9 Les structures et les classes

(1)

9 Les structures et les classes

Peter Schlagheck Universit ´e de Li `ege

Ces notes ont pour seule vocation d’ être utilis ées par les étudiants dans le cadre de leur cursus au sein de l’Universit é de Li ège. Aucun autre usage ni diffusion n’est autoris é, sous peine de constituer une violation de la Loi du 30 juin 1994

relative au droit d’auteur.

(2)

9 Les structures et les classes

9.1 Les structures

9.2 Les classes

(3)

9.1 Les structures

Exemple: traiter des dates de naissance de 20 personnes

const int N = 20;

int jour[ N ];

int mois[ N ];

int an[ N ];

fo

// lecture des dates for ( int i = 0; i < N; i++ )

folire( jour[ i ], mois[ i ], an[ i ] );

fo

// ordonner les dates tri( N, jour, mois, an );

fo

// affichage les dates ordonnees affichage( N, jour, mois, an );

void lire( int &j, int &m, int &a ) {

focout << ''rentrez votre '';

focout << ''date de naissance:'' << endl;

focout << ''jour:'' << endl;

focin >> j;

focout << ''mois:'' << endl;

focin >> m;

focout << ''an:'' << endl;

focin >> a;

} fo

void affichage( int N, int *j, int *m, int *a ) {

fofor ( int i = 0; i < N; i++ )

fofocout << j[ i ] << ''/'' << m[ i ] << ''/'' << a[ i ] << endl;

}

−→ gestion de 3 tableaux s épar és n écessaire

−→ → des erreurs sont possibles . . .

(4)

9.1 Les structures

Exemple: traiter des dates de naissance de 20 personnes

const int N = 20;

int jour[ N ];

int mois[ N ];

int an[ N ];

fo

// ordonner les dates tri( N, an, mois, jour );

fo

focin >> j;

focin >> m;

focin >> a;

} fo

fofor ( int i = 0; i < N; i++ )

}

−→ gestion de 3 tableaux s épar és n écessaire

−→ → des erreurs sont possibles . . .

(5)

9.1 Les structures

Exemple: traiter des dates de naissance de 20 personnes

const int N = 20;

int jour[ N ];

int mois[ N ];

int an[ N ];

fo

// ordonner les dates tri( N, jour, mois, an );

fo

focin >> j;

focin >> m;

focin >> a;

} fo

fofor ( int i = 0; i < N; i++ )

}

−→ gestion de 3 tableaux s épar és n écessaire

−→ utilisation d’une structure

(6)

9.1 Les structures

struct date {

foint j;

foint m;

foint a;

};

−→ ceci d ´efinit un nouveau type nomm ´e date

−→ qui est compos ´e de trois variables j, m, a du type int

(7)

9.1 Les structures

struct date {

foint j;

foint m;

foint a;

};

fo

const int N = 20;

date naiss[ N ];

fo

// lecture des dates for ( int i = 0; i < N; i++ ) folire( naiss[ i ] );

fo

// ordonner les dates tri( N, naiss );

fo

// affichage les dates ordonnees affichage( N, naiss );

fo

(8)

9.1 Les structures

struct date {

foint j;

foint m;

foint a;

};

fo

void lire( date &d );

void tri( int N, date *d );

void affichage( int N, date *d );

fo main() {

foconst int N = 20;

fodate naiss[ N ];

fofor ( int i = 0; i < N; i++ ) fofolire( naiss[ i ] );

fotri( N, naiss );

foaffichage( N, naiss );

}

void lire( date &d ) {

focin >> d.j;

focin >> d.m;

focin >> d.a;

} fo

void affichage( int N, date *d ) {

fofor ( int i = 0; i < N; i++ ) fofocout << d[ i ].j << ''/'' << d[ i ].m fofocout << ''/'' << d[ i ].a << endl;

}

(9)

9.1 Les structures

#include ''date.h'' fo

main() {

foconst int N = 20;

fodate naiss[ N ];

fofor ( int i = 0; i < N; i++ ) fofolire( naiss[ i ] );

fotri( N, naiss );

foaffichage( N, naiss );

}

Le contenu de date.h:

struct date {

foint j;

foint m;

foint a;

};

fo

void lire( date &d );

void tri( int N, date *d );

void affichage( int N, date *d );

Le contenu de date.cpp:

void lire( date &d ) {

focin >> d.j;

focin >> d.m;

focin >> d.a;

} fo

void affichage( int N, date *d ) {

fofor ( int i = 0; i < N; i++ ) fofocout << d[ i ].j << ''/'' << d[ i ].m fofocout << ''/'' << d[ i ].a << endl;

} fo

void tri( int N, date *d ) {

fo...

}

(10)

9.1 Les structures

struct hstypei {

fo htype1i hnom1i ; fo htype2i hnom2i ; fo...

};

−→ d ´efinition du type hstypei : il est compos ´e des variables

−→ hnom1i du type htype1i , hnom2i du type htype2i , . . .

(11)

9.1 Les structures

struct hstypei {

fo htype1i hnom1i ; fo htype2i hnom2i ; fo...

};

D ´efinition d’une variable nomm ´ee hsnomi du type hstypei : hstypei hsnomi ;

Acc `es aux composantes de la variable hsnomi (→ les “membres” de la structure hstypei ) :

