Créer des classes et des objets en C++

C++Beginner
Pratiquer maintenant

Introduction

Dans ce laboratoire (lab), vous apprendrez à créer des classes et des objets en programmation C++. Vous définirez des classes avec des membres de données privés, implémenterez des fonctions membres publiques, créerez des constructeurs avec différents paramètres, écrirez des destructeurs pour la libération des ressources, utiliserez des spécificateurs d'accès, implémenterez l'héritage entre les classes, redéfinirez les méthodes de la classe de base, créerez des fonctions amies (friend functions) pour le contrôle d'accès et utiliserez des membres et des méthodes statiques. Ces concepts sont fondamentaux pour la programmation orientée objet en C++ et vous fourniront une solide base pour la construction d'applications plus complexes.

Définir une classe avec des membres de données privés

Une classe en C++ est un modèle pour créer des objets. Elle définit un ensemble de propriétés (membres de données) et de méthodes (fonctions membres) que les objets créés à partir de cette classe auront. Les classes aident à organiser le code et à implémenter les principes de la programmation orientée objet tels que l'encapsulation, l'héritage et le polymorphisme.

La syntaxe de base pour définir une classe en C++ est la suivante :

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

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

Il existe trois spécificateurs d'accès en C++ qui contrôlent la visibilité et l'accessibilité des membres de classe :

  • private : Les membres déclarés comme privés sont accessibles uniquement à l'intérieur de la classe.
  • public : Les membres déclarés comme publics sont accessibles depuis l'extérieur de la classe.
  • protected : Les membres déclarés comme protégés sont accessibles à l'intérieur de la classe et par les instances de classes dérivées.

Dans cette étape, vous apprendrez à définir une classe avec des membres de données privés en C++. Les membres de données privés sont un concept essentiel en programmation orientée objet qui aide à encapsuler et à protéger l'état interne d'un objet.

Tout d'abord, ouvrez le WebIDE et accédez au répertoire ~/project. Créez un nouveau fichier appelé student.cpp :

touch ~/project/student.cpp

Ouvrez le fichier student.cpp dans le WebIDE et ajoutez le code suivant pour définir une classe Student avec des membres de données privés :

#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;
}

Décortiquons les concepts clés :

  1. Membres de données privés :

    • Déclarés à l'aide du spécificateur d'accès private:
    • Ne peuvent pas être directement accessibles depuis l'extérieur de la classe
    • Fournissent une protection des données et une encapsulation
  2. Types de données :

    • std::string name : Stocke le nom de l'étudiant
    • int age : Stocke l'âge de l'étudiant
    • double gpa : Stocke la moyenne générale de l'étudiant
  3. Encapsulation :

    • Les membres privés ne peuvent être accessibles que via des méthodes publiques
    • Empêche la modification directe des données internes

Compilez le programme :

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

Exemple de sortie lors de l'exécution du programme :

Name:
Age: 0
GPA: 0

Points clés :

  • Les membres privés sont masqués à l'accès extérieur
  • Ils ne peuvent être modifiés que via les méthodes de classe
  • Cela aide à maintenir l'intégrité et le contrôle des données

Implémenter des fonctions membres publiques

Dans cette étape, vous apprendrez à implémenter des fonctions membres publiques en C++. Les fonctions membres publiques permettent un accès contrôlé aux membres de données privés et offrent des moyens d'interagir avec les objets de classe.

Ouvrez le fichier student.cpp dans le WebIDE et modifiez la classe Student pour inclure des fonctions membres publiques :

#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;
}

Compilez et exécutez le programme :

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

Exemple de sortie :

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

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

Points clés concernant les fonctions membres publiques :

  • Fournissent un accès contrôlé aux membres de données privés
  • Les mutateurs (setters) permettent la modification avec validation
  • Les accesseurs (getters) permettent de lire les données privées
  • Aident à maintenir l'encapsulation et l'intégrité des données

Créer des constructeurs avec différents paramètres

Dans cette étape, vous apprendrez à créer des constructeurs avec différents paramètres en C++. Les constructeurs sont des fonctions membres spéciales qui initialisent les objets lorsqu'ils sont créés.

Ouvrez le fichier student.cpp dans le WebIDE et modifiez la classe Student pour inclure plusieurs constructeurs :

#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;
}

Compilez et exécutez le programme :

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

Exemple de sortie :

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

Points clés concernant les constructeurs :

  • Les constructeurs ont le même nom que la classe
  • Ils initialisent les membres de données de l'objet
  • On peut avoir plusieurs constructeurs avec différents paramètres
  • Ils sont appelés automatiquement lorsqu'un objet est créé

Écrire un destructeur pour la libération des ressources

Dans cette étape, vous apprendrez à propos des destructeurs en C++, qui sont des fonctions membres spéciales chargées de libérer les ressources lorsqu'un objet est détruit. Nous allons montrer comment écrire un destructeur et comprendre son importance dans la gestion de la mémoire.

Ouvrez le fichier student.cpp dans le WebIDE et modifiez le code pour inclure un destructeur et une allocation dynamique de mémoire :

#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;
}

Compilez et exécutez le programme :

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

Exemple de sortie :

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

