Kant1/French_Wikibooks_articles · Datasets at Hugging Face

text stringlengths 0 211k
Parmi les fonctions membres, on distingue :
Déclaration.
La déclaration d'une fonction membre se fait de la même manière qu'une fonction régulière mais au sein de la portée de la classe. En outre, on pourra la suffixer du mot clé "const" pour signifier qu'il s'agit d'un accesseur.
class A
public:
int getValue() const;
void setValue(int value);
private:
int value;
Définition.
Dans le cas d'une définition au sein de la classe même, elle est faite comme une fonction régulière. Dans ce cas, la fonction membre est automatiquement considérée comme "inline".
Dans le cas d'une définition en dehors de la classe, il faudra préfixer le nom de la fonction membre par le nom de la classe suivi de l'opérateur de portée (::). Dans ce cas, elle est automatiquement considérée comme non "inline".
class A
public:
int getValue() const { return this->value; } // définition au sein de la classe
void setValue(int value);
void print() const;
private:
int value;
inline void A::setValue(int value) // définition au sein de la classe (inline)
this->value = value;
void A::print() const // définition en dehors de la classe (non inline)
std::cout « "Value=" « this->value « std::endl;
En règle générale, les fonctions membres non "inline" devront être déclarées dans le fichier source .cpp de la classe, pour éviter d'avoir plusieurs fois la même définition au moment de l'édition des liens, et les fonctions membres "inline" devront être déclarées dans le fichier d'entête .hpp de la classe, pour permettre au compilateur de générer le code à chaque appel de la fonction.
Constructeurs et destructeur.
Les constructeurs et destructeur d'une classe sont des fonctions membres particulières de cette classe.
Destructeur.
Le destructeur d'une classe est appelé lorsqu'une de ses instances doit être détruite. Cela arrive à la fin de l'exécution d'une fonction/méthode lors d'une allocation dynamique : si vous avez déclaré, localement à une fonction/méthode, un élément d'une classe A par "A toto;" alors à la fin de l'exécution de la fonction/méthode, le destructeur de la classe est appelé automatiquement. Il est également appelé lorsqu'on détruit une instance avec codice_6.
Il ne peut y avoir qu'un seul destructeur pour une même classe. S'il n'est pas explicitement présent dans la classe, il sera généré par le compilateur. La syntaxe est similaire à celle du constructeur, à ceci près que le destructeur est introduit par un tilde et qu'il ne reçoit aucun argument :
codice_7
Un appel explicite avec codice_6 est nécessaire lorsqu'une instance a été allouée avec codice_5. Dans le cas contraire, si le pointeur est détruit sans appeler le destructeur, l'instance ne sera pas réellement supprimée et persistera en mémoire mais sans être accessible, ce qui occasionnera ce qu'on appelle une fuite de mémoire.
Exemples de classes.
Dans cet exemple de classe, les fichiers Point.h, Point.cpp et main.cpp vont vous être exposés. Tout d'abord, Point.h:
using namespace std;
class Point
public:
// Constructeurs
Point();
Point(double x, double y);
//Accesseurs et mutateurs
void setX(double x);
void setY(double y);
double getX() const;
double getY() const;
// Autres méthodes
double distance(const Point &P) const;
Point milieu(const Point &P) const;
void saisir();
void afficher() const;
private:
double x,y;
Voici le fichier Point.cpp:
using namespace std;
Point::Point() : x(0), y(0)
Point::Point(double x, double y) : x(x), y(y)
void Point::setX(double x)
this->x = x;
void Point::setY(double y)
this->y = y;
double Point::getX() const
return this->x;
double Point::getY() const
return this->y;
double Point::distance(const Point &P) const
double dx = this->x - P.x;
double dy = this->y - P.y;
return sqrt(dxdx + dydy);
Point Point::milieu(const Point &P) const
Point result;
result.x = (P.x + this->x) / 2;
result.y = (P.y + this->y) / 2;
return result;
void Point::saisir()
cout « "Tapez l'abscisse : "; cin » this->x;
cout « "Tapez l'ordonnée : "; cin » this->y;
void Point::afficher() const
cout « "L'abscisse vaut " « this->x « endl;
cout « "L'ordonnée vaut " « this->y « endl;
Et le fichier principal main.cpp:
using namespace std;
int main()
Point A, B, C;
double d;
cout « "SAISIE DU POINT A" « endl;
A.saisir();
cout « endl;
cout « "SAISIE DU POINT B" « endl;
B.saisir();
cout « endl;
C = A.milieu(B);
d = A.distance(B);
cout « "MILIEU DE AB" « endl;
C.afficher();
cout « endl;
cout « "La distance AB vaut : " « d « endl;
return 0;
Les opérateurs new et delete.
Il est parfois intéressant de créer dynamiquement de nouvelles instances d'une classe. Cela s'avère indispensable lorsque vous manipulez certaines structures de données complexes. L'opérateur codice_5 permet de créer une nouvelle instance d'une classe codice_11 en écrivant :
A* pointeur=new A; // Ou bien:
A* pointeur=new A();