hsnomi . hnom1i

hsnomi . hnom2i

. . .

(12)

9.1 Les structures

struct hstypei {

fo htype1i hnom1i ; fo htype2i hnom2i ; fo...

};

D ´efinition d’une variable nomm ´ee hsnomi du type hstypei : hstypei hsnomi ;

−→ on peut utiliser hsnomi . hnom1i , hsnomi . hnom2i , . . .

−→ de la m ˆeme fac¸on que toutes les autres variables

−→ des types htype1i , htype2i , . . .

(13)

9.1 Les structures

void lire( date &d ) {

focout << ''rentrez votre '';

focout << ''date de naissance:'' << endl;

focout << ''jour:'' << endl;

focin >> d.j;

focout << ''mois:'' << endl;

focin >> d.m;

focout << ''an:'' << endl;

focin >> d.a;

foif ( ( d.j > 31 ) || ( d.m > 12 ) || ( d.a > 2011 ) ) fo {

fofocout << ''rentrez svp une date valable!''<< endl;

fofolire( d );

fo}

}

(14)

9.1 Les structures

#include ''date.h'' fo

main() {

fodate d1;

fodate d2;

folire( d1 );

folire( d2 );

fo int jour diff = 365 * ( d2.a - d1.a ) foint jour diff = + 30 * ( d2.m - d1.m ) foint jour diff = + ( d2.j - d1.j );

focout << ''vos dates de naissance different environ '';

focout << ''par '' << jour diff << '' jours'' << endl;

}

(15)

9.1 Les structures

#include ''date.h'' fo

main() {

fodate d1;

fodate d2;

folire( d1 );

folire( d2 );

fo int jour diff = 365 * ( d2.a - d1.a ) foint jour diff = + 30 * ( d2.m - d1.m ) foint jour diff = + ( d2.j - d1.j );

focout << ''vos dates de naissance different environ '';

focout << ''par '' << jour diff << '' jours'' << endl;

}

(16)

9.1 Les structures

#include ''date.h'' fo

main() {

fodate d1;

fodate d2;

folire( d1 );

folire( d2 );

fo int jour diff = 365 * ( d2.a - d1.a ) foint jour diff = + 30 * ( d2.m - d1.m ) foint jour diff = + ( d2.j - d1.j );

focout << ''vos dates de naissance different environ '';

focout << ''par '' << jour diff << '' jours'' << endl;

}

(17)

9.1 Les structures

On peut combiner des variables des types diff ´erents dans une structure . . .

struct personne {

fochar nom[ 50 ];

fochar prenom[ 50 ];

fo// date de naissance foint jour;

foint mois;

foint an;

};

(18)

9.1 Les structures

On peut combiner des variables des types diff ´erents dans une structure . . . m ˆeme des variables d’autres structures

struct date {

foint j;

foint m;

foint a;

};

fo

struct personne {

fochar nom[ 50 ];

fochar prenom[ 50 ];

fodate naiss;

};

(19)

9.1 Les structures

On peut combiner des variables des types diff ´erents dans une structure . . . m ˆeme des variables d’autres structures

struct personne {

fochar nom[ 50 ];

fochar prenom[ 50 ];

fodate naiss;

fopersonne pere;

fopersonne mere;

};

−→ erreur: ^fo

−→ field 'pere' has incomplete type

−→ field 'mere' has incomplete type

(20)

9.1 Les structures

On peut combiner des variables des types diff ´erents dans une structure . . . m ˆeme des variables d’autres structures

struct personne {

fochar nom[ 50 ];

fochar prenom[ 50 ];

fodate naiss;

fo personne *pere;

fo personne *mere;

};

(21)

9.1 Les structures

Les structures permettent

de rassembler des variables qui logiquement tiennent ensemble

struct date {

foint j;

foint m;

foint a;

} ;

