Aide Memoire C++

Aide-mémoire C++

Matmeca 2014

Marc Duruflé

page 3 Aide-mémoire C++ par Marc Duruflé

Table des matières

1 Commentaires 5

2 Types prédéfinis 52.1 Types de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.2 Qualificatifs additionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

3 Pointeurs et références 7

4 Tableaux en C 84.1 Tableau statique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84.2 Tableau dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84.3 Tableau à plusieurs entrées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

5 Structures, énumérations 9

6 Fonctions 106.1 Surcharge de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106.2 Passage par référence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126.3 Passage par pointeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136.4 Pointeurs et références de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146.5 La fonction main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

7 Variables 15

8 Structures de contrôle 178.1 Opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178.2 Structure conditionnelle if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198.3 Structure conditionnelle switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198.4 Boucle for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208.5 Boucle while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208.6 Instructions break continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

9 C++ : la couche objet 219.1 Encapsulation des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219.2 Héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229.3 Fonctions et classes amies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239.4 Constructeur, destructeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249.5 Pointeur this . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269.6 Attributs et méthodes statiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279.7 Méthodes virtuelles, polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289.8 Surcharge des opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

10 Structure d’un code 3110.1 Prototype de fonctions, de classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3110.2 Directives du préprocesseur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3210.3 Espace de nommages (namespace) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

11 Entrées-sorties 34

12 Fonctions et classes génériques 36

13 Exceptions en C++ 39


14 Utilisation de la STL 4014.1 Fonctions mathématiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4014.2 Chaînes de caractères (string) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4014.3 Vecteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4214.4 Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4214.5 Piles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43


1. Commentaires

/∗Ceci e s t un commentaires surp l u s i e u r s l i g n e s (C e t C++) ∗/

// Ceci e s t un commentaire sur une l i g n e (C++ uniquement )

double x = 3 . 0 ; // qu i peut e t r e d i spo se a l a s u i t e d ’ une i n s t r u c t i o n

2. Types prédéfinis

Type Descriptionvoid type videbool booléenint entier (sur 4 octets)char caractère (1 octet)float réel simple précision (4 octets)double réel double précision (8 octets)

unsigned int entier positifshort entier courtlong entier long

int64_t entier long (sur 8 octets)

2.1. Types de base• void Type vide, utilisé le plus souvent pour signaler qu’une fonction ne retourne rien.

// exemple de func t i on qu i ne renvo ie r i envoid affiche_reel (double x ){

cout << "␣x␣=␣" << x << endl ;}

• bool Booleen (true or false)

bool test = true ;// on peut l e s u t i l i s e r d i rec tement dans l e s cond i t i on si f ( test )

cout << "Test␣ e s t ␣ v ra i ␣" << endl ;

• char Caractère (codé sur un octet)

// l a casse e s t importante , a e t A sont des ca rac t e r e s d i f f e r e n t schar lettre = ’A ’ ;// l a correspondance carac t e r e <−> nombre e s t assuree par// l a t a b l e a s c i i , par exemple ’0 ’ = 48char zero = ’ 0 ’ , zero_bis = 48 ;// i l y a au s s i des ca rac t e r e s spec iaux


// \ t ( t a b u l a t i o n ) , \n ( re tour cha r i o t ) , e t clettre = ’ \n ’ ;

• int Entier (codé sur 4 octets)

// pas d ’ ove r f l ow ( depassement ) s i n e s t compris en t re// −2 147 483 647 e t 2 147 483 647int n = 345 ;

// par de fau t un en t i e r ( i c i 345) e s t e c r i t en base decimale// on peut en t r e r un l i t e r a l en base hexadecimale// en commencant par 0xn = 0xA34E ; // n = A34E en hexadecimal

// pour l e s e n t i e r s en base 8 , on commence par 0n = 023472; // n vaut 10042

• float Réel simple précision (codé sur 4 octets).

Ce type représente des nombres réels entre 1e-38 et 1e38 avec une précision de 1e-7.

// pour d e c l a r e r un l i t e r a l s imple prec i s i on , a j ou t e r f :f loat x = 1.23 f ;

• double Réel double précision (codé sur 8 octets).Ce type représente des nombres réels entre 1e-308 et 1e308 avec une précision de 2e-16.

// pour d e c l a r e r un l i t e r a l doub le p r e c i s i on :double x = 1.23 , y = −5.04e10 ;

• int64_t Entier (codé sur 8 octets)

// a i n c l u r e pour avo i r l e type int64_t#include<s td i n t . h>

using namespace std ;

// pas d ’ ove r f l ow ( depassement ) s i n e s t compris en t re// −9e18 e t 9e18int64_t n = 345 ;

2.2. Qualificatifs additionnels• short Pour déclarer une variable de plus faible précision


// i l n ’ y a pas de reg l e , mais par exemple shor t i n t e s t en genera l// s t o c k e sur 2 o c t e t s (−32 768 a 32 767)short int n = 1045 ;

• long Pour déclarer une variable de plus grande précision

// i l n ’ y a pas de reg l e , mais par exemple long doub le e s t en genera l// s t o c k e sur 10 o c t e t s ( doub le p r e c i s i on etendue )// mettre L a l a f i n des l i t e r a u xlong double x = 0.1234L ;

• signed / unsigned Pour déclarer des entiers non-signés (positifs) ou signés

// Par de fau t l e s e n t i e r s sont s i gnes , pour d e c l a r e r un en t i e r p o s i t i f :unsigned int i = 23 ;// l ’ avantage e s t a l o r s que i peut a l l e r de 0 a 4 m i l l i a r d s

// l e s ca ra c t e r e s non s i gne s e x i s t e n t au s s i ( a l l a n t de 0 a 256)unsigned char c = 23 ;

3. Pointeurs et références

Un pointeur est une variable contenant l’adresse d’une autre variable. Le contenu du pointeur q est alorsaccédé par ∗ q et l’adresse d’une variable x est accédée par & x :

double x = 1.0 ; // x vaut 1 .0double y = 2.0 ; // y vaut 2 .0double∗ q ; // on dec l a r e un po in teur sur un doub leq = NULL ; // on s p e c i f i e i c i que q ne po in t e ver s r i enq = &x ; // q po in t e maintenant ver s l a v a r i a b l e x∗q = 3 . 0 ; // x vaut 3 .0q = &y ; // q po in t e maintenant ver s l a v a r i a b l e y∗q = 4 . 0 ;// y vaut maintenant 4 .0x = ∗q ;// x vaut maintenant 4 .0

// on peut a l l o u e r un nouve l emplacement memoire pour q// ( qu i sera ni x , ni y )q = new double ;∗q = 2 . 0 ; // x e t y sont inchanges

q = &x ; // i c i c ’ e s t t r e s dangereux// car on perd l ’ adres se r e s e r v e e au−dessus// on a a l o r s ce qu ’ on a p p e l l e une f u i t e de memoire

// on peut au s s i a l l o u e r p l u s i e u r s cases ( pas une s eu l e )q = new double [ 3 ] ; // 3 cases i c i// e t acceder aux au t r e s cases avec [ ]


x = q [ 1 ] ;

// pour l i b e r e r l a memoire , d e l e t e [ ]delete [ ] q ;

// l e s r e f e r enc e s peuvent au s s i e t r e u t i l i s e e s// pour d e f i n i r des a l i a s ( sans avo i r a e c r i r e de ∗)double& alias_x = x ;

// tou t changement sur a l ias_x se repe rcu t e ra sur x e t v i c e versaalias_x = −1.0; // x e t a l ias_x va l en t −1

4. Tableaux en C

4.1. Tableau statiqueC’est un tableau dont on connait la taille lors de la compilation.

// par exemple un t a b l e au de 4 r e e l s :// par de fau t l e s v a l e u r s de y ne sont pas i n i t i a l i s e e sdouble y [ 4 ] ;

// on u t i l i s e l ’ opera teur [ ] pour acceder aux e lements du t a b l e au// l e s i n d i c e s commencent a 0y [ 0 ] = 3 . 0 3 ; y [ 1 ] = −2e10 ; y [ 2 ] = 5 .54 e3 ; y [ 3 ] = 2 .02e−5;

