Klassen und Objekte in C++ erstellen

Einführung

In diesem Lab werden Sie lernen, wie Sie Klassen und Objekte in der C++-Programmierung erstellen. Sie werden Klassen mit privaten Datenelementen definieren, öffentliche Memberfunktionen implementieren, Konstruktoren mit verschiedenen Parametern erstellen, Destruktoren für die Ressourcenbereinigung schreiben, Zugriffsspezifizierer verwenden, Vererbung zwischen Klassen implementieren, Methoden der Basisklasse überschreiben, Freundesfunktionen für die Zugriffskontrolle erstellen und statische Member und Methoden nutzen. Diese Konzepte sind grundlegend für die objektorientierte Programmierung in C++ und bilden eine solide Grundlage für das Erstellen komplexerer Anwendungen.

Skills Graph

Definition einer Klasse mit privaten Datenelementen

Eine Klasse in C++ ist ein Bauplan für die Erstellung von Objekten. Sie definiert eine Reihe von Eigenschaften (Datenelemente) und Methoden (Memberfunktionen), die die aus der Klasse erstellten Objekte haben werden. Klassen helfen bei der Organisation von Code und bei der Umsetzung von Prinzipien der objektorientierten Programmierung wie Kapselung, Vererbung und Polymorphismus.

Die grundlegende Syntax für die Definition einer Klasse in C++ lautet wie folgt:

class ClassName {
private:
    // Private data members
    int dataMember1;
    std::string dataMember2;

public:
    // Public member functions
    void memberFunction1();
    int memberFunction2();
};

Es gibt drei Zugriffsspezifizierer in C++, die die Sichtbarkeit und Zugänglichkeit von Klassenelementen steuern:

• private: Elemente, die als privat deklariert sind, sind nur innerhalb der Klasse zugänglich.
• public: Elemente, die als öffentlich deklariert sind, sind von außerhalb der Klasse zugänglich.
• protected: Elemente, die als geschützt deklariert sind, sind innerhalb der Klasse und durch Instanzen abgeleiteter Klassen zugänglich.

In diesem Schritt werden Sie lernen, wie Sie eine Klasse mit privaten Datenelementen in C++ definieren. Private Datenelemente sind ein wesentliches Konzept in der objektorientierten Programmierung, das hilft, den internen Zustand eines Objekts zu kapseln und zu schützen.

Öffnen Sie zunächst die WebIDE und navigieren Sie zum Verzeichnis ~/project. Erstellen Sie eine neue Datei namens student.cpp:

touch ~/project/student.cpp

Öffnen Sie die Datei student.cpp in der WebIDE und fügen Sie den folgenden Code hinzu, um eine Student-Klasse mit privaten Datenelementen zu definieren:

#include <iostream>
#include <string>

class Student {
private:
    // Private data members
    std::string name;
    int age;
    double gpa;

public:
    // We'll add methods to interact with these private members in later steps
    void displayInfo() {
        std::cout << "Name: " << name << std::endl;
        std::cout << "Age: " << age << std::endl;
        std::cout << "GPA: " << gpa << std::endl;
    }
};

int main() {
    Student student;
    // Note: We can't directly access private members
    // student.name = "John"; // This would cause a compilation error

    student.displayInfo();
    return 0;
}

Lassen Sie uns die wichtigsten Konzepte aufschlüsseln:

1. Private Datenelemente:

   • Mit dem Zugriffsspezifizierer private: deklariert
   • Können nicht direkt von außerhalb der Klasse zugegriffen werden
   • Bieten Datenschutz und Kapselung

2. Datentypen:

   • std::string name: Speichert den Namen des Schülers
   • int age: Speichert das Alter des Schülers
   • double gpa: Speichert die Durchschnittsnote des Schülers

3. Kapselung:

   • Private Elemente können nur über öffentliche Methoden zugegriffen werden
   • Verhindert die direkte Modifikation interner Daten

Kompilieren Sie das Programm:

g++ student.cpp -o student
./student

Beispielausgabe beim Ausführen des Programms:

Name:
Age: 0
GPA: 0

Wichtige Punkte:

