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 :
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
- Déclarés à l'aide du spécificateur d'accès
Types de données :
std::string name: Stocke le nom de l'étudiantint age: Stocke l'âge de l'étudiantdouble gpa: Stocke la moyenne générale de l'étudiant
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 classeprotected: Les membres sont accessibles au sein de la classe et de ses classes dérivéespublic: 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 BaseClassNamepour 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é
virtualdans la classe de base pour permettre la surcharge - Utilisez le mot-clé
overridedans 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++.