// on peut i n i t i a l i s e r t ou t l e t a b l e au avec l e s { } :int n [ 4 ] = {−31, 43 , 3 , 10} ;

4.2. Tableau dynamiqueC’est un tableau dont on fixe la taille lors de l’execution

// par exemple on demande l a t a i l l e du t a b l e auint n ;cout << "Entrez ␣n␣" << endl ;cin >> n ;

// on a l l o u e l e t a b l e au avec l ’ opera teur newdouble∗ x ; // x po in teur ver s l a premiere case du t a b l e aux = new double [ n ] ;

// on u t i l i s e l ’ opera teur [ ] pour acceder aux e lements du t a b l e au// l e s i n d i c e s commencent a 0x [ 0 ] = 3 . 0 3 ; x [ 1 ] = −2e10 ; x [ 2 ] = 5 .54 e3 ; x [ 6 ] = 2 .02e−5;

// on d e s a l l o u e l e t a b l e au avec l ’ opera teur d e l e t e [ ]delete [ ] x ;


4.3. Tableau à plusieurs entréesLa syntaxe des tableaux statiques multidimensionnels est la suivante :

// exemple de t a b l e au 3x2 qu ’ on i n i t i a l i s edouble A [ 3 ] [ 2 ] = {{0 .5 , 0 . 6} , {−0.3 , 0 . 1} , {0 . 9 , −0.9}};

// on accede aux e lements en e c r i v an t A[ i ] [ j ]cout << "␣A[ 1 ] [ 0 ] ␣" << A [ 1 ] [ 0 ] << endl ;

// on peut e c r i r e un t a b l e au avec un nombre a r b i t r a i r e d ’ i n d i c e s// par exemple pour un t a b l e au t r i d imens i onne lint B [ 5 ] [ 4 ] [ 3 ] ;

B [ 2 ] [ 0 ] [ 4 ] = 3 . 4 ;

En C++, il n’y a pas d’équivalent natif aux tableaux dynamiques multidimensionnels comme il existe enFortran90. Toutefois il est possible de construire des vecteurs de vecteurs, avec le désavantage que ce typede structure ne stockera pas les éléments de manière contigüe. En voici un exemple :

// pour un vec t eur de vec teurs , on met deux e t o i l e s// on met autant d ’ e t o i l e s qu ’ i l y a d ’ i n d i c e sdouble∗∗ V ;

// on a l l o u e l a l i s t e des l i g n e s :int m = 5 ;V = new double ∗ [ m ] ;

// en su i t e on a l l o u e chaque l i g n e// chaque l i g n e peut avo i r une t a i l l e d i f f e r e n t e// e t l e s e lements de l a seconde l i g n e ne seron t pas s t o c k e s// physiquement j u s t e apres ceux de l a premiere l i g n e ( s tockage non cont i gu )int n = 7 ;for ( int i = 0 ; i < m ; i++)

V [ i ] = new double [ n ] ;

// en su i t e on modi f i e un element de V avec V[ i ] [ j ]V [ 0 ] [ 4 ] = 3 . 0 ;

// on do i t d e s a l l o u e r chaque l i g n e separementfor ( int i = 0 ; i < m ; i++)

delete [ ] V [ i ] ;

// pu i s d e s a l l o u e r l e t ou tdelete [ ] V ;

5. Structures, énumérations

Une structure contient plusieurs champs, c’est l’équivalent des types composés Fortran.

struct NomStructure{

// nombre des i n v i t e sint nombre_invites ;


// t a b l e au contenant l a t a i l l e des i n v i t e sdouble∗ taille_invites ;

// nom de l ’ evenementchar∗ nom ;

} ;

// on dec l a r e une v a r i a b l e de type NomStructureNomStructure repas ;

// pour mod i f i e r l e s membres de l a s t ruc tu re , opera teur .repas . nombre_invites = 10 ;

// on peut au s s i d e c l a r e r a l a vo l e e une s t r u c t u r e// sans donner de nom :struct{ double x , y ; } var ;

// e t mod i f i e r l e s membres de l a v a r i a b l e :var . x = 3 . 0 ; var . y = −2.0;

// on peut au s s i u t i l i s e r l e mot c l e t y p ede ftypedef struct { int i ; double x ; } NomStruct ;

// pu i s d e c l a r e r l a v a r i a b l e de type NomStructNomStruct x ;

Une énumération permet de définir des constantes entières dans un programme et de les nommer, ce quirend le code plus lisible.

// par exemple on enumere t ou t e s l e s cond i t i on s aux l im i t e s// qu ’ on s a i t t r a i t e r avec l e code :enum{DIRICHLET , NEUMANN , IMPEDANCE } ;

// ces cons tan te s sont des en t i e r s , qu ’ on peut u t i l i s e r :int condition = NEUMANN ;

// ensu i t e , au l i e u de f a i r e un t e s t// i f ( cond i t i on == 1) , on met l e nomi f ( condition == DIRICHLET )

{// on f a i t l e t ra i t emen t de l a cond i t i on de D i r i c h l e t

}

6. Fonctions

Syntaxe :type_retour nom_fonction(arg1, arg2, arg_default = value_default) ;

6.1. Surcharge de fonctionsUne fonction est définie par ses arguments et son type de retour. On peut surcharger une fonction, c’est

à dire avoir deux fonctions portant le même nom mais dont les arguments diffèrent. Le mot clé “return”renvoie la valeur de retour de la fonction et quitte la fonction.


// exemple t r i v i a l d ’ une f onc t i on renvoyant x+ydouble Add (double x , double y ){

return x + y ;}

// on peut surcharger c e t t e f onc t i on pour des arguments d i f f e r e n t sint Add ( int x , int y ){

return x + y ;}

double Add (double x , double y , double z ){

return x + y + z ;}

// on d e f i n i t une procedure en mettant vo id comme type de re tourvoid test_procedure (double x , double y ){

// re turn s e r t i c i a q u i t t e r l a procedurei f (x == y )return ;

// l e programme cont inuera que s i x e s t d i f f e r e n t de ycout << "1/(x−y ) ␣=␣" << 1 .0/ ( x−y ) << endl ;

}

// on peut s p e c i f i e r des arguments op t i onne l s a l a f i n des arguments// on l e u r donne une va l eu r par de faut , i c i z e s t un argument op t i onne l// s ’ i l n ’ e s t pas rempli , i l vaut 1 .0double Mlt (double x , double y , double z = 1 . 0 ){

return x∗y∗z ;}

int main ( ){

// pour appe l e r une fonc t ion , on e c r i t son nom avec l e s argumentsdouble x = Add ( 1 . 3 , 1 . 4 ) ;double y = Add (x , 0 . 45 , 1 . 2 3 ) ;

test_procedure (x , y ) ;

// on peut appe l e r Mlt avec t r o i s argumentsdouble z = Mlt (x , y , 2 . 3 ) ;

// ou avec deux arguments , l e de rn i e r prenant// l a va l eu r par de fau t (1 .0 i c i )z = Mlt (x , y ) ;

return 0 ;


}

6.2. Passage par référencePar défaut, les arguments d’une fonction sont passés par valeurs et ne sont donc pas modifiés. Une copie

locale de ces arguments est faite.

// exemple de f onc t i on avec des arguments u sue l sdouble Add (double x , double y ){

// on peut mod i f i e r l e s cop i e s l o c a l e s de x e t y// l a va l eu r de x e t y ne sera pas modi f i ee en s o r t i e de f onc t i onx += y ;y += x ;return x ;

}

int main ( ){

double x = 3 .2 , y = 2 . 3 ;double z = Add (x , y ) ;

// x e t y v a l en t t ou j our s 3 .2 e t 2 .3return 0 ;

}

Pour modifier les arguments, on utilise des références, afin de passer l’adresse des arguments. Ainsi onévite la copie locale des arguments, qui peut etre coûteuse si certaines variables sont volumineuses.

// exemple d ’ une s t r u c t u r e volumineusestruct BigArray{double A [ 1 0 0 0 ] ;} ;

// on passe x e t tab par re f erence , i l s peuvent e t r e mod i f i e s// de p l u s aucune cop ie l o c a l e de tab n ’ e s t e f f e c t u e evoid modify_argument (double& x , BigArray& tab ){