struct personne {

fochar nom[ 50 ];

fochar prenom[ 50 ];

fodate naiss;

} ;

(22)

9.1 Les structures

Les structures permettent

de rassembler des variables qui logiquement tiennent ensemble

de s éparer les diff érentes hierarchies d’un programme de mieux g érer des programmes complexes

personne p[ 20 ];

p[ 1 ].naiss.m = 5;

. . . est mieux g ´erable que

char nom[ 20 ][ 50 ];

char prenom[ 20 ][ 50 ];

int jour[ 20 ];

int mois[ 20 ];

int an[ 20 ];

mois[ 1 ] = 5;

(23)

Les structures et les fonctions

struct personne {

fochar nom[ 50 ];

fochar prenom[ 50 ];

fodate naiss;

};

void registration( personne &p ) {

focout << ''nom:'';

focin >> p.nom;

focout << ''prenom:'';

focin >> p.prenom;

folire( p.naiss );

}

void affichage( personne p ) {

focout << p.prenom << '' '' << p.nom << endl;

}

main() {

fopersonne p1;

foregistration( p1 );

foaffichage( p1 );

}

−→ facile d’ajouter des él éments suppl émentaires . . .

(24)

Les structures et les fonctions

struct personne {

fochar nom[ 50 ];

fochar sexe;

fodate naiss;

};

focout << ''nom:'';

focin >> p.nom;

focin >> p.prenom;

focout << ''sexe(m/f):'';

focin >> p.sexe;

folire( p.naiss );

}

foif ( p.sexe == 'f' ) fofocout << ''Mme '';

foelse

fofocout << ''M. '';

}

main() {

fopersonne p1;

foaffichage( p1 );

}

(25)

Les structures et les fonctions

struct personne {

fochar nom[ 50 ];

fochar sexe;

fodate naiss;

};

focout << ''nom:'';

focin >> p.nom;

focin >> p.prenom;

focin >> p.sexe;

folire( p.naiss );

}

foelse

}

main() {

fopersonne p1;

foaffichage( p1 );

}

(26)

Les structures et les fonctions

struct personne {

fochar nom[ 50 ];

fochar sexe;

fodate naiss;

};

focout << ''nom:'';

focin >> p.nom;

focin >> p.prenom;

focin >> p.sexe;

folire( p.naiss );

}

foelse

}

main() {

fopersonne p1;

foaffichage( p1 );

}

(27)

Les structures et les fonctions

struct personne {

fochar nom[ 50 ];

fochar sexe;

fodate naiss;

};

focout << ''nom:'';

focin >> p.nom;

focin >> p.prenom;

focin >> p.sexe;

folire( p.naiss );

}

foelse

}

main() {

fopersonne p1;

foaffichage( p1 );

}

(28)

Les structures et les fonctions

struct personne {

fochar nom[ 50 ];

fochar sexe;

fodate naiss;

};

focout << ''nom:'';

focin >> p.nom;

focin >> p.prenom;

focin >> p.sexe;

folire( p.naiss );

}

foelse

}

main() {

fopersonne p1;

foaffichage( p1 );

}

(29)

Les structures et les fonctions

struct personne {

fochar nom[ 50 ];

fochar sexe;

fodate naiss;

};

focout << ''nom:'';

focin >> p.nom;

focin >> p.prenom;

focin >> p.sexe;

folire( p.naiss );

}

foelse

}

main() {

fopersonne p1;

foaffichage( p1 );

}

(30)

Les structures et les fonctions

struct personne {

fochar nom[ 50 ];

fochar sexe;

fodate naiss;

};

focout << ''nom:'';

focin >> p.nom;

focin >> p.prenom;

focin >> p.sexe;

folire( p.naiss );

}

foelse

}

main() {

fopersonne p1;

foaffichage( p1 );

}

−→ ´evitez de copier des grosses structures:

−→ travailler plut ˆot avec l’original dans des fonctions

(31)

Les structures et les fonctions

struct personne {

fochar nom[ 50 ];

fochar sexe;

fodate naiss;

};

focout << ''nom:'';

focin >> p.nom;

focin >> p.prenom;

focin >> p.sexe;

folire( p.naiss );

}

void affichage( personne &p ) {

foelse

}

main() {

fopersonne p1;

foaffichage( p1 );

}

−→ ´evitez de copier des grosses structures:

−→ travailler plut ˆot avec l’original dans des fonctions

Mais attention: ne pas faire des manipulation involontaires!

(32)

Les structures et les fonctions

struct personne {

fochar nom[ 50 ];

fochar sexe;

fodate naiss;

};

focout << ''nom:'';