• Private Elemente sind vor externem Zugriff verborgen
• Sie können nur über Klassenmethoden modifiziert werden
• Dies hilft, die Datenintegrität und -kontrolle aufrechtzuerhalten

Implementierung öffentlicher Memberfunktionen

In diesem Schritt werden Sie lernen, wie Sie öffentliche Memberfunktionen in C++ implementieren. Öffentliche Memberfunktionen ermöglichen einen kontrollierten Zugriff auf private Datenelemente und bieten Möglichkeiten zur Interaktion mit Klassenobjekten.

Öffnen Sie die Datei student.cpp in der WebIDE und ändern Sie die Student-Klasse so, dass sie öffentliche Memberfunktionen enthält:

#include <iostream>
#include <string>

class Student {
private:
    std::string name;
    int age;
    double gpa;

public:
    // Setter methods to modify private data members
    void setName(std::string studentName) {
        name = studentName;
    }

    void setAge(int studentAge) {
        if (studentAge > 0 && studentAge < 120) {
            age = studentAge;
        } else {
            std::cout << "Invalid age!" << std::endl;
        }
    }

    void setGPA(double studentGPA) {
        if (studentGPA >= 0.0 && studentGPA <= 4.0) {
            gpa = studentGPA;
        } else {
            std::cout << "Invalid GPA!" << std::endl;
        }
    }

    // Getter methods to access private data members
    std::string getName() {
        return name;
    }

    int getAge() {
        return age;
    }

    double getGPA() {
        return gpa;
    }

    // Display method to print student information
    void displayInfo() {
        std::cout << "Student Information:" << std::endl;
        std::cout << "Name: " << name << std::endl;
        std::cout << "Age: " << age << std::endl;
        std::cout << "GPA: " << gpa << std::endl;
    }
};