for ( int i = 0 ; i < 1000 ; i++)tab . A [ i ] ∗= x ;

x += 1 . 0 ;}

// on peut u t i l i s e r l e mot−c l e cons t pour s p e c i f i e r qu ’un argument// e s t inchange , meme s ’ i l e s t passe par r e f e r ence// l e but e s t i c i d ’ e v i t e r l a cop ie l o c a l e d ’un gros o b j e tvoid test_argument ( const BigArray& t ){

t . A [ 0 ] = 2 . 0 ; // erreur a l a compi la t ion}

int main ( )


{double x = 2 . 0 ;BigArray tab ;for ( int i = 0 ; i < 1000 ; i++)

tab . A [ i ] = double (i ) ;

modify_argument (x , tab ) ;// x e t tab ont e t e mod i f i e s

return 0 ;}

6.3. Passage par pointeurUne méthode moins élégante est de passer les adresses des arguments. C’est une technique surtout

employée pour le passage de tableaux.

// on reprend l e meme exemple que precedemmentvoid modify_argument (double∗ x , BigArray∗ tab ){

// on do i t a l o r s adapter l a f onc t i onfor ( int i = 0 ; i < 1000 ; i++)

tab−>A [ i ] ∗= ∗x ;

∗x += 1 . 0 ;}

// l e passage par po in teur e s t na tu r e l pour un t a b l e audouble sum (double∗ x , int n ){

// on renvo ie l a somme des e lements du t a b l e au xdouble sum = 0 . 0 ;for ( int i = 0 ; i < n ; i++)

sum += x [ i ] ;

return sum ;}

int main ( ){

double x = 2 . 0 ;BigArray tab ;

// on passe i c i l e s adre s s e s des o b j e t smodify_argument(&x , &tab ) ;

double∗ vec ;int n = 10 ;vec = new double [ n ] ;

// pour un tab l eau , on l e passe d i rec tement// puisque c ’ e s t de ja un po in teurx = sum (vec , n ) ;


delete [ ] vec ;

return 0 ;}

6.4. Pointeurs et références de fonctionsGrace à ces fonctionnalités on peut construire des tableaux de fonctions ou passer une fonction en

paramètre.

// une r e f e r ence de f onc t i on s ’ e c r i t sous l a forme// type_retour (&nom_fct ) ( arguments )

// un po in teur de f onc t i on s ’ e c r i t sous l a forme// type_retour (∗nom_fct ) ( arguments )

// par exemple on c on s t r u i t une f onc t i on gener i que// pour c a l c u l e r l ’ i n t e g r a l e de f en t re a e t b , ou f// e s t une f onc t i on qu i e s t passee en parametredouble integrate (double a , double b , int N , double (&f ) (double ) ){

double sum = 0 . 0 ;double h = (b−a ) / N ;for ( int i = 0 ; i < N ; i++)

{double x = (double (i ) + 0 . 5 )∗ h + a ;sum += h∗f (x ) ;

}

return sum ;}

// exemple de f onc t i on dont on veut c a l c u l e r l ’ i n t e g r a l edouble func (double x ){

return x∗x + sin ( 0 . 5∗ x ) ;}

int main ( ){

cout << " In t e g r a l e ␣de␣exp␣=␣" << integrate ( 0 . 0 , 1 . 0 , 20 , exp ) << endl ;cout << " In t e g r a l e ␣de␣ func ␣=␣" << integrate ( 0 . 0 , 1 . 0 , 20 , func ) << endl ;

// on dec l a r e un nouveau type f p t r qu i e s t un po in teur de f onc t i on// renvoyant un doub le avec un doub le en parametretypedef double (∗ fptr ) (double ) ;

// on dec l a r e un t a b l e au contenant t r o i s f on c t i on s de ce typefptr tab_fct [ 3 ] ;

// on i n i t i a l i s e l e t a b l e autab_fct [ 0 ] = &exp ;


tab_fct [ 1 ] = &func ;tab_fct [ 2 ] = &asin ;

for ( int i = 0 ; i < 3 ; i++)cout << " In t e g r a l e ␣de␣ f_i ␣=␣"<< integrate ( 0 . 0 , 1 . 0 , 20 , ∗tab_fct [ i ] ) << endl ;

return 0 ;}

6.5. La fonction mainLa fonction main est la fonction appelée lors de l’exécution, il ne doit donc y avoir qu’une seule fonction

main lorsqu’on réalise l’édition des liens.

int main ( ){

// on renvo ie 0 s i l e programme s ’ e s t b ien derou l e// un autre en t i e r s ’ i l y a eu une erreurreturn 0 ;

}

On peut également récupérer les arguments de la ligne de commande :

// Par exemple s i vous avez execu te vo t r e programme en tapant :// ./ a . out t o t o 2 .5 −4// a l o r s argc vaudra 4 , argv [ 0 ] vaudra "./ a . out "// argv [ 1 ] " t o t o " , argv [ 2 ] "2.5" e t argv [ 3 ] "−4"int main ( int argc , char∗∗ argv ){

// l e s arguments sont des cha ines de ca rac t e r e// qu ’ on peut c on v e r t i r en doub le avec a to f , e t en i n t avec a t o iint n = atoi ( argv [ 3 ] ) ;double x = atof ( argv [ 2 ] ) ;

}

7. Variables

Les variables peuvent etre déclarées à n’importe quel endroit du programme (on dit qu’elles sont déclaréesà la volée). La variable est détruite lors de la fermeture de l’accolade. Les variables globales sont déclaréesà l’extérieur de toute fonction.

// par exemple on dec l a r e une v a r i a b l e g l o b a l eint Nglob = 10 ;

// e l l e sera connue dans t ou t e s l e s f on c t i on s qu i s u i v en tvoid f (double x ){

cout << "Nglob␣=␣" << Nglob << endl ;}

void g (double y ){


double z = 2.0∗ y ;for ( int i = 0 ; i < Nglob ; i++)

z ∗= double (i+1);

// on peut au s s i d e c l a r e r des v a r i a b l e l o c a l e s a l a f onc t i on gdouble w = −5.43 + z ;

cout << "w␣=␣" << w << endl ;

// t ou t e s l e s v a r i a b l e s l o c a l e s ( i c i w e t z ) sont d e t r u i t e s a l a fermeture// de l ’ acco lade

}

// i c i w e t z ne sont pas connuesw = 3 . 0 ; // erreur de compi la t ion

// on peut au s s i d e c l a r e r des v a r i a b l e s cons tantes , dont on// ne peut mod i f i e r l a va l eu r apres i n i t i a l i s a t i o nconst double epsilon = 1e−10;

epsilon = 3 . 0 ; // erreur de compi la t ion


8. Structures de contrôle

8.1. Opérateurs() opérateur d’accès[] opérateur d’accès. membre d’un objet ou structure-> raccourci pour (*pointeur).! opérateur non˜ non bit à bit

++ incrémentation (i++ est équivalent à i = i+ 1)−− décrémentation (i−− est équivalent à i = i− 1)∗ cible d’un pointeur ou multiplication& référence/ division− opposé d’un nombre ou soustraction+ addition de deux nombres% modulo (a%b équivaut à mod(a, b) en Fortran)<< flux de sortie ou décalage de bit>> flux d’entrée ou décalage de bit< signe strictement inférieur> signe strictement supérieur<= signe inférieur ou égal>= signe supérieur ou égal== signe égal (pour la comparaison)! = signe différent& et bit à bitˆ ou exclusif bit à bit| ou bit à bit

&& et logique|| ou logique? : structure if/else compacte= affectation∗ = a∗ = b équivaut à a = a ∗ b+ = a+ = b équivaut à a = a+ b/ = a/ = b équivaut à a = a/b% = a% = b équivaut à a = a%b− = a− = b équivaut à a = a− bˆ= aˆ= b équivaut à a = aˆb& = a& = b équivaut à a = a&b| = a| = b équivaut à a = a|b

On notera qu’il n’y a pas d’opérateur puissance (comme ** en Fortran), il faut utiliser la fonction pow(dans le package cmath). Voici un exemple d’utilisation de ces opérateurs.