focin >> p.nom;

focin >> p.prenom;

focin >> p.sexe;

folire( p.naiss );

}

void affichage( personne &p ) {

foif ( p.sexe = 'f' ) fofocout << ''Mme '';

foelse

}

main() {

fopersonne p1;

foaffichage( p1 );

}

−→ ´evitez de copier des grosses structures:

−→ travailler plut ˆot avec l’original dans des fonctions Mais attention: ne pas faire des manipulation involontaires!

−→ (Ex ´ecution: Mme Albert Einstein)

(33)

Les structures et les fonctions

struct personne {

fochar nom[ 50 ];

fochar sexe;

fodate naiss;

};

focout << ''nom:'';

focin >> p.nom;

focin >> p.prenom;

focin >> p.sexe;

folire( p.naiss );

}

void affichage( const personne &p ) {

foelse

}

main() {

fopersonne p1;

foaffichage( p1 );

}

−→ ´evitez de copier des grosses structures:

−→ travailler plut ˆot avec l’original dans des fonctions

−→ utiliser une r ´ef ´erence constante

(34)

Les structures et les fonctions

struct personne {

fochar nom[ 50 ];

fochar sexe;

fodate naiss;

};

focout << ''nom:'';

focin >> p.nom;

focin >> p.prenom;

focin >> p.sexe;

folire( p.naiss );

}

foif ( p.sexe = 'f' ) fofocout << ''Mme '';

foelse

}

main() {

fopersonne p1;

foaffichage( p1 );

}

−→ erreur: assignment of data-member 'personne::sexe'

in read-only structure

(35)

Les r ´ef ´erences constantes

htypei hnomi ( ..., const htype1i & hnom1i , ...);

→ d éclaration d’une fonction hnomi qui prend, comme un de ses arguments, une r éf érence constante à une variable du type htype1i

→ la fonction travaille avec l’original de cette variable, mais n’a pas de droit de la modifier quelque part

−→ utilit ´e pour des variables des types compos ´es

(structures, classes)

(36)

La copie des structures

struct personne {

fochar nom[ 50 ];

fochar sexe;

fodate naiss;

};

focout << ''nom:'';

focin >> p.nom;

focin >> p.prenom;

focin >> p.sexe;

folire( p.naiss );

}

foelse

}

main() {

fopersonne p1;

fopersonne p2 = p1;

fop2.sexe = ’f’;

}

(37)

La copie des structures

struct personne {

fochar nom[ 50 ];

fochar sexe;

fodate naiss;

};

focout << ''nom:'';

focin >> p.nom;

focin >> p.prenom;

focin >> p.sexe;

folire( p.naiss );

}

foelse

}

main() {

fopersonne p1;

fopersonne p2 = p1;

}

(38)

La copie des structures

struct personne {

fochar nom[ 50 ];

fochar sexe;

fodate naiss;

};

focout << ''nom:'';

focin >> p.nom;

focin >> p.prenom;

focin >> p.sexe;

folire( p.naiss );

}

foelse

}

main() {

fopersonne p1;

fopersonne p2 = p1;

}

(39)

La copie des structures

struct personne {

fochar nom[ 50 ];

fochar sexe;

fodate naiss;

};

focout << ''nom:'';

focin >> p.nom;

focin >> p.prenom;

focin >> p.sexe;

folire( p.naiss );

}

foelse

}

main() {

fopersonne p1;

fopersonne p2 = p1;

}

(40)

La copie des structures

struct personne {

fochar nom[ 50 ];

fochar sexe;

fodate naiss;

};

focout << ''nom:'';

focin >> p.nom;

focin >> p.prenom;

focin >> p.sexe;

folire( p.naiss );

}

foelse

}

main() {

fopersonne p1;

fopersonne p2 = p1;

}

(41)

La copie des structures

struct personne {

fochar nom[ 50 ];

fochar sexe;

fodate naiss;

};

focout << ''nom:'';

focin >> p.nom;

focin >> p.prenom;

focin >> p.sexe;

folire( p.naiss );

}

foelse

}

main() {

fopersonne p1;

fopersonne p2 = p1;

}

L’op ´eration de copie p2 = p1 effectue une copie de chaque

membre de la structure personne.

(42)

Les structures et les tableaux dynamiques

struct personne {

fochar nom[ 50 ];

foint Nenf;

fochar ( *prenom enf )[ 50 ];

};

focout << ''nom et prenom: '';

focin >> p.nom >> p.prenom;

focout << ''nombre d'enfants: '';

focin >> p.Nenf;

fop.prenom enf = new char[ p.Nenf ][50];