int main() {
    Student student;

    // Using public member functions to set and get data
    student.setName("Alice Johnson");
    student.setAge(20);
    student.setGPA(3.75);

    // Display student information
    student.displayInfo();

    // Demonstrate getter methods
    std::cout << "\nStudent Name: " << student.getName() << std::endl;
    std::cout << "Student Age: " << student.getAge() << std::endl;
    std::cout << "Student GPA: " << student.getGPA() << std::endl;

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ student.cpp -o student
./student

Beispielausgabe:

Student Information:
Name: Alice Johnson
Age: 20
GPA: 3.75

Student Name: Alice Johnson
Student Age: 20
Student GPA: 3.75

Wichtige Punkte zu öffentlichen Memberfunktionen:

• Bieten kontrollierten Zugriff auf private Datenelemente
• Setter ermöglichen die Modifikation mit Validierung
• Getter ermöglichen das Lesen privater Daten
• Helfen bei der Aufrechterhaltung von Kapselung und Datenintegrität

Erstellung von Konstruktoren mit verschiedenen Parametern

In diesem Schritt werden Sie lernen, wie Sie in C++ Konstruktoren mit verschiedenen Parametern erstellen. Konstruktoren sind spezielle Memberfunktionen, die Objekte beim Erstellen initialisieren.

Öffnen Sie die Datei student.cpp in der WebIDE und ändern Sie die Student-Klasse so, dass sie mehrere Konstruktoren enthält:

#include <iostream>
#include <string>

class Student {
private:
    std::string name;
    int age;
    double gpa;

public:
    // Default constructor
    Student() {
        name = "Unknown";
        age = 0;
        gpa = 0.0;
    }

    // Constructor with name parameter
    Student(std::string studentName) {
        name = studentName;
        age = 0;
        gpa = 0.0;
    }

    // Constructor with name and age parameters
    Student(std::string studentName, int studentAge) {
        name = studentName;
        age = studentAge;
        gpa = 0.0;
    }

    // Full constructor with all parameters
    Student(std::string studentName, int studentAge, double studentGPA) {
        name = studentName;
        age = studentAge;
        gpa = studentGPA;
    }

    // Display method to print student information
    void displayInfo() {
        std::cout << "Student Information:" << std::endl;
        std::cout << "Name: " << name << std::endl;
        std::cout << "Age: " << age << std::endl;
        std::cout << "GPA: " << gpa << std::endl;
    }
};

int main() {
    // Using different constructors
    Student student1;  // Default constructor
    Student student2("Alice Johnson");  // Constructor with name
    Student student3("Bob Smith", 22);  // Constructor with name and age
    Student student4("Charlie Brown", 20, 3.75);  // Full constructor

    std::cout << "Student 1:" << std::endl;
    student1.displayInfo();

    std::cout << "\nStudent 2:" << std::endl;
    student2.displayInfo();

    std::cout << "\nStudent 3:" << std::endl;
    student3.displayInfo();

    std::cout << "\nStudent 4:" << std::endl;
    student4.displayInfo();

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ student.cpp -o student
./student

Beispielausgabe:

Student 1:
Student Information:
Name: Unknown
Age: 0
GPA: 0

Student 2:
Student Information:
Name: Alice Johnson
Age: 0
GPA: 0

Student 3:
Student Information:
Name: Bob Smith
Age: 22
GPA: 0

Student 4:
Student Information:
Name: Charlie Brown
Age: 20
GPA: 3.75

Wichtige Punkte zu Konstruktoren:

• Konstruktoren haben den gleichen Namen wie die Klasse.
• Sie initialisieren die Datenelemente eines Objekts.
• Es können mehrere Konstruktoren mit verschiedenen Parametern existieren.
• Sie werden automatisch aufgerufen, wenn ein Objekt erstellt wird.

Schreiben eines Destruktors zur Ressourcenbereinigung

In diesem Schritt werden Sie sich mit Destruktoren in C++ befassen. Destruktoren sind spezielle Memberfunktionen, die für die Bereinigung von Ressourcen verantwortlich sind, wenn ein Objekt zerstört wird. Wir werden zeigen, wie man einen Destruktor schreibt und warum er für die Speicherverwaltung wichtig ist.

Öffnen Sie die Datei student.cpp in der WebIDE und ändern Sie den Code so, dass er einen Destruktor und dynamische Speicherzuweisung enthält:

#include <iostream>
#include <string>

class Student {
private:
    std::string name;
    int age;
    double gpa;
    char* dynamicBuffer;  // Simulating dynamic memory allocation

public:
    // Constructors
    Student() {
        name = "Unknown";
        age = 0;
        gpa = 0.0;
        dynamicBuffer = new char[50];  // Allocate dynamic memory
        std::cout << "Default Constructor Called" << std::endl;
    }

    Student(std::string studentName) : name(studentName), age(0), gpa(0.0) {
        dynamicBuffer = new char[50];
        std::cout << "Parameterized Constructor Called" << std::endl;
    }

    // Destructor
    ~Student() {
        // Clean up dynamically allocated memory
        delete[] dynamicBuffer;
        std::cout << "Destructor Called for " << name << std::endl;
    }

    void displayInfo() {
        std::cout << "Student Information:" << std::endl;
        std::cout << "Name: " << name << std::endl;
        std::cout << "Age: " << age << std::endl;
        std::cout << "GPA: " << gpa << std::endl;
    }
};

int main() {
    // Demonstrating object creation and destruction
    {
        std::cout << "Creating first student:" << std::endl;
        Student student1("Alice Johnson");
        student1.displayInfo();

        std::cout << "\nCreating second student:" << std::endl;
        Student student2("Bob Smith");
        student2.displayInfo();
    }  // Objects go out of scope here, destructors are called

    std::cout << "\nExiting main function" << std::endl;
    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ student.cpp -o student
./student

Beispielausgabe:

Creating first student:
Parameterized Constructor Called
Student Information:
Name: Alice Johnson
Age: 0
GPA: 0

Creating second student:
Parameterized Constructor Called
Student Information:
Name: Bob Smith
Age: 0
GPA: 0

Destructor Called for Bob Smith
Destructor Called for Alice Johnson

Exiting main function

Wichtige Punkte zu Destruktoren:

• Definiert mit ~ gefolgt vom Klassennamen
• Wird automatisch aufgerufen, wenn ein Objekt zerstört wird
• Wird verwendet, um dynamisch zugewiesene Ressourcen freizugeben
• Hilft, Speicherlecks zu vermeiden
• Kein Rückgabetyp und keine Parameter

Wichtige Eigenschaften von Destruktoren:

• Wird aufgerufen, wenn ein Objekt außerhalb des Gültigkeitsbereichs geht
• Wird automatisch vom Compiler aufgerufen
• Ist entscheidend für die Bereinigung von dynamischem Speicher
• Hilft, Systemressourcen effizient zu verwalten

Verwendung von Zugriffsspezifizierern (public, private, protected)

In diesem Schritt werden Sie sich mit Zugriffsspezifizierern in C++ befassen und lernen, wie sie die Sichtbarkeit und Zugänglichkeit von Klassenelementen steuern. Wir werden die Unterschiede zwischen öffentlichen, privaten und geschützten Zugriffsebenen untersuchen.

Öffnen Sie die Datei student.cpp in der WebIDE und ändern Sie den Code, um die Zugriffsspezifizierer zu demonstrieren:

#include <iostream>
#include <string>

class Student {
private:
    // Private members: accessible only within the class
    std::string name;
    int age;
    double gpa;

protected:
    // Protected members: accessible within the class and its derived classes
    std::string school;

public:
    // Public members: accessible from anywhere
    Student(std::string studentName, int studentAge, double studentGPA) {
        name = studentName;
        age = studentAge;
        gpa = studentGPA;
        school = "Default School";
    }

    // Public method to demonstrate access to private members
    void displayInfo() {
        std::cout << "Student Information:" << std::endl;
        std::cout << "Name: " << name << std::endl;  // Accessing private member
        std::cout << "Age: " << age << std::endl;
        std::cout << "GPA: " << gpa << std::endl;
        std::cout << "School: " << school << std::endl;
    }

    // Public method to modify private members
    void updateGPA(double newGPA) {
        if (newGPA >= 0.0 && newGPA <= 4.0) {
            gpa = newGPA;
        }
    }
};

class GraduateStudent : public Student {
public:
    GraduateStudent(std::string name, int age, double gpa)
        : Student(name, age, gpa) {
        // Can access protected 'school' member from base class
        school = "Graduate School";
    }

    void displaySchool() {
        std::cout << "School: " << school << std::endl;
    }
};

int main() {
    Student student("Alice Johnson", 20, 3.75);
    student.displayInfo();  // Public method accessing private members

    // Uncommenting the lines below would cause compilation errors
    // student.name = "John";  // Error: Cannot access private member
    // student.age = 25;       // Error: Cannot access private member

    student.updateGPA(3.90);  // Modifying private member through public method
    student.displayInfo();

    GraduateStudent gradStudent("Bob Smith", 25, 3.90);
    gradStudent.displayInfo();
    gradStudent.displaySchool();

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ student.cpp -o student
./student

Beispielausgabe:

Student Information:
Name: Alice Johnson
Age: 20
GPA: 3.75
School: Default School
Student Information:
Name: Alice Johnson
Age: 20
GPA: 3.90
School: Default School
Student Information:
Name: Bob Smith
Age: 25
GPA: 3.90
School: Graduate School
School: Graduate School

Wichtige Punkte zu Zugriffsspezifizierern:

• private: Elemente sind nur innerhalb derselben Klasse zugänglich.
• protected: Elemente sind innerhalb der Klasse und ihrer abgeleiteten Klassen zugänglich.
• public: Elemente sind von überall zugänglich.
• Sie helfen bei der Steuerung des Datenzugriffs und der Aufrechterhaltung der Kapselung.

Implementierung von Vererbung zwischen Klassen

In diesem Schritt werden Sie sich mit Vererbung in C++ befassen, einem grundlegenden Konzept der objektorientierten Programmierung, das es ermöglicht, neue Klassen auf der Grundlage bestehender Klassen zu erstellen.

Öffnen Sie die Datei student.cpp in der WebIDE und ändern Sie den Code, um Vererbung zu demonstrieren:

#include <iostream>
#include <string>

// Base class
class Person {
protected:
    std::string name;
    int age;

public:
    // Constructor
    Person(std::string personName, int personAge) {
        name = personName;
        age = personAge;
    }

    // Method to display basic information
    void displayInfo() {
        std::cout << "Name: " << name << std::endl;
        std::cout << "Age: " << age << std::endl;
    }
};

// Derived class: Student inherits from Person
class Student : public Person {
private:
    double gpa;
    std::string major;

public:
    // Constructor that calls base class constructor
    Student(std::string studentName, int studentAge, double studentGPA, std::string studentMajor)
        : Person(studentName, studentAge) {
        gpa = studentGPA;
        major = studentMajor;
    }

    // Additional method specific to Student
    void displayStudentInfo() {
        // Calling base class method
        displayInfo();
        std::cout << "GPA: " << gpa << std::endl;
        std::cout << "Major: " << major << std::endl;
    }
};

// Another derived class: Employee inherits from Person
class Employee : public Person {
private:
    std::string company;
    double salary;

public:
    // Constructor that calls base class constructor
    Employee(std::string employeeName, int employeeAge, std::string employeeCompany, double employeeSalary)
        : Person(employeeName, employeeAge) {
        company = employeeCompany;
        salary = employeeSalary;
    }

    // Additional method specific to Employee
    void displayEmployeeInfo() {
        // Calling base class method
        displayInfo();
        std::cout << "Company: " << company << std::endl;
        std::cout << "Salary: $" << salary << std::endl;
    }
};

int main() {
    // Creating objects of derived classes
    Student student("Alice Johnson", 20, 3.75, "Computer Science");
    std::cout << "Student Information:" << std::endl;
    student.displayStudentInfo();

    std::cout << "\n";

    Employee employee("Bob Smith", 35, "Tech Corp", 75000.0);
    std::cout << "Employee Information:" << std::endl;
    employee.displayEmployeeInfo();

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ student.cpp -o student
./student

Beispielausgabe:

Student Information:
Name: Alice Johnson
Age: 20
GPA: 3.75
Major: Computer Science

Employee Information:
Name: Bob Smith
Age: 35
Company: Tech Corp
Salary: $75000

Wichtige Punkte zu Vererbung:

• Basisklasse (Person) enthält gemeinsame Attribute.
• Abgeleitete Klassen (Student, Employee) erben von der Basisklasse.
• Verwenden Sie : public Basisklassenname, um zu erben.
• Es können neue Attribute und Methoden in abgeleiteten Klassen hinzugefügt werden.
• Es können Methoden der Basisklasse in abgeleiteten Klassen verwendet werden.

Überschreiben von Methoden der Basisklasse

In diesem Schritt werden Sie lernen, wie Sie in C++ Methoden der Basisklasse überschreiben können. Dies ermöglicht es abgeleiteten Klassen, ihre eigene Implementierung von Methoden bereitzustellen, die von der Basisklasse geerbt wurden.

Öffnen Sie die Datei student.cpp in der WebIDE und ändern Sie den Code, um das Überschreiben von Methoden zu demonstrieren:

#include <iostream>
#include <string>

class Animal {
protected:
    std::string name;

public:
    Animal(std::string animalName) : name(animalName) {}

    // Virtual keyword allows method to be overridden
    virtual void makeSound() {
        std::cout << "Some generic animal sound" << std::endl;
    }

    // Virtual method for displaying information
    virtual void displayInfo() {
        std::cout << "Animal Name: " << name << std::endl;
    }
};

class Dog : public Animal {
private:
    std::string breed;

public:
    Dog(std::string dogName, std::string dogBreed)
        : Animal(dogName), breed(dogBreed) {}

    // Override makeSound method
    void makeSound() override {
        std::cout << "Woof! Woof!" << std::endl;
    }

    // Override displayInfo method
    void displayInfo() override {
        // Call base class method first
        Animal::displayInfo();
        std::cout << "Breed: " << breed << std::endl;
    }
};

class Cat : public Animal {
private:
    std::string color;

public:
    Cat(std::string catName, std::string catColor)
        : Animal(catName), color(catColor) {}

    // Override makeSound method
    void makeSound() override {
        std::cout << "Meow! Meow!" << std::endl;
    }

    // Override displayInfo method
    void displayInfo() override {
        // Call base class method first
        Animal::displayInfo();
        std::cout << "Color: " << color << std::endl;
    }
};

int main() {
    // Create animal objects
    Animal genericAnimal("Generic Animal");
    Dog myDog("Buddy", "Labrador");
    Cat myCat("Whiskers", "Orange");

    // Demonstrate polymorphic behavior
    std::cout << "Generic Animal:" << std::endl;
    genericAnimal.displayInfo();
    genericAnimal.makeSound();

    std::cout << "\nDog:" << std::endl;
    myDog.displayInfo();
    myDog.makeSound();

    std::cout << "\nCat:" << std::endl;
    myCat.displayInfo();
    myCat.makeSound();

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ student.cpp -o student
./student

Beispielausgabe:

Generic Animal:
Animal Name: Generic Animal
Some generic animal sound

Dog:
Animal Name: Buddy
Breed: Labrador
Woof! Woof!

Cat:
Animal Name: Whiskers
Color: Orange
Meow! Meow!

Wichtige Punkte zum Überschreiben von Methoden:

• Verwenden Sie das Schlüsselwort virtual in der Basisklasse, um das Überschreiben zu ermöglichen.
• Verwenden Sie das Schlüsselwort override in der abgeleiteten Klasse, um explizit zu überschreiben.
• Sie können die Methode der Basisklasse mit Basisklasse::Methode() aufrufen.
• Es ermöglicht verschiedene Implementierungen für dieselbe Methode.
• Es ermöglicht polymorphes Verhalten.

Erstellen von Friend-Funktionen zur Zugriffskontrolle

In diesem Schritt werden Sie sich mit Friend-Funktionen in C++ befassen. Friend-Funktionen ermöglichen es externen Funktionen oder anderen Klassen, auf private und geschützte Member einer Klasse zuzugreifen.

Öffnen Sie die Datei student.cpp in der WebIDE und ändern Sie den Code, um Friend-Funktionen zu demonstrieren:

#include <iostream>
#include <string>

class BankAccount {
private:
    std::string accountHolder;
    double balance;

    // Declare friend functions
    friend void displayAccountDetails(const BankAccount& account);
    friend class AccountManager;

public:
    // Constructor
    BankAccount(std::string name, double initialBalance) {
        accountHolder = name;
        balance = initialBalance;
    }

    // Method to deposit money
    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
};

// Friend function that can access private members
void displayAccountDetails(const BankAccount& account) {
    std::cout << "Account Holder: " << account.accountHolder << std::endl;
    std::cout << "Current Balance: $" << account.balance << std::endl;
}

// Friend class that can access private members
class AccountManager {
public:
    // Method that can access private members of BankAccount
    void transferFunds(BankAccount& from, BankAccount& to, double amount) {
        if (from.balance >= amount) {
            from.balance -= amount;
            to.balance += amount;
            std::cout << "Transfer successful!" << std::endl;
        } else {
            std::cout << "Insufficient funds!" << std::endl;
        }
    }
};

int main() {
    // Create bank accounts
    BankAccount account1("Alice Johnson", 1000.0);
    BankAccount account2("Bob Smith", 500.0);

    // Use friend function to display account details
    std::cout << "Account 1 Details:" << std::endl;
    displayAccountDetails(account1);

    std::cout << "\nAccount 2 Details:" << std::endl;
    displayAccountDetails(account2);

    // Use friend class to transfer funds
    AccountManager manager;
    std::cout << "\nTransferring $200 from Alice to Bob:" << std::endl;
    manager.transferFunds(account1, account2, 200.0);

    std::cout << "\nUpdated Account Details:" << std::endl;
    displayAccountDetails(account1);
    displayAccountDetails(account2);

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ student.cpp -o student
./student

Beispielausgabe:

Account 1 Details:
Account Holder: Alice Johnson
Current Balance: $1000

Account 2 Details:
Account Holder: Bob Smith
Current Balance: $500

Transferring $200 from Alice to Bob:
Transfer successful!

Updated Account Details:
Account Holder: Alice Johnson
Current Balance: $800
Account Holder: Bob Smith
Current Balance: $700

Wichtige Punkte zu Friend-Funktionen:

• Mit dem Schlüsselwort friend deklariert
• Können auf private und geschützte Member einer Klasse zugreifen
• Innerhalb der Klassendefinition deklariert
• Können einzelne Funktionen oder ganze Klassen sein
• Brechen die Kapselung auf, daher sparsam einsetzen

Verwendung von statischen Membern und Methoden

In diesem Schritt werden Sie sich mit statischen Membern und Methoden in C++ befassen. Statische Member und Methoden werden von allen Instanzen einer Klasse geteilt und gehören zur Klasse selbst, nicht zu einzelnen Objekten.

Öffnen Sie die Datei student.cpp in der WebIDE und ändern Sie den Code, um statische Member und Methoden zu demonstrieren:

#include <iostream>
#include <string>

class University {
private:
    std::string name;
    static int totalStudents;  // Static member variable
    static double totalTuition;  // Another static member variable

public:
    // Constructor
    University(std::string universityName) : name(universityName) {}

    // Method to add students
    void addStudents(int count) {
        totalStudents += count;
    }

    // Method to add tuition
    void addTuition(double amount) {
        totalTuition += amount;
    }

    // Static method to display total students
    static void displayTotalStudents() {
        std::cout << "Total Students Across All Universities: "
                  << totalStudents << std::endl;
    }

    // Static method to display total tuition
    static void displayTotalTuition() {
        std::cout << "Total Tuition Collected: $"
                  << totalTuition << std::endl;
    }

    // Static method to calculate average tuition
    static double calculateAverageTuition() {
        return (totalStudents > 0)?
               (totalTuition / totalStudents) : 0.0;
    }
};

// Initialize static member variables outside the class
int University::totalStudents = 0;
double University::totalTuition = 0.0;

int main() {
    // Create university objects
    University harvard("Harvard University");
    University mit("MIT");
    University stanford("Stanford University");

    // Add students and tuition
    harvard.addStudents(5000);
    harvard.addTuition(75000000.0);

    mit.addStudents(4500);
    mit.addTuition(65000000.0);

    stanford.addStudents(4200);
    stanford.addTuition(60000000.0);

    // Call static methods directly on the class
    std::cout << "University Statistics:" << std::endl;
    University::displayTotalStudents();
    University::displayTotalTuition();

    // Calculate and display average tuition
    std::cout << "Average Tuition per Student: $"
              << University::calculateAverageTuition() << std::endl;

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ student.cpp -o student
./student

Beispielausgabe:

University Statistics:
Total Students Across All Universities: 13700
Total Tuition Collected: $2e+08
Average Tuition per Student: $14598.5

Wichtige Punkte zu statischen Membern und Methoden:

• Werden von allen Instanzen einer Klasse geteilt
• Mit dem Schlüsselwort static deklariert
• Können ohne Erstellung eines Objekts zugegriffen werden
• Gehören zur Klasse, nicht zu einzelnen Objekten
• Nützlich zum Nachverfolgen von klassenweiten Informationen

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie eine Klasse mit privaten Datenelementen definieren, was ein wesentliches Konzept in der objektorientierten Programmierung ist. Private Datenelemente helfen dabei, den internen Zustand eines Objekts zu kapseln und zu schützen. Sie haben auch die Wichtigkeit von öffentlichen Memberfunktionen kennengelernt, die einen kontrollierten Zugriff auf private Datenelemente ermöglichen. Dies trägt zur Aufrechterhaltung der Datenintegrität und -kontrolle bei. Darüber hinaus haben Sie die Verwendung von Konstruktoren, Destruktoren, Zugriffsspezifizierern, Vererbung, Methodenüberschreibung, Friend-Funktionen sowie statischen Membern und Methoden untersucht, die alle grundlegende Prinzipien der objektorientierten Programmierung in C++ sind.