// on suppose qu ’un o b j e t matr ice e s t cree avec une surcharge de l ’ opera teur ( )// on peut u t i l i s e r A( i , j ) pour mod i f i e r un element de l a matriceMatrice A ;A (0 , 3) = 2 . 3 ;

// l ’ opera teur [ ] e s t u t i l i s e pour l e s tab l eaux , vec teurs , e t cvector<double> v ;v [ 0 ] = 1 .2 e10 ;


// on peut d e c l a r e r un po in teur sur une matrice// on suppose que l ’ o b j e t Matrice con t i en t une f onc t i on GetM()Matrice∗ B ;

// on peut f a i r e po in t e r B sur AB = &A ;

// e t appe l e r GetM() s o i t avec ∗ , s o i t avec −>int n = (∗B ) . GetM ( ) ;n = B−>GetM ( ) ;

// ! e s t l ’ opera teur non , ! ( i >3) equ i vau t a ( i <=3)int i = 5 ;i f ( ! (i > 3) )

i = 7 ;

// && : e t l o g i que , | | : ou l o g i q u ei f ( ( ( i==3) | | (i == 7)) && (i <= 5))

{// i c i s e u l i = 3 d e v r a i t passer l a cond i t i on

}

// != e s t l ’ opera teur d i f f e r e n ti f ( ( i != 3) && (i >= 2))

{// i peut e t r e e ga l a 2 ou super i eur ou e ga l a 4

}

// ++ a gauche s i g n i f i e qu ’ on incremente avant d ’ u t i l i s e r l e r e s u l t a t// ++ a d r o i t e s i g n i f i e qu ’ on u t i l i s e d ’ abord l e r e s u l t a t avant d ’ incrementerv[++i ] = 3 . 4 ; // equ i vau t a i = i +1; v [ i ] = 3 . 4 ;v [ i++] = 3 . 4 ; // equ i vau t a v [ i ] = 3 . 4 ; i = i +1;

// idem pour l a decrementat ion −−v [ i−−] = 3 . 4 ; // equ i vau t a v [ i ] = 3 . 4 ; i = i −1;

// r e s t e d ’ une d i v i s i o n euc l i d i enne ( pour l e s e n t i e r s uniquement ) :int r = i%2; // vaut 1 s i i e s t impair

// on peut f a i r e l e s opera t i ons c l a s s i q u e s// par exemple i c i y = ( x + 2 .0 )∗3 .0 − 1.0/ x ;double x = 1 .2 , y = 0 . 8 ;y = (x + 2 . 0 ) ∗ 3 . 0 − 1 .0/ x ;

// ~ : non b i t a b i t// par exemple ~(00000001011) = 1111110100 s o i t −12 en decimali = ~11; // d e v r a i t f a i r e i = −12

// & : e t b i t a b i t , e t | : ou b i t a b i t , ^ : ou e x c l u s i fi = 6 | 12 ; // d e v r a i t f a i r e 0110 | 1100 = 1110 ( i =14)i = 6 & 12 ; // d e v r a i t f a i r e 0110 & 1100 = 0100 ( i =4)


i = 6 ^ 12 ; // d e v r a i t f a i r e 0110 ^ 1100 = 1010 ( i =10)

// << pour l e s s o r t i e s , >> pour l e s en t r e e scout << "coucou" << endl ;cin >> i ;

// ∗=, +=, /=, −=, %=, e t c f onc t i onnen t sur l e meme pr inc i p e :i += 4 ; // equ i vau t a f a i r e i = i + 4

// ? : pour un i f e l s e compactx = (i >= 3) ? 1 .23 : 0 . 4 ;// equ i vau t a i f ( i>= 3) { x = 1 .23 ;} e l s e { x = 0 . 4 ; }

8.2. Structure conditionnelle ifLe mot clé else est optionnel.

// s i i l y a une s eu l e i n s t r u c t i on , pas d ’ acco ladei f (i == 3)

cout << " i ␣vaut␣3" << endl ;else

cout << " i ␣ e s t ␣ d i f f e r e n t ␣de␣3" << endl ;

// sinon on met des acco ladesdouble x ;i f (i == 3)

{x = 0 . 4 5 ;cout << " i ␣vaut␣3" << endl ;

}else i f (i == 5)

{x = 0 . 5 2 ;cout << " i ␣vaut␣5" << endl ;

}else

{x = −0.2;cout << " i ␣ e s t ␣ d i f f e r e n t ␣de␣3␣ et ␣de␣5" << endl ;

}

8.3. Structure conditionnelle switchOn ne peut ici que comparer à des constantes (entiers ou caractères). C’est l’equivalent du select case en

fortran.

// par exemple sur un carac t e r echar lettre ;switch ( lettre )

{case ’ a ’ :// i n s t r u c t i o n s dans l e cas ou l e t t r e =’a ’cout << "␣ l e t t r e ␣=␣a" << endl ;


// mettre break a l a f i n ( o b l i g a t o i r e )break ;

case ’ b ’ :case ’ c ’ :case ’ d ’ :

// i c i l e t t r e vaut b c ou dcout << "␣ l e t t r e ␣=␣b␣c␣ou␣d" << endl ;break ;

default :// l e s au t r e s cas non t r a i t e scout << " l e t t r e ␣ inconnue " << endl ;

}

8.4. Boucle forSyntaxe :for (initialisation ; test ; itération) opération ;

Example :

// Comme pour i f , pas d ’ acco lade s i une s eu l e i n s t r u c t i o n// i c i on f a i t l a somme des e n t i e r s de 0 a 9int sum = 0 ;for ( int i = 0 ; i < 10 ; i++)

sum += i ;

// sum de v r a i t e t r e e ga l e a 45// l o r s qu ’ i l y a p l u s i e u r s i n s t r u c t i on s , on met des acco lades// i c i on decremente i par pas de 2for ( int i = 10 ; i >= 0 ; i −= 2)

{// on do i t o b t en i r i = 10 , 8 , 6 , 4 , 2 , 0cout << " i ␣=␣" << i << endl ;sum −= i ;

}

8.5. Boucle whileSyntaxe :

while (condition) operation ;

do operation while (condition) ;

Exemple :

// dans un premier cas on t e s t e l a cond i t i on avant// d ’ e f f e c t u e r l ’ opera t ionint i = 0 ;while (i < 10)

i++;


// dans un second cas , on f a i t l ’ opera t ion avant de t e s t e r l a cond i t i oni = 20 ;do

{cout <<"␣ i ␣=␣" << i << endl ;i++;

}while (i < 10 ) ;

8.6. Instructions break continueExemple :

// cont inue permet de sau t e r l e s i n s t r u c t i o n s p l a c e e s apresfor ( int i = 0 ; i < 10 ; i++)

{i f (i == 0)continue ;

// t ou t e s l e s l i g n e s qu i s u i v en t ne seron t pas// execu t e e s pour i = 0 , mais l e se ron t pour i > 0cout << " i ␣=␣" << i << endl ;

}

// break s o r t de l a bouc l efor ( int i = 0 ; i < 10 ; i++)

{i f (i == 5)break ;

// i c i a cause du break , on s o r t de l a bouc l e// pour i = 5 , l e s v a l e u r s 6 , 7 , 8 , 9 ne seron t// jamais parcourues

}

9. C++ : la couche objet

9.1. Encapsulation des donnéesOn peut ici utiliser le mot-clé struct, par défaut les membres d’une struct sont publiques, alors que les

membres d’une class sont privées par défaut.Exemple :

class NomClasse{

// par de fau t l e s membres sont p r i v e e sint ip ; // i c i une v a r i a b l e membre ( appe l ee a t t r i b u t )

// i c i une f onc t i on membre ( appe l ee methode )void CheckPrivate ( ){

cout << " c l a s s e ␣ok" << endl ;}


protected :// tous l e s membres p l a c e s apres sont ‘ ‘ p ro t e g e s ’ ’int jp ;