fofor ( int i = 0; i < p.Nenf; i++ ) fo{

fofocout << ''prenom de l'enfant '' fofocout<< i + 1 << '': '';

fofocin >> p.prenom enf[ i ];

fo}

}

main() {

fopersonne p1;

foregistration( p1 );

fopersonne p2 = p1;

fostrcpy( p2.prenom enf[ 0 ], ''Claire'');

focout << p1.prenom enf[ 0 ] << endl;

}

(43)

Les structures et les tableaux dynamiques

struct personne {

fochar nom[ 50 ];

foint Nenf;

};

fo main() {

fopersonne p1;

fopersonne p2 = p1;

fostrcpy( p2.prenom enf[ 0 ], ''Claire'');

focout << p1.prenom enf[ 0 ] << endl;

}

focin >> p.Nenf;

fo}

}

Ex ´ecution:

nom et prenom:

(44)

Les structures et les tableaux dynamiques

struct personne {

fochar nom[ 50 ];

foint Nenf;

};

fo main() {

fopersonne p1;

fopersonne p2 = p1;

}

focin >> p.Nenf;

fo}

}

Ex ´ecution:

nom et prenom: Clinton

Bill

(45)

Les structures et les tableaux dynamiques

struct personne {

fochar nom[ 50 ];

foint Nenf;

};

fo main() {

fopersonne p1;

fopersonne p2 = p1;

}

focin >> p.Nenf;

fo}

}

Ex ´ecution:

nom et prenom: Clinton Bill

nombre d'enfants:

(46)

Les structures et les tableaux dynamiques

struct personne {

fochar nom[ 50 ];

foint Nenf;

};

fo main() {

fopersonne p1;

fopersonne p2 = p1;

}

focin >> p.Nenf;

fo}

}

Ex ´ecution:

nom et prenom: Clinton Bill

nombre d'enfants: 1

(47)

Les structures et les tableaux dynamiques

struct personne {

fochar nom[ 50 ];

foint Nenf;

};

fo main() {

fopersonne p1;

fopersonne p2 = p1;

}

focin >> p.Nenf;

fo}

}

Ex ´ecution:

nom et prenom: Clinton Bill

nombre d'enfants: 1

prenom de l'enfant 1:

(48)

Les structures et les tableaux dynamiques

struct personne {

fochar nom[ 50 ];

foint Nenf;

};

fo main() {

fopersonne p1;

fopersonne p2 = p1;

}

focin >> p.Nenf;

fo}

}

Ex ´ecution:

nom et prenom: Clinton Bill

nombre d'enfants: 1

prenom de l'enfant 1: Chelsea

(49)

Les structures et les tableaux dynamiques

struct personne {

fochar nom[ 50 ];

foint Nenf;

};

fo main() {

fopersonne p1;

fopersonne p2 = p1;

}

focin >> p.Nenf;

fo}

}

Ex ´ecution:

nom et prenom: Clinton Bill

nombre d'enfants: 1

prenom de l'enfant 1: Chelsea

Claire

(50)

Les structures et les tableaux dynamiques

struct personne {

fochar nom[ 50 ];

foint Nenf;

};

fo main() {

fopersonne p1;

fopersonne p2 = p1;

}

focin >> p.Nenf;

fo}

}

(51)

Les structures et les tableaux dynamiques

struct personne {

fochar nom[ 50 ];

foint Nenf;

};

fo main() {

fopersonne p1;

fopersonne p2 = p1;

}

focin >> p.Nenf;

fo}

}

(52)

Les structures et les tableaux dynamiques

struct personne {

fochar nom[ 50 ];

foint Nenf;

};

fo main() {

fopersonne p1;

fopersonne p2 = p1;

}

focin >> p.Nenf;

fo}

}

(53)

Les structures et les tableaux dynamiques

struct personne {

fochar nom[ 50 ];

foint Nenf;

};

fo main() {

fopersonne p1;

fopersonne p2 = p1;

}

focin >> p.Nenf;

fo}

}

(54)

Les structures et les tableaux dynamiques

struct personne {

fochar nom[ 50 ];

foint Nenf;

};

fo main() {

fopersonne p1;

fopersonne p2 = p1;

}

focin >> p.Nenf;

fo}

}

(55)

Les structures et les tableaux dynamiques

struct personne {

fochar nom[ 50 ];

foint Nenf;

};

fo main() {

fopersonne p1;

fopersonne p2 = p1;

}

focin >> p.Nenf;

fo}

}

(56)

Les structures et les tableaux dynamiques

struct personne {

fochar nom[ 50 ];

foint Nenf;

};