Parmi les fonctions membres, on distingue :

Déclaration.

La déclaration d'une fonction membre se fait de la même manière qu'une fonction régulière mais au sein de la portée de la classe. En outre, on pourra la suffixer du mot clé "const" pour signifier qu'il s'agit d'un accesseur.

class A

public:

int getValue() const;

void setValue(int value);

private:

int value;

Définition.

Dans le cas d'une définition au sein de la classe même, elle est faite comme une fonction régulière. Dans ce cas, la fonction membre est automatiquement considérée comme "inline".

Dans le cas d'une définition en dehors de la classe, il faudra préfixer le nom de la fonction membre par le nom de la classe suivi de l'opérateur de portée (::). Dans ce cas, elle est automatiquement considérée comme non "inline".

class A

public:

int getValue() const { return this->value; } // définition au sein de la classe

void setValue(int value);

void print() const;

private:

int value;

inline void A::setValue(int value) // définition au sein de la classe (inline)

this->value = value;

void A::print() const // définition en dehors de la classe (non inline)

std::cout « "Value=" « this->value « std::endl;

En règle générale, les fonctions membres non "inline" devront être déclarées dans le fichier source .cpp de la classe, pour éviter d'avoir plusieurs fois la même définition au moment de l'édition des liens, et les fonctions membres "inline" devront être déclarées dans le fichier d'entête .hpp de la classe, pour permettre au compilateur de générer le code à chaque appel de la fonction.

Constructeurs et destructeur.

Les constructeurs et destructeur d'une classe sont des fonctions membres particulières de cette classe.

Destructeur.

Le destructeur d'une classe est appelé lorsqu'une de ses instances doit être détruite. Cela arrive à la fin de l'exécution d'une fonction/méthode lors d'une allocation dynamique : si vous avez déclaré, localement à une fonction/méthode, un élément d'une classe A par "A toto;" alors à la fin de l'exécution de la fonction/méthode, le destructeur de la classe est appelé automatiquement. Il est également appelé lorsqu'on détruit une instance avec codice_6.

Il ne peut y avoir qu'un seul destructeur pour une même classe. S'il n'est pas explicitement présent dans la classe, il sera généré par le compilateur. La syntaxe est similaire à celle du constructeur, à ceci près que le destructeur est introduit par un tilde et qu'il ne reçoit aucun argument :

codice_7

Un appel explicite avec codice_6 est nécessaire lorsqu'une instance a été allouée avec codice_5. Dans le cas contraire, si le pointeur est détruit sans appeler le destructeur, l'instance ne sera pas réellement supprimée et persistera en mémoire mais sans être accessible, ce qui occasionnera ce qu'on appelle une fuite de mémoire.

Exemples de classes.

Dans cet exemple de classe, les fichiers Point.h, Point.cpp et main.cpp vont vous être exposés. Tout d'abord, Point.h:

using namespace std;

class Point

public:

// Constructeurs

Point();

Point(double x, double y);

//Accesseurs et mutateurs

void setX(double x);

void setY(double y);

double getX() const;

double getY() const;

// Autres méthodes

double distance(const Point &P) const;

Point milieu(const Point &P) const;

void saisir();

void afficher() const;

private:

double x,y;

Voici le fichier Point.cpp:

using namespace std;

Point::Point() : x(0), y(0)

Point::Point(double x, double y) : x(x), y(y)

void Point::setX(double x)

this->x = x;

void Point::setY(double y)

this->y = y;

double Point::getX() const

return this->x;

double Point::getY() const

return this->y;

double Point::distance(const Point &P) const

double dx = this->x - P.x;

double dy = this->y - P.y;

return sqrt(dx*dx + dy*dy);

Point Point::milieu(const Point &P) const

Point result;

result.x = (P.x + this->x) / 2;

result.y = (P.y + this->y) / 2;

return result;

void Point::saisir()

cout « "Tapez l'abscisse : "; cin » this->x;

cout « "Tapez l'ordonnée : "; cin » this->y;

void Point::afficher() const

cout « "L'abscisse vaut " « this->x « endl;

cout « "L'ordonnée vaut " « this->y « endl;

Et le fichier principal main.cpp:

using namespace std;

int main()

Point A, B, C;

double d;

cout « "SAISIE DU POINT A" « endl;

A.saisir();

cout « endl;

cout « "SAISIE DU POINT B" « endl;

B.saisir();

cout « endl;

C = A.milieu(B);

d = A.distance(B);

cout « "MILIEU DE AB" « endl;

C.afficher();

cout « endl;

cout « "La distance AB vaut : " « d « endl;

return 0;

Les opérateurs new et delete.

Il est parfois intéressant de créer dynamiquement de nouvelles instances d'une classe. Cela s'avère indispensable lorsque vous manipulez certaines structures de données complexes. L'opérateur codice_5 permet de créer une nouvelle instance d'une classe codice_11 en écrivant :

A* pointeur=new A; // Ou bien:

A* pointeur=new A();