void CheckProtected ( ){


public :// tous l e s membres p l a c e s apres sont p u b l i c sint kp ;

void CheckPublic ( ){


// on peut i n s e r e r a t ou t moment l e mot c l e// p r i v a t e p u b l i c ou p ro t e c t ed pour s p e c i f i e r l e type des membres qu i s u i v en tprivate :int ip2 ;

} ;

int main ( ){

// dans une f onc t i on e x t e r i e u r e a l a c l a s s e// on n ’ a acces qu ’ aux donnees pu b l i q u e sNomClasse var ;

var . CheckPublic ( ) ; // OKvar . kp = 3 ; // OK

// pas d ’ acces aux donnees p r i v e e s ou pro t e g e e svar . ip = 1 ; // erreur de compi la t ionvar . CheckProtected ( ) ; // erreur de compi la t ion

return 0 ;}

9.2. HéritageTrois types d’héritage (public, private, protected), voici comment les types de données des attributs de

la classe mère sont transformés après héritage :

Données héritage public héritage protected héritage privatepublic public protected privateprotected protected protected privateprivate interdit interdit interdit

Exemple


// c l a s s e mereclass Mother{

// donnees p r i v e e sprivate :int i_private ;

// donnees p ro t e g e e sprotected :int i_protected ;

// donnees pu b l i q u e spublic :int i_public ;

} ;

// c l a s s e f i l l e , par exemple pour un h e r i t a g e p u b l i cclass Daughter : public Mother{

void Test ( ){

// on peut acceder a tous l e s membres de l a c l a s s e merei_protected = 0 ;

// sau f l e s donnees p r i v e e si_private = 0 ; // erreur de compi la t ion

}} ;

// pour un h e r i t a g e pro t egeclass Fille : protected Mother{} ;

class Father{

public :int j_public ;

} ;

// on peut f a i r e au s s i un h e r i t a g e mu l t i p l eclass Fils : public Mother , public Father{} ;

9.3. Fonctions et classes amiesExemple :

class Mother{

private :


int ip ;// f onc t i on amiefriend void affiche_ip ( const Mother &);

// c l a s s e amiefriend class Amie ;

} ;

// dans l a f onc t i on amie on peut acceder aux membres p r i v e e s de l a c l a s s evoid affiche_ip ( const Mother & var ){

cout << "␣ i ␣=␣" << var . ip << endl ;}

// pour l e s c l a s s e s amies :class Amie{

public :// l e s methodes ont acces aux donnees p r i v e e s de Mothervoid ChangeIp ( Mother & var , int j ){

var . ip = j ;}

} ;

int main ( ){

Mother var ;Amie a ;

a . ChangeIp (var , 3 ) ;

affiche_ip ( var ) ;}

9.4. Constructeur, destructeur

class Base{

protected :int i ;double x ;

// l e s cons t ruc t eu r s e t d e s t r u c t e u r s sont p u b l i c spublic :// un cons t ruc t eu r n ’ a pas de type de re tour// e t a l e meme nom que l a c l a s s eBase ( ){

// un cons t ruc t eu r s e r t a i n i t i a l i s e r l e s a t t r i b u t si = 0 ;x = 1 . 0 ;


}

// deuxieme cons t ruc t eurBase ( int j , double y ){

i = j ;x = y ;

}

// cons t ruc t eu r par cop ieBase ( const Base& var ){

i = var . i ;x = var . x ;

}

// un s eu l d e s t r u c t eu r p o s s i b l e~Base ( ){

// un de s t r u c t eu r s e r t a l i b e r e r l a memoire u t i l i s e e par l ’ o b j e t// i c i pas de t a b l e au a d e t r u i r e

}

} ;

class Daughter : public Base{

double y ;

public :// on app e l l e l e cons t ruc t eur de l a c l a s s e mere// e t l e s con s t ruc t eu r s des a t t r i b u t sDaughter (double z ) : Base ( ) , y (z ) {}

Daughter ( int j , double w , double z ) : Base (j , w ){

y = z ;}

// pour e v i t e r l e s convers ions imp l i c i t e s , mot c l e e x p l i c i texpl ic it Daughter ( int j ) : Base ( ){

y = 0 . 0 ;}

// pas beso in de d e c l a r e r l e d e s t r u c t eu r// l e d e s t r u c t eu r par de fau t e s t im p l i c i t e e t ne f a i t r i en

} ;

int main ( ){


// des qu ’ on dec l a r e un ob j e t , un cons t ruc t eur sera appe l e// s i pas d ’ argument comme i c i , l e cons t ruc t eur par de fau t Base ( ) e s t appe l eBase b ;

// appe l du second cons t ruc t eur de BaseBase a (4 , 5 . 0 ) ;

// appe l du cons t ruc t eur par cop ie ( e q u i v a l e n t a i n i t i a l i s e r c = a)Base c (a ) ;

// on peut au s s i appe l e r un cons t ruc t eur apres l a d e c l a r a t i onb = Base (6 , −2.0) ;

Daughter z ; // erreur a l a compi la t ion// car l e cons t ruc t eur par de fau t n ’ a pas e t e d e f i n i

Daughter w (2 , 5 . 23 , 0 . 4 3 ) ; // ok

// l o r s de l ’ acco lade fermante , l e s d e s t r u c t e u r s seron t appe l e sreturn 0 ;

}

9.5. Pointeur thisC’est un pointeur vers l’objet instancié.

class Base ;

void affiche_objet ( const Base& v ) ;

class Base{

public :int ip ;

void ModifieIp ( int j ){

ip = j ;

// s i on veut appe l e r une f onc t i on qu i prend en argument// l ’ o b j e t courant , on u t i l i s e t h i saffiche_objet (∗ this ) ;

}

void SetIp ( int j ){

ip = j ;}

} ;

void affiche_objet ( const Base& v ){

cout << " i ␣=␣" << v . ip << endl ;


}

int main ( ){

Base var ;

var . ModifieIp ( 4 ) ;// i l au ra i t e t e e q u i v a l e n t de f a i r e// var . Se t Ip ( 4 ) ; a f f i c h e_ob j e t ( var ) ;

return 0 ;}

9.6. Attributs et méthodes statiquesLes attributs statiques sont partagés par toutes les instances d’une classe. Les méthodes statiques ne

doivent pas modifier d’attribut dynamique, ni appeler des méthodes dynamiques. Les méthodes statiques sontcomplètement équivalentes à des fonctions usuelles (extérieures à la classe) excepté qu’elles sont encapsuléesdans une classe.

class Exemple{

public :// a t t r i b u t s dynamiquesint ip ;double x ;

// a t t r i b u t s s t a t i q u e s precedes par l e mot c l e s t a t i cstat ic int jp ;stat ic double y ;

// methodes dynamiquesvoid SetIp ( int j ){

ip = j ;}

// methodes s t a t i q u e s precedees par l e mot c l e s t a t i cstat ic void DisplayInfoClass ( ){

cout << "Cette ␣ c l a s s e ␣ne␣ s e r t ␣a␣ r i e n " << endl ;

ip = 0 ; // i n t e r d i t , e r reur de compi la t ionSetIp ( 3 ) ; // i n t e r d i t , e r reur de compi la t ion

jp = 3 ; // oui on a l e d r o i t}

} ;

// d e c l a r a t i on o b l i g a t o i r e des a t t r i b u t s s t a t i q u e s a l ’ e x t e r i e u r de l a c l a s s eint Exemple : : jp ( 3 ) ;double Exemple : : y ( 2 . 0 3 ) ;


int main ( ){

// pour mod i f i e r un membre s t a t i q u eExemple : : jp = −10;Exemple : : y = −0.45;

// pour appe l e r une f onc t i on s t a t i q u eExemple : : DisplayInfoClass ( ) ;

return 0 ;}

9.7. Méthodes virtuelles, polymorphismeLes méthodes virtuelles permettent de factoriser du code en écrivant des fonctions générales dans la

classe mère, qui appelle des méthodes définies dans les classes filles.

class Forme{

public :// pour une c l a s s e a b s t r a i t e l e d e s t r u c t eu r do i t e t r e v i r t u e lvirtual ~Forme ( ) {}

// on peut d e f i n i r des f onc t i on s v i r t u e l l e s// qu i se ron t surchargees dans l e s c l a s s e s d e r i v e e svirtual void Draw ( ){

// ne f a i t r ien , on s a i t pas comment de s s i n e r une forme genera l ecout << "Methode␣ i n d e f i n i e " << endl ;

}