fo main() {

fopersonne p1;

fopersonne p2 = p1;

}

focin >> p.Nenf;

fo}

}

(57)

Les structures et les tableaux dynamiques

struct personne {

fochar nom[ 50 ];

foint Nenf;

};

fo main() {

fopersonne p1;

fopersonne p2 = p1;

}

focin >> p.Nenf;

fo}

}

(58)

Les structures et les tableaux dynamiques

struct personne {

fochar nom[ 50 ];

foint Nenf;

};

fo main() {

fopersonne p1;

fopersonne p2 = p1;

}

focin >> p.Nenf;

fo}

}

(59)

Les structures et les tableaux dynamiques

struct personne {

fochar nom[ 50 ];

foint Nenf;

};

fo main() {

fopersonne p1;

fopersonne p2 = p1;

}

focin >> p.Nenf;

fo}

}

(60)

Les structures et les tableaux dynamiques

struct personne {

fochar nom[ 50 ];

foint Nenf;

};

fo main() {

fopersonne p1;

fopersonne p2 = p1;

}

focin >> p.Nenf;

fo}

}

(61)

Les structures et les tableaux dynamiques

struct personne {

fochar nom[ 50 ];

foint Nenf;

};

fo main() {

fopersonne p1;

fopersonne p2 = p1;

}

focin >> p.Nenf;

fo}

}

(62)

Les structures et les tableaux dynamiques

struct personne {

fochar nom[ 50 ];

foint Nenf;

};

fo main() {

fopersonne p1;

fopersonne p2 = p1;

}

focin >> p.Nenf;

fo}

}

−→ pas de copie du tableau dynamique dans l’espace libre

−→ p1 et p2 r éf èrent à des m êmes donn ées

(63)

Les structures et les tableaux dynamiques

struct personne {

fochar nom[ 50 ];

foint Nenf;

};

fo main() {

fopersonne p1;

fopersonne p2 = p1;

}

focin >> p.Nenf;

fo}

}

(64)

Les structures et les tableaux dynamiques

struct personne {

fochar nom[ 50 ];

foint Nenf;

};

fo main() {

fopersonne p1;

fopersonne p2 = p1;

}

focin >> p.Nenf;

fo}

}

Ex ´ecution:

nom et prenom: Clinton Bill

nombre d'enfants: 1

prenom de l'enfant 1: Chelsea

Segmentation fault

(65)

Les fonctions de membre des structures

struct personne {

fochar nom[ 50 ];

fochar sexe;

fodate naiss;

fo

fovoid registration() fo{

fofocout << ''nom et prenom:'';

fofocin >> nom >> prenom;

fofocout << ''sexe(m/f):'';

fofocin >> sexe;

fofolire( naiss );

fo}

};

focout << ''nom et prenom:'';

focin >> p.sexe;

folire( p.naiss );

} fo

foelse

focout << p.prenom << '' '' focout<< p.nom << endl;

}

Aussi des fonctions peuvent ˆetre des membres des structures.

(66)

Les fonctions de membre des structures

struct personne {

fochar nom[ 50 ];

fochar sexe;

fodate naiss;

fo

fovoid registration() fo{

fofocout << ''nom et prenom:'';

fofocin >> nom >> prenom;

fofocout << ''sexe(m/f):'';

fofocin >> sexe;

fofolire( naiss );

fo}

fo

fovoid affichage() const fo{

fofoif ( sexe == 'f' ) fofofocout << ''Mme '';

fofoelse

fofofocout << ''M. '';

fofocout << prenom << '' '' fofocout<< nom << endl;

fo}

};

focin >> p.sexe;

folire( p.naiss );

} fo

foelse

focout << p.prenom << '' '' focout<< p.nom << endl;

}

(67)

Les fonctions de membre des structures

struct personne {

fochar nom[ 50 ];

fochar sexe;

fodate naiss;

fo

fovoid registration();

fo

fovoid affichage() const;

};

void personne::registration() {

focin >> nom >> prenom;

focin >> sexe;

folire( naiss );

} fo

void personne::affichage() const {

foif ( sexe == 'f' ) fofocout << ''Mme '';

foelse

focout << prenom << '' '' focout<< nom << endl;

}

−→ d ´eclaration et d ´efinition des deux fonctions de membre

−→ registration() et affichage()

(68)

Les fonctions de membre des structures

Le contenu de personne.h

#include ''date.h'' using namespace std;

fo

struct personne {

fochar nom[ 50 ];

fochar sexe;

fodate naiss;

fo

};

Le contenu de personne.cpp