Points clés concernant les destructeurs :

  • Définis avec ~ suivi du nom de la classe
  • Appelés automatiquement lorsqu'un objet est détruit
  • Utilisés pour libérer les ressources allouées dynamiquement
  • Aident à prévenir les fuites de mémoire
  • N'ont pas de type de retour et pas de paramètres

Caractéristiques importantes des destructeurs :

  • Appelés lorsque l'objet sort de portée
  • Invoqués automatiquement par le compilateur
  • Cruciaux pour la libération de la mémoire dynamique
  • Aident à gérer efficacement les ressources système

Utiliser les spécificateurs d'accès (public, private, protected)

Dans cette étape, vous apprendrez à propos des spécificateurs d'accès en C++ et à savoir comment ils contrôlent la visibilité et l'accessibilité des membres de classe. Nous allons explorer les différences entre les niveaux d'accès public, privé et protégé.

Ouvrez le fichier student.cpp dans le WebIDE et modifiez le code pour démontrer les spécificateurs d'accès :

#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;
}

Compilez et exécutez le programme :

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

Exemple de sortie :

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

Points clés concernant les spécificateurs d'accès :

  • private : Les membres ne sont accessibles qu'au sein de la même classe
  • protected : Les membres sont accessibles au sein de la classe et de ses classes dérivées
  • public : Les membres sont accessibles depuis n'importe où
  • Aident à contrôler l'accès aux données et à maintenir l'encapsulation

Implémenter l'héritage entre les classes

Dans cette étape, vous apprendrez à propos de l'héritage en C++, un concept fondamental de la programmation orientée objet qui permet de créer de nouvelles classes à partir de classes existantes.

Ouvrez le fichier student.cpp dans le WebIDE et modifiez le code pour démontrer l'héritage :

#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;
}

Compilez et exécutez le programme :

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

Exemple de sortie :

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

Points clés concernant l'héritage :

  • La classe de base (Person) contient des attributs communs
  • Les classes dérivées (Student, Employee) héritent de la classe de base
  • Utilisez : public BaseClassName pour hériter
  • On peut ajouter de nouveaux attributs et méthodes dans les classes dérivées
  • On peut utiliser les méthodes de la classe de base dans les classes dérivées

Surcharger les méthodes de la classe de base

Dans cette étape, vous apprendrez à surcharger les méthodes de la classe de base en C++, ce qui permet aux classes dérivées de fournir leur propre implémentation des méthodes héritées de la classe de base.

Ouvrez le fichier student.cpp dans le WebIDE et modifiez le code pour démontrer la surcharge de méthodes :

#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;
}

Compilez et exécutez le programme :

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

Exemple de sortie :

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!

Points clés concernant la surcharge de méthodes :

  • Utilisez le mot-clé virtual dans la classe de base pour permettre la surcharge
  • Utilisez le mot-clé override dans la classe dérivée pour surcharger explicitement
  • Vous pouvez appeler la méthode de la classe de base en utilisant BaseClass::method()
  • Permet d'avoir différentes implémentations pour la même méthode
  • Permet le comportement polymorphique

Créer des fonctions amies pour le contrôle d'accès

Dans cette étape, vous apprendrez à propos des fonctions amies (friend functions) en C++, qui permettent à des fonctions externes ou à d'autres classes d'accéder aux membres privés et protégés d'une classe.

Ouvrez le fichier student.cpp dans le WebIDE et modifiez le code pour démontrer les fonctions amies :

#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;
}

Compilez et exécutez le programme :

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

Exemple de sortie :

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

Points clés concernant les fonctions amies :

  • Déclarées en utilisant le mot-clé friend
  • Peuvent accéder aux membres privés et protégés d'une classe
  • Déclarées à l'intérieur de la définition de la classe
  • Peuvent être des fonctions individuelles ou des classes entières
  • Enfreignent l'encapsulation, donc utilisez-les avec modération

Utiliser les membres et les méthodes statiques

Dans cette étape, vous apprendrez à propos des membres et méthodes statiques en C++, qui sont partagés entre toutes les instances d'une classe et appartiennent à la classe elle - même plutôt qu'aux objets individuels.

Ouvrez le fichier student.cpp dans le WebIDE et modifiez le code pour démontrer les membres et méthodes statiques :

#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;
}

Compilez et exécutez le programme :

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

Exemple de sortie :

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

Points clés concernant les membres et méthodes statiques :

  • Partagés entre toutes les instances d'une classe
  • Déclarés en utilisant le mot - clé static
  • Peuvent être accédés sans créer d'objet
  • Appartiennent à la classe, pas aux objets individuels
  • Utiles pour suivre les informations au niveau de la classe

Résumé

Dans ce laboratoire, vous avez appris à définir une classe avec des membres de données privés, ce qui est un concept essentiel en programmation orientée objet. Les membres de données privés aident à encapsuler et à protéger l'état interne d'un objet. Vous avez également appris l'importance des fonctions membres publiques, qui permettent un accès contrôlé aux membres de données privés. Cela contribue à maintenir l'intégrité et le contrôle des données. De plus, vous avez exploré l'utilisation des constructeurs, des destructeurs, des spécificateurs d'accès, de l'héritage, de la surcharge de méthodes, des fonctions amies (friend functions) ainsi que des membres et méthodes statiques, tous éléments qui constituent des principes fondamentaux de la programmation orientée objet en C++.