// on peut d e c l a r e r des methodes v i r t u e l l e s pures// qu ’ on a pas beso in de d e t a i l l e r , car on cons idere// qu ’ e l l e ne seron t jamais appe l e e svirtual int GetNombrePoints ( ) = 0 ;

// dans une methode gener ique , on peut u t i l i s e r l e s methodes v i r t u e l l e s// qu i sont s p e c i a l i s e e s pour chaque formevoid AnalyseDessin ( ){

// i c i l a f onc t i on Draw appe l ee n ’ e s t pas forcement l a f onc t i on Draw()// d e f i n i e dans Forme , c e l a peut e t r e une f onc t i on d ’ une c l a s s e de r i v e eDraw ( ) ;

int n = GetNombrePoints ( ) ;cout << "␣Nombre␣de␣ po in t s ␣de␣ l a ␣ forme␣=␣" << n << endl ;

}

} ;

class Carre : public Forme


{public :// on surcharge l e s f on c t i on s v i r t u e l l e s de Formeint GetNombrePoints ( ){

return 4 ;}

void Draw ( ){

cout << "−−−" << endl ;cout << " | ␣ | " << endl ;cout << "−−−" << endl ;

}

} ;

class Triangle : public Forme{

public :// on surcharge l e s f on c t i on s v i r t u e l l e s de Formeint GetNombrePoints ( ){

return 3 ;}

void Draw ( ){

cout << " / | " << endl ;cout << "−−" << endl ;

}

} ;

int main ( ){

Forme b ; // erreur de compi la t ion car l a c l a s s e e s t a b s t r a i t e// ( a b s t r a i t e = con t i en t une methode v i r t u e l l e pure )

Carre quad ;

// l e s f on c t i on s Draw() e t GetNombrePoints ( ) du Carre seron t appe l e e squad . AnalyseDessin ( ) ;

Triangle tri ;

// l e s f on c t i on s Draw() e t GetNombrePoints ( ) du Triang le se ron t appe l e e stri . AnalyseDessin ( ) ;

// on peut au s s i c reer un o b j e t polymorphique// ( qu i pourra e t r e un t r i a n g l e ou un carre )Forme∗ forme ;


// i c i c ’ e s t un carreforme = new Carre ( ) ;

delete forme ;

// e t maintenant un t r i a n g l eforme = new Triangle ( ) ;

}

9.8. Surcharge des opérateurs

// par exemple s i on veut pouvoir f a i r e des opera t i ons// d irec tement sur l e s v e c t eu r sclass Vector{

protected :// donneesdouble∗ data ;// t a i l l e v ec t eurint m ;

public :

// on surcharge dans l a c l a s s e tous l e s opera t eur s i n t e rne s

// opera teur =Vector& operator=(const Vector& v ){

for ( int i = 0 ; i < m ; i++)data [ i ] = v (i ) ;

return ∗ this ;}

// opera teur d ’ acces ( )double operator ( ) ( int i ) const ;

// i c i c ’ e s t l ’ opera teur d ’ acces qu i peut e t r e u t i l i s e pour V( i ) = c t e ;double& operator ( ) ( int i ) ;

// l ’ opera teur d ’ acces ( ) peut e t r e surcharge// pour un nombre que lconque d ’ arguments (V( i , j ) = que l que chose )double& operator ( ) ( int i , int j ) ;

// opera teur s += ∗= −=Vector & operator +=(const Vector& v ) ;Vector & operator ∗=(const Vector& v ) ;Vector & operator −=(const Vector& v ) ;

// opera teur de pre−increment ++vVector & operator ++(void ) ;


// opera teur de post−increment v++Vector operator ++(int ) ;

// opera teur s de comparaisonbool operator ==(const Vector&) const ;bool operator !=(const Vector&) const ;bool operator <=(const Vector&) const ;bool operator >=(const Vector&) const ;bool operator <(const Vector&) const ;bool operator >(const Vector&) const ;

} ;

// l e s opera t eurs e x t e rne s sont d e f i n i s a l ’ e x t e r i e u rVector operator +(const Vector&, const Vector&);Vector operator −(const Vector&, const Vector&);Vector operator ∗( const Vector&, const Vector&);

// on peut gerer l e cas mixte Vector/ doub leVector operator ∗( const double&, const Vector&);Vector operator ∗( const Vector&, const double&);

// en su i t e dans l e main , on peut u t i l i s e r ces surchargesint main ( ){

Vector x , y , z ;

z = 2.0∗ x + y ;++x ;

x (0 ) = 3 . 0 ;// . . .

return 0 ;}

10. Structure d’un code

En dispose les déclarations des fonctions et classes (appelées prototypes) dans des fichiers d’en-tête(headers) dont l’extension se termine par .hpp, .H, .h++ ou .hxx. Les définitions sont elles placées dans desfichiers .cpp, .C, .cxx, .c++ ou .cc.

10.1. Prototype de fonctions, de classesUn prototype ne contient que la déclaration de la classe ou de la fonction

// exemple de pro to t ype d ’ une f onc t i on// l a f onc t i on e s t d e f i n i e dans un autre f i c h i e rvoid MaFunction ( const double&, int , double ∗ ) ;

// pa r f o i s deux c l a s s e s sont en t r e l a c e e s , i l e s t a l o r s u t i l e// de d e c l a r e r l ’ e x i s t e n c e d ’ une c l a s s e , avant de l a d e t a i l l e r p l u s l o i n :class MaClasse ;


// on peut a l o r s d e c l a r e r des p ro to t ype s de f onc t i on s// avec MaClasse en argumentvoid FunctionClasse ( const MaClasse &);

// exemple de pro to t ype d ’ une c l a s s eclass MaClasse{

public :int n ;double x ;

// on ne met que l e s p ro t o t ype s des f onc t i on s membresvoid Fonc1 (double ) ;int Fonc2 ( int ) ;

} ;

// Pour d e f i n i r l e s f onc t i on s membres Fonc1 e t Fonc2// a l ’ e x t e r i e u r de l a c l a s s e :void MaClasse : : Fonc1 (double y ){

x = 2.0∗ y ;}

int MaClasse : : Fonc2 ( int m ){

return m + n ;}

10.2. Directives du préprocesseurLes directives du préprocesseur commencent toutes par #.

// La d i r e c t i v e l a p l u s u t i l i s e e e s t l a d i r e c t i v e in c l ude// qu i i n c l u t de maniere d i r e c t e l e contenu d ’un f i c h i e r#include <iostream>

// l e f i c h i e r ios tream . h sera d irec tement in s e r e dans l e f i c h i e r

// pour un f i c h i e r personnel , on met des gu i l l emen t s#include "MonFichier . hxx"

// pour e v i t e r l e s mu l t i p l e s i n c l u s i on s , l e s f i c h i e r s comportent// tou jour s des l i g n e s de ce type :#ifndef FILE_MON_FICHIER_HEADER_HXX#define FILE_MON_FICHIER_HEADER_HXX// l ’ i d e n t i f i c a t e u r i c i d o i t e t r e unique parmi tous l e s f i c h i e r s i n c l u s// l e f a i t de mettre ce d e f i n e empeche une seconde i n c l u s i on du meme f i c h i e r// puisque FILE_MON_FICHIER_HEADER_HXX sera a l o r s d e f i n i

// on met i c i t ou t l e contenu du f i c h i e rclass Patati{} ;


// e t on termine par end i f#endif

// l a not ion de f l a g s e s t souvent u t i l i s e e , ce sont// des i n d i c a t e u r s qu ’ on peut d e f i n i r l o r s de l a compi la t ion// ( opt ion −Dnom_flag )// Par exemple s i on veut s p e c i f i e r dans l e code que// l a l i b r a i r i e Blas e s t u t i l i s e e , on va compi ler :// g++ −DUSE_BLAS to t o . cc − l b l a s

// e t dans l e f i c h i e r t o t o . cc , on va t r a i t e r di f feremment l e cas// ou on peut u t i l i s e r Blas , e t l e cas ou on ne peut pas#ifde f USE_BLAS// pa r t i e du code qu i ne sera a c t i v e e que s i l e f l a g USE_BLAS e s t d e f i n i// ( s o i t l o r s de l a compi la t ion s o i t par une d i r e c t i v e #de f i n e )// par exemple on u t i l i s e une rou t ine b l a s pour add i t i onner deux v e c t eu r sdaxpy_ (n , alpha , x , 1 , y , 1 ) ;