#include <iostream>

#include ''personne.h'' fo

focin >> sexe;

folire( naiss );

} fo

foelse

}

(69)

Les fonctions de membre des structures

Le contenu de date.h

struct date {

foint j;

foint m;

foint a;

fo

fovoid lecture();

};

Le contenu de date.cpp

#include <iostream>

fo

void date::lecture() {

focin >> j;

focin >> m;

focin >> a;

} fo

void date::affichage() const {

focout << j << ''/'' << m focout<< ''/'' << a << endl;

}

(70)

Les fonctions de membre des structures

Le contenu de personne.h

fo

struct personne {

fochar nom[ 50 ];

fochar sexe;

fodate naiss;

fo

};

Le contenu de personne.cpp

#include <iostream>

focin >> sexe;

fonaiss.lecture();

} fo

foelse

}

(71)

Les fonctions de membre des structures

Le contenu de personne.h

fo

struct personne {

fochar nom[ 50 ];

fochar sexe;

fodate naiss;

fo

};

Le contenu de prog.cpp

#include <iostream>

main() {

fopersonne p1;

fop1.registration();

fopersonne p2 = p1;

fop2.affichage();

}

(72)

Les fonctions de membre des structures

struct hstypei {

fo htype1i hnom1i ; fo htype2i hnom2i ; fo...

fo hftypei hfnomi ( htype ai hnom ai , ...);

};

−→ d ´eclaration de la fonction hfnomi comme membre

−→ de la structure hstypei

(73)

Les fonctions de membre des structures

struct hstypei {

fo htype1i hnom1i ; fo htype2i hnom2i ; fo...

fo hftypei hfnomi ( htype ai hnom ai , ...);

};

fo

hftypei hstypei :: hfnomi ( htype ai hnom ai , ...) {

fo...

}

−→ d ´efinition “ext ´erieure” de la fonction hfnomi :

hstypei :: hfnomi signifie l’ ´el ´ement hfnomi de la structure hstypei

(74)

Les fonctions de membre des structures

struct hstypei {

fo htype1i hnom1i ; fo htype2i hnom2i ; fo...

fo hftypei hfnomi ( htype ai hnom ai , ...) fo{

fofo...

fo}

};

−→ d ´efinition “int ´erieure” de la fonction hfnomi

(75)

Les fonctions de membre des structures

struct hstypei {

fo htype1i hnom1i ; fo htype2i hnom2i ; fo...

fo hftypei hfnomi ( htype ai hnom ai , ...);

};

Appel: hsnomi . hfnomi ( hnom ai , ...) o `u hsnomi est une variable du type hstypei

C’est équivalent à l’appel hfnom2i ( hsnomi , hnom ai , ...) o ù hfnom2i est d éclar ée comme

hftypei hfnom2i ( hstypei & hsnomi , htype ai hnom ai , ...);

(et, dans sa d ´efinition, hnom1i remplac ´e par hsnomi . hnom1i ,. . . )

(76)

Les fonctions de membre des structures

struct hstypei {

fo htype1i hnom1i ; fo htype2i hnom2i ; fo...

fo hftypei hfnomi ( htype ai hnom ai , ...) const;

};

−→ la fonction hfnomi ne peut pas modifier

−→ les variables hnom1i , hnom2i , . . . de hsnomi

(77)

Les fonctions de membre des structures

struct hstypei {

fo htype1i hnom1i ; fo htype2i hnom2i ; fo...

fo hftypei hfnomi ( htype ai hnom ai , ...) const;

};

fo

hftypei hstypei :: hfnomi ( htype ai hnom ai , ...) const {

fo...

}

−→ ne pas oublier le const dans la d ´efinition !

(78)

9.2 Les classes

Les classes sont des structures avec des secteurs publics (public) et priv ´es (private).

class date {

public:

fo foint j;

foint m;

foint a;

fo

fovoid lecture();

fovoid affichage() const;

};

est ´equivalent `a

struct date {

foint j;

foint m;

foint a;

fo

fovoid lecture();

fovoid affichage() const;

};

−→ tous les ´el ´ements de la classe date

−→ sont accessibles par l’ext ´erieur

(79)

9.2 Les classes

Les classes sont des structures avec des secteurs publics (public) et priv ´es (private).

class date {

private:

fo foint j;

foint m;

foint a;

fo

fovoid lecture();

fovoid affichage() const;

};

