Dans cette page, je décris un type propre au c++ :
c'est le type class, qui est à la base de la programmation objet.
En plus des types usuels du langage c, on trouve le type class, dans le c++
Les types usuels sont :
char short unsigned int long float double
L'instruction typedef du c est aussi utilisable en c++
typedef.cpp : l'instruction typedef
On peut définir de nouveaux types en utilisant l'instruction struct ou union Une structure du c permet de déclarer un ensemble de données. Par exemple :
struct adresse { char *nom; char *rue; int num; }
Les instructions ci-dessus déclarent la structure adresse, qui contient 3 champs (encore appelés membres) adresse est un nouveau type, et on peut l'utiliser, comme un type usuel, pour déclarer une variable du type adresse. Par exemple, l'instruction :
adresse monadresse;
déclare la variable mon adresse, du type adresse.
On accède aux membres d'une structure par l'opérateur . (point) par exemple monadresse.num=45; affecte la valeur 45 au membre num de la structure monadresse.
Une classe du c++ généralise la notion de structure du c, en permettant d'écrire parmi les champs, en plus des données, des fonctions qui permettent d'opérer sur ces données.
L'idée d'une structure du c est de manipuler un ensemble de données, dans un seul enregistrement.
La notion de classe du c++, permet de regrouper les données et les fonctions qui les manipulent, dans un même enregistrement, pour une plus grande fiabilité.
class1.cpp : premier exemple d'une classe, dont tous les champs sont publics
Mais il y a plus encore.
On peut donner aux champs d'une classe, des accès privés, protégés ou publics, en utilisant les mots-réservés :
private protected ou public
Par exemple :
class personne
{
protected :
int age;
public :
void affiche(void)
{
cout << "mon age est " << age <
Les instructions ci-dessus déclarent la classe personne,
qui possède 2 champs,
la donnée age et la fonction affiche.
la donnée age est un champ protégé.
la fonction affiche est un champ public.
Les données sont aussi appelées propriétés,
et les fonctions membres, sont appelées les méthodes.
Par défaut, les champs sont privés.
Par exemple, si l'on retire l'instruction protected dans l'exemple ci-dessus,
la propriété age devient un champ privé.
Les champs publics,
sont accessibles de n'importe où dans le programme.
Par contre les champs privés,
ne sont accessibles que dans l'étendue de la classe.
Les champs protégés sont accessibles dans la classe,
et dans les classes dérivées (voir l'héritage dans le cours 5)
Les accès que l'on donne aux champs d'une classe,
permettent de sécuriser les programmes.
class2.cpp : classe avec des propriétés privées et des méthodes publiques
En général, les propriétés sont déclarées privées,
et les méthodes sont déclarées publiques.
Ceci fait que l'on ne peut accéder aux propriétés privées d'une classe,
que par des méthodes de la classe.
membre.cpp : membres privés publics et protégés
Ces idées conduisent à la manière de programmer en c++,
qui correspond à l'encapsulation.
Chaque classe peut être considérée comme une partie indépendante,
qui peut être développée pour être utilisée sans risque dans les applications.
On verra dans le cours 5,
comment la notion de classes dérivées d'une classe de base,
facilite la programmation,
en permettant de personnaliser une classe élaborée par d'autres,
pour ses propres besoins,
avec très peu de lignes de code.
Ces remarques montrent que la programmation en c++,
sera dans son esprit, bien différente de la programmation en c
On distinguera les déclarations,
qui préciseront les champs d'une classe,
de l'implémentation des fonctions,
qui définira le code des fonctions membres.
Toutes les déclarations seront en général placées dans un fichier nomclass.h,
où nomclass est le nom de la classe.
Ces .h contiendront l'analogue des prototypes des fonctions,
que l'on déclare en c,
mais le compilateur c++ est bien plus strict.
Le code des fonctions membres sera placé dans nomclass.cpp
Pour des fonctions réduites à très peu d'instructions,
on pourra exceptionnellement les définir dans le corps de la classe,
et l'on dit dans ce cas que les fonctions sont in line.
les fonction in line sont l'analogue des macro du c
On utilisera l'instruction #ifndef dans les .h,
pour que le précompilateur ne rajoute pas des déclarations plusieurs fois,
car cela est interdit en c++
L'exemple de la classe personne ci-dessus deviendra :
#ifndef personne_h
#define personne personne_h
class personne
{
int age;
public :
void affiche(void);
};
#endif
Les instructions ci-dessus seront placées dans le fichier personne.h
L'implémentation de la seule fonction membre de la classe personne,
sera placée dans le fichier personne.cpp,
qui s'écrira :
#include <iostream.h>
#include "personne.h"
void personne::affiche(void)
{
cout << ""mon age est " << age << endl;
}
On remarque la présence de l'opérateur :: (deux deux-points)
d'affectation de portée
Ici la fonction membre est très simple,
et on aurait pû la definir in line,
mais on a choisi de l'implémenter en dehors de la classe pour l'exemple.
Je vais maintenant décrire comment créer et utiliser un élément d'une classe,
que l'on appelle encore un objet de la classe.
Dans un programme,
que j'appelle ici main (de l'anglais principal)
j'aimerais créer un objet de la classe personne,
de nom dupont, et afficher son age.
Comme la donnée age est un champ privé,
ce membre n'est pas accessible dans le main.
Il faut donc trouver un moyen pour donner une valeur à ce champ privé.
Pour cela, on déclare dans la classe personne,
une méthode publique particulière,
que l'on appelle un constructeur.
Consultez le lien suivant, pour un exemple de définition de constructeurs d'une classe.
construc.cpp : exemple de constructeurs d'une classe
Un constructeur est une fonction membre,
qui doit avoir le même nom que celui de la classe,
et ne renvoyer aucune valeur.
J'ajoute dans la déclaration de la classe personne,
après l'instruction public :
la ligne suivante
personne(int a)
{
age=a;
}
Ce constructeur va nous permettre d'affecter la valeur a au champ privé age,
car la fonction personne est accessible depuis le main,
puisqu'elle est publique.
Le programme principal pourra s'écrire, par exemple :
#include <iostream.h>
#include "personne.h"
void main(void)
{
personne dupont(45);
dupont.affiche();
return ;
}
Dans les exemples du répertoire source,
je n'ai pas séparé les déclarations,
l'implémentation, et le programme principal,
dans des fichiers séparés,
pour permettre une compilation en ligne ou à l'invite de DOS,
à partir d'un seul .cpp
Je reviendrai sur la notion de classe, dans le cours 5,
mais au-paravent, je vais insister sur l'usage des pointeurs,
et sur la surcharge des fonctions .
suivant : cours 3 les pointeurs