#else

// dans ce cas on a pas b la s , on f a i t une somme standardfor ( int i = 0 ; i < n ; i++)

y [ i ] += alpha∗x [ i ] ;

#endif

// pour a c t i v e r manuellement un f l a g#define USE_BLAS

// pour d e s a c t i v e r l e f l a g :#undef USE_BLAS

// on peut t e s t e r au s s i que l e f l a g e s t non a c t i f#ifndef USE_BLAS// dans ce cas , on a pas Blas

#endif

// l e s #de f i n e permet tent au s s i de d e f i n i r des macros// par exemple l a macro DISP// permet d ’ a f f i c h e r l e nom e t contenu d ’ une v a r i a b l e :#define DISP(x ) std : : cout << #x " : ␣" << x << std : : endl

// on peut a l o r s u t i l i s e r DISP partout , e t l e remplacement sera e f f e c t u e// par l e preproces seurDISP (x ) ; // sera remplace par s t d : : cout << " x : " << x << s td : : end l ;


10.3. Espace de nommages (namespace)Lorsqu’on écrit une librairie, toutes les fonctions et classes de la librairie sont encapsulées dans un espace

de nommage. L’espace de nommage de la STL est std.

// avant d ’ e c r i r e t ou t e f onc t i on de l a l i b r a i r i e , on met l e mot c l e namespacenamespace NomLibrairie{

int Fonc1 (double y ){

return int (y ) ;} ;

class MaClasse{

public :double x ;

} ;

} // f i n du namespace

// en su i t e s i on veut u t i l i s e r une f onc t i on du namespace ,// s o i t on f a i t NomLibrairie : :

void f ( ){

NomLibrairie : : Fonc1 ( 2 . 0 ) ;}

// s o i t on u t i l i s e l a commande using , e t on a pas beso in de// mettre NomLibrairie : :using namespace NomLibrairie ;

int main ( ){

Fonc1 ( 2 . 0 ) ;

return 0 ;}

11. Entrées-sorties

Exemple :

// iostream pour l e s en t r e e s s o r t i e s s tandard#include <iostream>

// fs tream pour l e s f i c h i e r s#include <fstream>



int main ( ){

// cout pour l e f l u x de s o r t i e a l ’ ecran// cerr pour l e f l u x des e r reur s// end l e s t un re tour cha r i o t avec v idage du b u f f e rcout << "Coucou␣" << endl ;

// cin pour l e f l u x d ’ en t ree au c l a v i e rint test_input ; double x ;cout << "Entrez ␣un␣ e n t i e r ␣ s u i v i ␣d␣un␣ f l o t t a n t " << endl ;cin >> test_input >> x ;

// par defaut , cout a f f i c h e 5 c h i f f r e s s i g n i f i c a t i f s// on peut en mettre p l u s avec p r e c i s i oncout . precision ( 1 5 ) ; // i c i 15 c h i f f r e s s i g n i f i c a t i f scout << "x␣=␣" << x << endl ;

// pour e c r i r e dans un f i c h i e r : o fs treamofstream file_out ( " s o r t i e . dat" ) ; // on e c r i t dans s o r t i e . dat

// l a syntaxe e s t l a meme que pour coutfile_out << "x␣=␣" << x << endl ;

// une f o i s l e s e c r i t u r e s terminees :file_out . close ( ) ;

// pour l i r e dans un f i c h i e r i f s t r eamifstream file_in ( " ent r e e . dat" ) ; // on l i t dans en t ree . dat

// premiere chose a f a i r e : v e r i f i e r que l e f i c h i e r e s t ouver ti f ( ! file_in . is_open ( ) )

{cout << " Imposs ib l e ␣de␣ l i r e ␣ l e ␣ f i c h i e r ␣ ent r e e . dat" << endl ;abort ( ) ; // abor t q u i t t e l e programme , p ra t i qu e pour debugguer

}

// en su i t e on peut l i r e une donneefile_in >> x ;

// on peut v e r i f i e r s i l a l e c t u r e de c e t t e donnee a marchei f ( ! file_in . good ( ) )

{// un echec peut ven i r d ’ une mauvaise donnee// ( par exemple s i i l y a un mot au l i e u d ’un nombre )cout << "Echec␣de␣ l e c t u r e " << endl ;abort ( ) ;

}

// on ferme l e f l u x une f o i s terminefile_in . close ( ) ;

// on peut ouvr i r un autre f i c h i e r avec l a methode open


file_in . open ( " autre . dat" ) ;file_in . close ( ) ;

// pour l i r e / e c r i r e en b i na i r e on u t i l i s e wr i t e e t readfile_out . open ( " binary . dat" ) ;// wr i t e demande des char , donc on c on v e r t i t t ou t en char∗file_out . write ( reinterpret_cast<char∗>(&x ) , s izeof (double ) ) ;file_out . close ( ) ;

file_in . open ( " binary . dat" ) ;// read demande des char , donc on c on v e r t i t t ou t en char∗file_in . read ( reinterpret_cast<char∗>(&x ) , s izeof (double ) ) ;file_out . close ( ) ;

return 0 ;}

12. Fonctions et classes génériques

Exemple de fonctions génériques :

// par exemple , s i l ’ on veut e c r i r e une f onc t i on// qu i marche a l a f o i s pour l e s complexes e t l e s r e e l s// p l u t o t que de dup l i qu e r l e code , on va e c r i r e// une f onc t i on prenant en parametre un type gener ique ,// par exemple pour l a norme d ’un vec t eur :template<class Vector>double Norm ( const Vector& x ){

double norm = 0 . 0 ;for (unsigned int i = 0 ; i < x . size ( ) ; i++)

norm += abs (x [ i ] ) ;

return norm ;}

// on peut avo i r p l u s i e u r s t ype s gener i que stemplate<class Matrix , class Vector1 , class Vector2>void MltAdd ( const Matrix& A , const Vector1& x , Vector2& y ){

// . . .}

int main ( ){

// l e s f on c t i on s s ’ u t i l i s e n t normalementvector<double> x ;cout << Norm (x ) << endl ;

// pour l e s v e c t eu r s complexesvector<complex<double> > xc ;cout << Norm (xc ) << endl ;


}

Exemple de classes génériques

// exemple d ’ une c l a s s e vec t eur// T peut e t r e un int , double , char , s t r i n g , e t ctemplate<class T>class Vector{

protected :// donneesT∗ data ;int m ;

public :int GetSize ( ){

return m ;}

} ;

// on peut mettre p l u s i e u r s parametrestemplate<class T , class Prop>class Base{

public :// de c l a r e r des f onc t i on s normalesvoid FoncNormale (double , double ) ;

// e t des f onc t i on s temp la tetemplate<class Vector>void FoncGeneric (double , Vector&);

} ;

// d e f i n i t i o n des f onc t i on s a l ’ e x t e r i e u r de l a c l a s s etemplate<class T , class Prop>void Base<T , Prop>:: FoncNormale (double x , double y ){}

// pour l a f onc t i on template , on a en premier l e s parametres// temp la te de l a c l a s s e pu i s ceux de l a f onc t i ontemplate<class T , class Prop> template<class Vector>void Base<T , Prop>:: FoncGeneric (double x , Vector& y ){}

// on peut en su i t e f a i r e une s p e c i a l i s a t i o n p a r t i e l l e de l a c l a s s e// l a c l a s s e a i n s i d e f i n i e remplacera completement l a c l a s s e// gener i que pour l e j eu de parametres c h o i s itemplate<class Prop>class Base<int , Prop>


{public :

} ;

// on peut f a i r e une s p e c i a l i s a t i o n t o t a l etemplate<>class Base<int , double>{} ;

int main ( ){

// l o r s de l ’ i n s t anc i a t i on , i l f a u t p r e c i s e r l e type des parametresVector<int> v ;

// i c i l e compi la teur c h o i s i r a l a c l a s s e Base gener i queBase<string , int> A ;

// i c i l e compi la teur c h o i s i r a l a c l a s s e Base s p e c i a l i s e e p a r t i e l l emen tBase<int , string> B ;

// i c i l e compi la teur c h o i s i r a l a c l a s s e s p e c i a l i s e e to ta l ementBase<int , double> C ;

}