est ´equivalent `a

class date {

foint j;

foint m;

foint a;

fo

fovoid lecture();

fovoid affichage() const;

};

−→ aucun ´el ´ement de la classe date

−→ n’est accessible par l’ext ´erieur

−→ (pas d’int ´er ˆet pratique . . . )

(80)

9.2 Les classes

Les classes sont des structures avec des secteurs publics (public) et priv ´es (private).

class date {

private:

fo foint j;

foint m;

foint a;

fo public:

fo

fovoid lecture();

fovoid affichage() const;

};

est ´equivalent `a

class date {

foint j;

foint m;

foint a;

fo public:

fo

fovoid lecture();

fovoid affichage() const;

};

−→ lecture et affichage sont accessibles (publiques) et

−→ j, m et a sont inaccessibles (priv ´es) par l’ext ´erieur

(81)

9.2 Les classes

Les classes sont des structures avec des secteurs publics (public) et priv ´es (private).

class date {

private:

fo foint j;

foint m;

foint a;

fo public:

fo

fovoid lecture();

fovoid affichage() const;

};

est ´equivalent `a

class date {

foint j;

foint m;

foint a;

fo public:

fo

fovoid lecture();

fovoid affichage() const;

};

−→ les variables j, m et a peuvent être acc éd ées uniquement

−→ par les fonctions de membre lecture et affichage

(82)

9.2 Les classes

Les classes sont des structures avec des secteurs publics (public) et priv ´es (private).

Typiquement, les variables de membre d’une classe sont d éclar ées priv ées et les fonctions de membres publiques.

Ceci permet de prot éger les variables d’une classe contre une manipulation imprudente par l’utilisateur et de d éfinir leur acc ès depuis l’ext érieur par des fonctions de membres publiques.

Analogie avec un t ´el ´eviseur:

→ les boutons sur la t ´el ´ecommande correspondent aux

→ fonctions puliques

→ l’ électronique à l’int érieur du t él éviseur correspond à ses

→ variables internes

(83)

9.2 Les classes

Exemple: gestion s ´ecuris ´ee d’un tableau dynamique

class tableau {

foint N;

fodouble *tab;

fo public:

fo

fovoid construction( int N );

fo

fovoid destruction();

fo

fovoid set element( int i, double x );

fo

fodouble element( int i );

};

fo

void tableau::construction( int N ) {

foN = N ;

fotab = new double[ N ];

}

(84)

9.2 Les classes

Exemple: gestion s ´ecuris ´ee d’un tableau dynamique

class tableau {

foint N;

fodouble *tab;

fo public:

fo

};

fo

void tableau::destruction() {

fodelete[] tab;

}

(85)

9.2 Les classes

Exemple: gestion s ´ecuris ´ee d’un tableau dynamique

class tableau {

foint N;

fodouble *tab;

fo public:

fo

};

fo

void tableau::set element( int i, double x ) {

foif ( ( i >= 0 ) && ( i < N ) ) fofotab[ i ] = x;

}

(86)

9.2 Les classes

Exemple: gestion s ´ecuris ´ee d’un tableau dynamique

class tableau {

foint N;

fodouble *tab;

fo public:

fo

};

fo

double tableau::element( int i ) {

foif ( ( i >= 0 ) && ( i < N ) ) foforeturn ( tab[ i ] );

foreturn 0;

}

(87)

9.2 Les classes

Exemple: gestion s ´ecuris ´ee d’un tableau dynamique

class tableau {

foint N;

fodouble *tab;

fo public:

fo

fodouble element( int i ) const;

};

fo

double tableau::element( int i ) const {

foif ( ( i >= 0 ) && ( i < N ) ) foforeturn ( tab[ i ] );

foreturn 0;

}

(88)

9.2 Les classes

Exemple: gestion s ´ecuris ´ee d’un tableau dynamique

class tableau {

foint N;

fodouble *tab;

fo public:

fo

fodouble element( int i ) const;

};

fo

−→ tableau dynamique avec toutes fonctionnalit ´ees “correctes”

−→ pas de moyen de manipuler tab de mani `ere pernicieuse

−→ depuis l’ext ´erieur de la classe

(89)

9.2 Les classes

class tableau {

foint N;

fodouble *tab;

fo public:

fo

fovoid construction( int N ) fo{

fofoN = N ;

fofotab = new double[ N ];

fo}

fo

fovoid destruction() fo{

fofodelete[] tab;

fo}

fo

fovoid set element( int i, double x ) fo{

fofoif ( ( i >= 0 ) && ( i < N ) ) fofofotab[ i ] = x;

fo}

fo

fodouble element( int i ) const fo{

fofoif ( ( i >= 0 ) && ( i < N ) ) fofoforeturn ( tab[ i ] );

foforeturn 0;

fo}

};