Les paramètres template peuvent être introduits par le mot-clé typename (au lieu de class), et on peutaussi utiliser des constantes dont on connaitra la valeur à la compilation.

// i c i m des i gne l a t a i l l e du vec t eur// m e s t connu a l a compi la t ion , ce qu i permet de pouvoir e c r i r e// des a l g o s op t imi se s (meta−programing )template<typename T , int m>class TinyVector{

// comme m e s t connu a l a compi la t ion , on peut// u t i l i s e r des t a b l e aux s t a t i q u e sT data [ m ] ;

public :T operator ( ) ( int i ){

return data [ i ] ;}

} ;

int main ( ){

// dans l e main , on do i t p r e c i s e r l a t a i l l eTinyVector<double , 3> y ;

}


13. Exceptions en C++

Exemple

#include <iostream>#include <except ion>


// pour chaque nouv e l l e except ion , on f a i t une c l a s s e :class MonException{

public :string comment ; // commentaire a s s o c i e a l ’ e xcep t i on

// cons t ruc t eu r prenant un commentaire en argumentMonException ( const string& c ) : comment (c ) {}

} ;

int main ( ){

try{

// on met i c i l e code qu ’ on veut execu t e r// s i a un moment on a une erreur , on peut l ancer une excep t i onMonException a ( ‘ ‘ Argument invalide ’ ’ ) ;throw a ;

// une excep t i on peut e t r e de n ’ importe que l type// par exemple un en t i e rint b = 3 ;throw b ;

}catch ( MonException& err )

{// cas ou une excep t i on de type MonException a e t e lancee// on f a i t l e t ra i t emen t a s s o c i e e a c e t t e excpe t i on

}catch ( int a )

{// cas ou une excep t i on de type en t i e r a e t e l ancee

}catch ( . . . )

{// t ou t e s l e s au t r e s e x c ep t i on s// on peut appe l e r abor t par exemple s i on ne s a i t pas gerer// ce cas l aabort ( ) ;

}

return 0 ;}


14. Utilisation de la STL

14.1. Fonctions mathématiquesLes fonctions mathématiques sont contenues dans cmath.Exemple

#include <cmath>


int main ( ){

// c a l c u l de x^ydouble x = 2 .3 , y = 0 . 8 ;double z = pow (x , y ) ;

// s q r t : rac ine carree// exp : e x p on en t i e l l e// l o g : l ogar i thme neper ien// log10 : l ogar i thme en base 10// log2 : l ogar i thme en base 2// sin , cos , tan : f on c t i on s t r i g o s u s u e l l e s// asin , acos , atan : l e s arc cos , s in e t tan// sinh , cosh , tanh , asinh , acos , atanh : l e s cos , s in , e t c h yp e r bo l i q u e s// tgamma : f onc t i on gammaz = asin (x ) ;

// arrondi au p l u s proche// i c i on c on v e r t i t en en t i e r parce que round renvo ie un r e e lint n = int ( round (z ) ) ;

// arrondi i n f e r i e u rn = int ( floor (z ) ) ;

// arrondi super i eurn = int ( ceil (z ) ) ;

// d ’ au t r e s f onc t i on s e x i s t e n t}

14.2. Chaînes de caractères (string)Exemple

#include<st r ing>#include<iostream>#include<sstream>


// pour conv e r t i r un nombre en s t r i n gtemplate<typename T>in l ine std : : string to_str ( const T& input )


{std : : ostringstream output ;output << input ;return output . str ( ) ;

}

// pour conv e r t i r un s t r i n g en nombretemplate <class T>in l ine T to_num ( std : : string s ){

T num ;std : : istringstream str (s ) ;str >> num ;return num ;

}

int main ( ){

// pour manipuler l e s cha ines de carac t e re s , ne pas u t i l i s e r char∗ (C)// mais p l u t o t des s t r i n gstring s ( " toto " ) ;

// nombre de ca rac t e r e s : s i z e ( )cout << "nombre␣de␣ l e t t r e s ␣=␣" << s . size ( ) << endl ;

// pour acceder a chaque carac tere , opera teur [ ]s [ 1 ] = ’ y ’ ; // s vaut maintenant t y t o

// on peut comparer des s t r i n gi f (s == " tata " )

cout << " i n c o r r e c t " << endl ;

// on peut concatener avec l ’ opera teur +s = s + " . dat" ; // s vaut maintenant t y t o . dat

// on peut rechercher une chaineint pos = s . find ( " to " ) ; // pos d e v r a i t v a l o i r 2i f ( pos == string : : npos )

cout << "on␣n␣a␣pas␣ trouve ␣ l a ␣ chaine ␣ to ␣dans␣ s " << endl ;

// on peut e x t r a i r e une sous−chainestring s_sub = s . substr (pos , 3 ) ;// pour e x t r a i r e 3 ca rac t e r e s a p a r t i r de s [ pos ]

s_sub = s . substr ( pos ) ;// pour e x t r a i r e tous l e s ca ra c t e r e s a p a r t i r de s [ pos ]

// par exemple pour conv e r t i r i = 356 en s t r i n gint i = 356 ;s = to_str (i ) ;


// e t pour c onv e r t i r "3.1456" en doub les = string ( " 3 .1456 " ) ;double x = to_num<double>(s ) ;

}

14.3. Vecteurs

#include<vector>


int main ( ){

// l a c l a s s e vec t o r s t o c k e l e s e lements de maniere con t i gue// acces rapide , mais i n s e r t i o n l e n t evector<double> x ( 5 ) ; // vec t eur de 5 r e e l s

// acces avec [ ]x [ 0 ] = 1 .06e−7;x [ 1 ] = −3.5e8 ;

// on peut agrandir l e v ec t eur en gardant l e s anciens e lementsx . resize ( 6 ) ;

// l e s nouveaux e lements do i ven t e t r e i n i t i a l i s e sx [ 5 ] = 2 . 5 ;

// on peut au s s i r a j ou t e r un element a l a f i n du vec t eur// ( i e l e v ec t eur e s t r e t a i l l e e t un element e s t r a j ou t e )x . push_back ( 3 . 4 ) ; // e qu i v a l e n t a x . r e s i z e ( 7 ) ; x [ 6 ] = 3 . 4 ;

// on peut au s s i i n s e r e r un element avec in s e r t , e t d e t r u i r e l e v ec t eur avec c l e a rx . clear ( ) ;

}

14.4. Listes

#include<l i s t >#include <iostream>


int main ( ){

// une l i s t e ne s t o c k e pas l e s e lements de maniere con t i gue// ( pensez a une l i s t e simplement chainee )// l ’ i n s e r t i o n e s t rapide , mais l ’ acces e s t l e n tlist<double> v ;

// push_back e t i n s e r t e x i s t e n tv . push_back ( 3 . 4 ) ;v . push_back ( 0 . 3 ) ;


// pour parcour i r l a l i s t e , l e mieux e s t d ’ u t i l i s e r un i t e r a t e u rlist<double>:: iterator it ;cout << ‘ ‘ v = ‘ ‘ ;for (it = v . begin ( ) ; it != v . end ( ) ; ++it )

cout << ‘ ‘ ‘ ‘ << ∗it ;

cout << endl ;}

14.5. Piles

#include<stack>


int main ( ){

// s t a c k e s t un conteneur correspondant a une p i l e// ( premier entre , premier s o r t i )stack<double> pile ;

// on empi le l e s e lements avec pushpile . push ( 0 . 3 3 ) ;pile . push ( −0 .25) ;pile . push ( 1 . 3 ) ; // l a p i l e vaut (1 . 3 , −0.25 , 0 .33)

// on l i b e r e un element avec poppile . pop ( ) ; // l a p i l e vaut (−0.25 , 0 .33)

// pour acceder au dern i e r e lement topdouble y = pile . top ( ) ; // y = −0.25 e t l a p i l e vaut (−0.25 , 0 .33)

}

Documents

Aide Memoire C++