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 5
2.1 Types de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 Qualificatifs additionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

3 Pointeurs et références 7

4 Tableaux en C 8
4.1 Tableau statique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.2 Tableau dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.3 Tableau à plusieurs entrées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

5 Structures, énumérations 9

6 Fonctions 10
6.1 Surcharge de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
6.2 Passage par référence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
6.3 Passage par pointeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
6.4 Pointeurs et références de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
6.5 La fonction main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

7 Variables 15

8 Structures de contrôle 17
8.1 Opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
8.2 Structure conditionnelle if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
8.3 Structure conditionnelle switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
8.4 Boucle for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
8.5 Boucle while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
8.6 Instructions break continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

9 C++ : la couche objet 21

9.1 Encapsulation des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
9.2 Héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
9.3 Fonctions et classes amies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
9.4 Constructeur, destructeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
9.5 Pointeur this . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
9.6 Attributs et méthodes statiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
9.7 Méthodes virtuelles, polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
9.8 Surcharge des opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

10 Structure d’un code 31

10.1 Prototype de fonctions, de classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
10.2 Directives du préprocesseur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
10.3 Espace de nommages (namespace) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

11 Entrées-sorties 34

12 Fonctions et classes génériques 36

13 Exceptions en C++ 39
 page 4 Aide-mémoire C++ par Marc Duruflé

14 Utilisation de la STL 40
14.1 Fonctions mathématiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
14.2 Chaînes de caractères (string) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
14.3 Vecteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
14.4 Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
14.5 Piles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
 page 5 Aide-mémoire C++ par Marc Duruflé

1. Commentaires

/∗
Ceci e s t un commentaires s u r
plusieurs lignes (C e t C++) ∗/

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

double x = 3 . 0 ; // q u i p e u t e t r e d i s p o s e 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 Description
void type vide
bool booléen
int 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 positif
short entier court
long 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 f u n c t i o n q u i ne r e n v o i e r i e n
void affiche_reel ( double x )
{
cout << " ␣x␣=␣ " << x << endl ;
}

• bool Booleen (true or false)

bool test = true ;

// on p e u t l e s u t i l i s e r d i r e c t e m e n t dans l e s c o n d i t i o n s
i f ( test )
cout << " Test ␣ e s t ␣ v r a i ␣ " << endl ;

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

// l a c a s s e e s t i m p o r t a n t e , a e t A s o n t d e s c a r a c t e r e s d i f f e r e n t s
char lettre = ’A ’ ;
// l a c o r r e s p o n d a n c e c a r a c t e r e <−> nombre e s t a s s u r e e par
// l a t a b l e a s c i i , par exemple ’ 0 ’ = 48
char zero = ’ 0 ’ , zero_bis = 4 8 ;
// i l y a a u s s i d e s c a r a c t e r e s s p e c i a u x
 page 6 Aide-mémoire C++ par Marc Duruflé

// \ t ( t a b u l a t i o n ) , \n ( r e t o u r c h a r i o t ) , e t c
lettre = ’ \n ’ ;

• int Entier (codé sur 4 octets)

// pas d ’ o v e r f l o w ( depassement ) s i n e s t compris e n t r e

// −2 147 483 647 e t 2 147 483 647
int n = 3 4 5 ;

// par d e f a u t un e n t i e r ( i c i 345) e s t e c r i t en b a s e d e c i m a l e
// on p e u t e n t r e r un l i t e r a l en b a s e h e x a d e c i m a l e
// en commencant par 0 x
n = 0 xA34E ; // n = A34E en h e x a d e c i m a l

// pour l e s e n t i e r s en b a s e 8 , on commence par 0

n = 0 2 3 4 7 2 ; // n v a u t 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 i m p l e p r e c i s i o n , a j o u t e r f :
float 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 d o u b l e p r e c i s i o n :
double x = 1 . 2 3 , y = −5.04 e10 ;

• int64_t Entier (codé sur 8 octets)

// a i n c l u r e pour a v o i r l e t y p e i n t 6 4 _ t
#include<s t d i n t . h>

using namespace std ;

// pas d ’ o v e r f l o w ( depassement ) s i n e s t compris e n t r e

// −9e18 e t 9 e18
int64_t n = 3 4 5 ;

2.2. Qualificatifs additionnels

• short Pour déclarer une variable de plus faible précision
 page 7 Aide-mémoire C++ par Marc Duruflé

// i l n ’ y a pas de r e g l e , mais par exemple s h o r t i n t e s t en g e n e r a l

// s t o c k e s u r 2 o c t e t s (−32 768 a 32 767)
short int n = 1 0 4 5 ;

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

// i l n ’ y a pas de r e g l e , mais par exemple l o n g d o u b l e e s t en g e n e r a l

// s t o c k e s u r 10 o c t e t s ( d o u b l e p r e c i s i o n e t e n d u e )
// m e t t r e L a l a f i n d e s l i t e r a u x
long double x = 0 . 1 2 3 4 L ;

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

// Par d e f a u t l e s e n t i e r s s o n t s i g n e s , pour d e c l a r e r un e n t i e r p o s i t i f :
unsigned int i = 2 3 ;
// l ’ a v a n t a g e e s t a l o r s que i p e u t a l l e r de 0 a 4 m i l l i a r d s

// l e s c a r a c t e r e s non s i g n e s e x i s t e n t a u s s i ( a l l a n t de 0 a 256)
unsigned char c = 2 3 ;

3. Pointeurs et références

Un pointeur est une variable contenant l’adresse d’une autre variable. Le contenu du pointeur q est alors
accédé par ∗ q et l’adresse d’une variable x est accédée par & x :
double x = 1 . 0 ; // x v a u t 1 . 0
double y = 2 . 0 ; // y v a u t 2 . 0
double∗ q ; // on d e c l a r e un p o i n t e u r s u r un d o u b l e
q = NULL ; // on s p e c i f i e i c i que q ne p o i n t e v e r s r i e n
q = &x ; // q p o i n t e maintenant v e r s l a v a r i a b l e x
∗q = 3 . 0 ; // x v a u t 3 . 0
q = &y ; // q p o i n t e maintenant v e r s l a v a r i a b l e y
∗q = 4 . 0 ;
// y v a u t maintenant 4 . 0
x = ∗q ;
// x v a u t maintenant 4 . 0

// on p e u t a l l o u e r un n o u v e l emplacement memoire pour q

// ( q u i s e r a n i x , n i y )
q = new double ;
∗q = 2 . 0 ; // x e t y s o n t i n c h a n g e s

q = &x ; // i c i c ’ e s t t r e s d a n g e r e u x
// c a r on per d l ’ a d r e s s e r e s e r v e e au−d e s s u s
// 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 p e u t a u s s i a l l o u e r p l u s i e u r s c a s e s ( pas une s e u l e )
q = new double [ 3 ] ; // 3 c a s e s i c i
// e t a c c e d e r aux a u t r e s c a s e s a v e c [ ]
 page 8 Aide-mémoire C++ par Marc Duruflé

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 e n c e s p e u v e n t a u s s i e t r e u t i l i s e e s
// pour d e f i n i r d e s a l i a s ( s a n s a v o i r a e c r i r e de ∗)
double& alias_x = x ;

// t o u t changement s u r a l i a s _ x s e r e p e r c u t e r a s u r x e t v i c e v e r s a
alias_x = −1.0; // x e t a l i a s _ x v a l e n t −1

4. Tableaux en C

4.1. Tableau statique

C’est un tableau dont on connait la taille lors de la compilation.
// par exemple un t a b l e a u de 4 r e e l s :
// par d e f a u t l e s v a l e u r s de y ne s o n t pas i n i t i a l i s e e s
double y [ 4 ] ;

// on u t i l i s e l ’ o p e r a t e u r [ ] pour a c c e d e r aux e l e m e n t s du t a b l e a u
// l e s i n d i c e s commencent a 0
y [ 0 ] = 3 . 0 3 ; y [ 1 ] = −2e10 ; y [ 2 ] = 5 . 5 4 e3 ; y [ 3 ] = 2 . 0 2 e −5;

// on p e u t i n i t i a l i s e r t o u t l e t a b l e a u a v e c l e s { } :
int n [ 4 ] = { −31 , 4 3 , 3 , 1 0 } ;

4.2. Tableau dynamique

C’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 a u
int n ;
cout << " Entre z ␣n␣ " << endl ;
cin >> n ;

// on a l l o u e l e t a b l e a u a v e c l ’ o p e r a t e u r new
double∗ x ; // x p o i n t e u r v e r s l a p r e m i e r e c a s e du t a b l e a u
x = new double [ n ] ;

// on u t i l i s e l ’ o p e r a t e u r [ ] pour a c c e d e r aux e l e m e n t s du t a b l e a u
// l e s i n d i c e s commencent a 0
x [ 0 ] = 3 . 0 3 ; x [ 1 ] = −2e10 ; x [ 2 ] = 5 . 5 4 e3 ; x [ 6 ] = 2 . 0 2 e −5;

// on d e s a l l o u e l e t a b l e a u a v e c l ’ o p e r a t e u r d e l e t e [ ]
delete [ ] x ;
 page 9 Aide-mémoire C++ par Marc Duruflé

4.3. Tableau à plusieurs entrées

La syntaxe des tableaux statiques multidimensionnels est la suivante :
// exemple de t a b l e a u 3 x2 qu ’ on i n i t i a l i s e
double A [ 3 ] [ 2 ] = { { 0 . 5 , 0 . 6 } , { −0.3 , 0 . 1 } , { 0 . 9 , −0.9}};

// on a c c e d e aux e l e m e n t s en e c r i v a n t A[ i ] [ j ]
cout << " ␣A [ 1 ] [ 0 ] ␣ " << A [ 1 ] [ 0 ] << endl ;

// on p e u t e c r i r e un t a b l e a u a v e c 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 a u t r i d i m e n s i o n n e l
int 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 en
Fortran90. Toutefois il est possible de construire des vecteurs de vecteurs, avec le désavantage que ce type
de structure ne stockera pas les éléments de manière contigüe. En voici un exemple :
// pour un v e c t e u r de v e c t e u r s , on met deux e t o i l e s
// on met a u t a n t d ’ e t o i l e s qu ’ i l y a d ’ i n d i c e s
double ∗∗ V ;

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

// e n s u i t e on a l l o u e chaque l i g n e
// chaque l i g n e p e u t a v o 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 l e m e n t s de l a s e c o n d e l i g n e ne s e r o n t pas s t o c k e s
// p h y s i q u e m e n t j u s t e a p r e s ceux de l a p r e m i e r e l i g n e ( s t o c k a g e non c o n t i g u )
int n = 7 ;
f o r ( int i = 0 ; i < m ; i++)
V [ i ] = new double [ n ] ;

// e n s u i t e on m o d i f i e un e l e m e n t de V a v e c V[ i ] [ j ]
V [0][4] = 3.0;

// on d o i t d e s a l l o u e r chaque l i g n e separement
f o r ( int i = 0 ; i < m ; i++)
delete [ ] V [ i ] ;

// p u i s d e s a l l o u e r l e t o u t
delete [ ] V ;

5. Structures, énumérations

Une structure contient plusieurs champs, c’est l’équivalent des types composés Fortran.
struct NomStructure
{
// nombre d e s i n v i t e s
int nombre_invites ;
 page 10 Aide-mémoire C++ par Marc Duruflé

// t a b l e a u c o n t e n a n t l a t a i l l e d e s i n v i t e s
double∗ taille_invites ;

// nom de l ’ evenement
char∗ nom ;
};

// on d e c l a r e une v a r i a b l e de t y p e NomStructure
NomStructure repas ;

// pour m o d i f i e r l e s membres de l a s t r u c t u r e , o p e r a t e u r .
repas . nombre_invites = 1 0 ;

// on p e u t a u s s i d e c l a r e r a l a v o l e e une s t r u c t u r e
// s a n s donner de nom :
struct { double x , y ; } var ;

// e t m o d 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 p e u t a u s s i u t i l i s e r l e mot c l e t y p e d e f
typedef struct { int i ; double x ; } NomStruct ;

// p u i s d e c l a r e r l a v a r i a b l e de t y p e NomStruct
NomStruct x ;
Une énumération permet de définir des constantes entières dans un programme et de les nommer, ce qui
rend le code plus lisible.
// par exemple on enumere t o u t e s l e s c o n d i t i o n s aux l i m i t e s
// qu ’ on s a i t t r a i t e r a v e c l e code :
enum{ DIRICHLET , NEUMANN , IMPEDANCE } ;

// c e s c o n s t a n t e s s o n t d e s e n t i e r s , qu ’ on p e u t u t i l i s e r :
int condition = NEUMANN ;

// e n s u i t e , au l i e u de f a i r e un t e s t
// i f ( c o n d i t i o n == 1 ) , on met l e nom
i f ( condition == DIRICHLET )
{
// on f a i t l e t r a i t e m e n t de l a c o n d i t i o n 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 fonctions

Une 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.
 page 11 Aide-mémoire C++ par Marc Duruflé

// exemple t r i v i a l d ’ une f o n c t i o n r e n v o y a n t x+y

double Add ( double x , double y )
{
return x + y ;
}

// on p e u t s u r c h a r g e r c e t t e f o n c t i o n pour d e s arguments d i f f e r e n t s
int 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 p r o c e d u r e en m e t t a n t v o i d comme t y p e de r e t o u r
void test_procedure ( double x , double y )
{
// r e t u r n s e r t i c i a q u i t t e r l a p r o c e d u r e
i f ( x == y )
return ;

// l e programme c o n t i n u e r a que s i x e s t d i f f e r e n t de y
cout << " 1 / ( x−y ) ␣=␣ " << 1 . 0 / ( x−y ) << endl ;
}

// on p e u t s p e c i f i e r d e s arguments o p t i o n n e l s a l a f i n d e s arguments
// on l e u r donne une v a l e u r par d e f a u t , i c i z e s t un argument o p t i o n n e l
// s ’ i l n ’ e s t pas r e m p l i , i l v a u t 1 . 0
double Mlt ( double x , double y , double z = 1 . 0 )
{
return x∗y∗z ;
}

int main ( )
{
// pour a p p e l e r une f o n c t i o n , on e c r i t son nom a v e c l e s arguments
double x = Add ( 1 . 3 , 1 . 4 ) ;
double y = Add ( x , 0 . 4 5 , 1 . 2 3 ) ;

test_procedure ( x , y ) ;

// on p e u t a p p e l e r Mlt a v e c t r o i s arguments
double z = Mlt ( x , y , 2 . 3 ) ;

// ou a v e c deux arguments , l e d e r n i e r p r e n a n t
// l a v a l e u r par d e f a u t ( 1 . 0 i c i )
z = Mlt ( x , y ) ;

return 0 ;
 page 12 Aide-mémoire C++ par Marc Duruflé

6.2. Passage par référence

Par 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 o n c t i o n a v e c d e s arguments u s u e l s
double Add ( double x , double y )
{
// on p e u t m o d i f i e r l e s c o p i e s l o c a l e s de x e t y
// l a v a l e u r de x e t y ne s e r a pas m o d i f i e e en s o r t i e de f o n c t i o n
x += 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 e n t t o u j o u r s 3 . 2 e t 2 . 3
return 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 v o l u m i n e u s e
struct BigArray
{
double A [ 1 0 0 0 ] ;
};

// on p a s s e x e t t a b par r e f e r e n c e , i l s p e u v e n t e t r e m o d i f i e s
// de p l u s aucune c o p i e l o c a l e de t a b n ’ e s t e f f e c t u e e
void modify_argument ( double& x , BigArray& tab )
{
f o r ( int i = 0 ; i < 1 0 0 0 ; i++)
tab . A [ i ] ∗= x ;

x += 1 . 0 ;
}

// on p e u t u t i l i s e r l e mot−c l e c o n s 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 p a s s e par r e f e r e n c e
// l e b u t e s t i c i d ’ e v i t e r l a c o p i e l o c a l e d ’ un g r o s o b j e t
void test_argument ( const BigArray& t )
{
t . A [ 0 ] = 2 . 0 ; // e r r e u r a l a c o m p i l a t i o n
}

int main ( )
 page 13 Aide-mémoire C++ par Marc Duruflé

{
double x = 2 . 0 ;
BigArray tab ;
f o r ( int i = 0 ; i < 1 0 0 0 ; i++)
tab . A [ i ] = double ( i ) ;

modify_argument ( x , tab ) ;
// x e t t a b ont e t e m o d i f i e s

return 0 ;
}

6.3. Passage par pointeur

Une 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 r e p r e n d l e meme exemple que precedemment
void modify_argument ( double∗ x , BigArray ∗ tab )
{
// on d o i t a l o r s a d a p t e r l a f o n c t i o n
f o r ( int i = 0 ; i < 1 0 0 0 ; i++)
tab−>A [ i ] ∗= ∗x ;

∗x += 1 . 0 ;
}

// l e p a s s a g e par p o i n t e u r e s t n a t u r e l pour un t a b l e a u
double sum ( double∗ x , int n )
{
// on r e n v o i e l a somme d e s e l e m e n t s du t a b l e a u x
double sum = 0 . 0 ;
f o r ( int i = 0 ; i < n ; i++)
sum += x [ i ] ;

return sum ;
}

int main ( )
{
double x = 2 . 0 ;
BigArray tab ;

// on p a s s e i c i l e s a d r e s s e s d e s o b j e t s
modify_argument(&x , &tab ) ;

double∗ vec ;
int n = 1 0 ;
vec = new double [ n ] ;

// pour un t a b l e a u , on l e p a s s e d i r e c t e m e n t
// p u i s q u e c ’ e s t d e j a un p o i n t e u r
x = sum ( vec , n ) ;
 page 14 Aide-mémoire C++ par Marc Duruflé

delete [ ] vec ;

return 0 ;
}

6.4. Pointeurs et références de fonctions

Grace à ces fonctionnalités on peut construire des tableaux de fonctions ou passer une fonction en
paramètre.
// une r e f e r e n c e de f o n c t i o n s ’ e c r i t s o u s l a forme
// t y p e _ r e t o u r (&nom_fct ) ( arguments )

// un p o i n t e u r de f o n c t i o n s ’ e c r i t s o u s l a forme
// t y p e _ r e t o u r (∗ nom_fct ) ( arguments )

// par exemple on c o n s t r u i t une f o n c t i o n g e n e r i q u e

// pour c a l c u l e r l ’ i n t e g r a l e de f e n t r e a e t b , ou f
// e s t une f o n c t i o n q u i e s t p a s s e e en parametre
double integrate ( double a , double b , int N , double (&f ) ( double ) )
{
double sum = 0 . 0 ;
double h = ( b−a ) / N ;
f o r ( int i = 0 ; i < N ; i++)
{
double x = ( double ( i ) + 0 . 5 ) ∗ h + a ;
sum += h∗f ( x ) ;
}

return sum ;
}

// exemple de f o n c t i o n dont on v e u t c a l c u l e r l ’ i n t e g r a l e
double func ( double x )
{
return x∗x + sin ( 0 . 5 ∗ x ) ;
}

int main ( )
{
cout << " I n t e g r a l e ␣ de ␣ exp ␣=␣ " << integrate ( 0 . 0 , 1 . 0 , 2 0 , exp ) << endl ;
cout << " I n t e g r a l e ␣ de ␣ f u n c ␣=␣ " << integrate ( 0 . 0 , 1 . 0 , 2 0 , func ) << endl ;

// on d e c l a r e un nouveau t y p e f p t r q u i e s t un p o i n t e u r de f o n c t i o n
// r e n v o y a n t un d o u b l e a v e c un d o u b l e en parametre
typedef double ( ∗ fptr ) ( double ) ;

// on d e c l a r e un t a b l e a u c o n t e n a n t t r o i s f o n c t i o n s de ce t y p e
fptr tab_fct [ 3 ] ;

// on i n i t i a l i s e l e t a b l e a u
tab_fct [ 0 ] = &exp ;
 page 15 Aide-mémoire C++ par Marc Duruflé

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

f o r ( int i = 0 ; i < 3 ; i++)

cout << " I n t e g r a l e ␣ de ␣ f _ i ␣=␣ "
<< integrate ( 0 . 0 , 1 . 0 , 2 0 , ∗ tab_fct [ i ] ) << endl ;

return 0 ;
}

6.5. La fonction main

La 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 r e n v o i e 0 s i l e programme s ’ e s t b i e n d e r o u l e
// un a u t r e e n t i e r s ’ i l y a eu une e r r e u r
return 0 ;
}
On peut également récupérer les arguments de la ligne de commande :
// Par exemple s i vous a v e z e x e c u t e v o t r e programme en t a p a n t :
// . / a . o u t t o t o 2 . 5 −4
// a l o r s a r g c vaudra 4 , a r g v [ 0 ] vaudra " . / a . o u t "
// a r g v [ 1 ] " t o t o " , a r g v [ 2 ] " 2 . 5 " e t a r g v [ 3 ] "−4"
int main ( int argc , char ∗∗ argv )
{
// l e s arguments s o n t d e s c h a i n e s de c a r a c t e r e
// qu ’ on p e u t c o n v e r t i r en d o u b l e a v e c a t o f , e t en i n t a v e c a t o i
int 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 d e c l a r e une v a r i a b l e g l o b a l e
int Nglob = 1 0 ;

// e l l e s e r a connue dans t o u t e s l e s f o n c t i o n s q u i s u i v e n t
void f ( double x )
{
cout << " Nglob ␣=␣ " << Nglob << endl ;
}

void g ( double y )
{
 page 16 Aide-mémoire C++ par Marc Duruflé

double z = 2 . 0 ∗ y ;
f o r ( int i = 0 ; i < Nglob ; i++)
z ∗= double ( i +1);

// on p e u t a u s s i d e c l a r e r d e s v a r i a b l e l o c a l e s a l a f o n c t i o n g
double w = −5.43 + z ;

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

// t o u 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 ) s o n t d e t r u i t e s a l a f e r m e t u r e
// de l ’ a c c o l a d e
}

// i c i w e t z ne s o n t pas connues
w = 3 . 0 ; // e r r e u r de c o m p i l a t i o n

// on p e u t a u s s i d e c l a r e r d e s v a r i a b l e s c o n s t a n t e s , dont on
// ne p e u t m o d i f i e r l a v a l e u r a p r e s i n i t i a l i s a t i o n
const double epsilon = 1e −10;

epsilon = 3 . 0 ; // e r r e u r de c o m p i l a t i o n
 page 17 Aide-mémoire C++ par Marc Duruflé

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 s u p p o s e qu ’ un o b j e t m a t r i c e e s t c r e e a v e c une s u r c h a r g e de l ’ o p e r a t e u r ( )
// on p e u t u t i l i s e r A( i , j ) pour m o d i f i e r un e l e m e n t de l a m a t r i c e
Matrice A ;
A (0 , 3) = 2 . 3 ;

// l ’ o p e r a t e u r [ ] e s t u t i l i s e pour l e s t a b l e a u x , v e c t e u r s , e t c
vector<double> v ;
v [ 0 ] = 1 . 2 e10 ;
 page 18 Aide-mémoire C++ par Marc Duruflé

// on p e u t d e c l a r e r un p o i n t e u r s u r une m a t r i c e
// on s u p p o s e que l ’ o b j e t M a t r i c e c o n t i e n t une f o n c t i o n GetM ( )
Matrice ∗ B ;

// on p e u t f a i r e p o i n t e r B s u r A
B = &A ;

// e t a p p e l e r GetM ( ) s o i t a v e c ∗ , s o i t a v e c −>
int n = ( ∗ B ) . GetM ( ) ;
n = B−>GetM ( ) ;

// ! e s t l ’ o p e r a t e u r non , ! ( i >3) e q u i v a u t a ( i <=3)

int i = 5 ;
i f ( ! ( i > 3) )
i = 7;

// && : e t l o g i q u e , | | : ou l o g i q u e
i f ( ( ( i==3) | | ( i == 7 ) ) && ( i <= 5 ) )
{
// i c i s e u l i = 3 d e v r a i t p a s s e r l a c o n d i t i o n
}

// != e s t l ’ o p e r a t e u r d i f f e r e n t
i f ( ( i != 3 ) && ( i >= 2 ) )
{
// i p e u t e t r e e g a l a 2 ou s u p e r i e u r ou e g a l a 4
}

// ++ a gauche s i g n i f i e qu ’ on i n c r e m e n t e a v a n t 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 a v a n t d ’ i n c r e m e n t e r
v[++i ] = 3 . 4 ; // e q u i v a u t a i = i +1; v [ i ] = 3 . 4 ;
v [ i++] = 3 . 4 ; // e q u i v a u t a v [ i ] = 3 . 4 ; i = i +1;

// idem pour l a d e c r e m e n t a t i o n −−
v [ i−−] = 3 . 4 ; // e q u i v a u t a v [ i ] = 3 . 4 ; i = i −1;

// r e s t e d ’ une d i v i s i o n e u c l i d i e n n e ( pour l e s e n t i e r s uniquement ) :

int r = i%2; // v a u t 1 s i i e s t i m p a i r

// on p e u t f a i r e l e s o p e r a t i o n s 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 d e c i m a l
i = ~ 1 1 ; // 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 f
i = 6 | 1 2 ; // d e v r a i t f a i r e 0110 | 1100 = 1110 ( i =14)
i = 6 & 1 2 ; // d e v r a i t f a i r e 0110 & 1100 = 0100 ( i =4)
 page 19 Aide-mémoire C++ par Marc Duruflé

i = 6 ^ 1 2 ; // 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 e n t r e e s

cout << " coucou " << endl ;
cin >> i ;

// ∗=, +=, /=, −=, %=, e t c f o n c t i o n n e n t s u r l e meme p r i n c i p e :

i += 4 ; // e q u i v a u t a f a i r e i = i + 4

// ? : pour un i f e l s e compact
x = ( i >= 3 ) ? 1 . 2 3 : 0 . 4 ;
// e q u i v a u t a i f ( i>= 3) { x = 1 . 2 3 ; } e l s e { x = 0 . 4 ; }

8.2. Structure conditionnelle if

Le mot clé else est optionnel.
// s i i l y a une s e u l e i n s t r u c t i o n , pas d ’ a c c o l a d e
i 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 ;

// s i n o n on met d e s a c c o l a d e s
double x ;
i f ( i == 3 )
{
x = 0.45;
cout << " i ␣ vaut ␣ 3 " << endl ;
}
e l s e i f ( i == 5 )
{
x = 0.52;
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 ␣ e t ␣ de ␣ 5 " << endl ;
}

8.3. Structure conditionnelle switch

On ne peut ici que comparer à des constantes (entiers ou caractères). C’est l’equivalent du select case en
fortran.
// par exemple s u r un c a r a c t e r e
char lettre ;
switch ( lettre )
{
case ’ a ’ :
// i n s t r u c t i o n s dans l e c a s ou l e t t r e =’a ’
cout << " ␣ l e t t r e ␣=␣ a " << endl ;
 page 20 Aide-mémoire C++ par Marc Duruflé

// m e t t r e b r e a k 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 v a u t b c ou d
cout << " ␣ l e t t r e ␣=␣b␣ c ␣ou␣d" << endl ;
break ;
default :
// l e s a u t r e s c a s non t r a i t e s
cout << " l e t t r e ␣ i n c o n n u e " << endl ;
}

8.4. Boucle for

Syntaxe :
for (initialisation ; test ; itération) opération ;
Example :
// Comme pour i f , pas d ’ a c c o l a d e s i une s e u l e i n s t r u c t i o n
// i c i on f a i t l a somme d e s e n t i e r s de 0 a 9
int sum = 0 ;
f o r ( int i = 0 ; i < 1 0 ; i++)
sum += i ;

// sum d e v r a i t e t r e e g a l e a 45
// l o r s q u ’ i l y a p l u s i e u r s i n s t r u c t i o n s , on met d e s a c c o l a d e s
// i c i on decremente i par pas de 2
f o r ( int i = 1 0 ; i >= 0 ; i −= 2 )
{
// on d o i t o b t e n i r i = 10 , 8 , 6 , 4 , 2 , 0
cout << " i ␣=␣ " << i << endl ;
sum −= i ;
}

8.5. Boucle while

Syntaxe :

while (condition) operation ;

do operation while (condition) ;

Exemple :

// dans un p r e m i e r c a s on t e s t e l a c o n d i t i o n a v a n t
// d ’ e f f e c t u e r l ’ o p e r a t i o n
int i = 0 ;
while ( i < 1 0 )
i++;
 page 21 Aide-mémoire C++ par Marc Duruflé

// dans un second cas , on f a i t l ’ o p e r a t i o n a v a n t de t e s t e r l a c o n d i t i o n

i = 20;
do
{
cout <<" ␣ i ␣=␣ " << i << endl ;
i++;
}
while ( i < 1 0 ) ;

8.6. Instructions break continue

Exemple :
// c o n t i n u e permet de s a u 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 a p r e s
f o r ( int i = 0 ; i < 1 0 ; i++)
{
i f ( i == 0 )
continue ;

// t o u t e s l e s l i g n e s q u i s u i v e n t ne s e r o n t pas
// e x e c u t e e s pour i = 0 , mais l e s e r o n t pour i > 0
cout << " i ␣=␣ " << i << endl ;
}

// b r e a k s o r t de l a b o u c l e
f o r ( int i = 0 ; i < 1 0 ; i++)
{
i f ( i == 5 )
break ;

// i c i a c a u s e du break , on s o r t de l a b o u c l e
// pour i = 5 , l e s v a l e u r s 6 , 7 , 8 , 9 ne s e r o n t
// j a m a i s p a r c o u r u e s
}

9. C++ : la couche objet

9.1. Encapsulation des données

On 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 :
c l a s s NomClasse
{
// par d e f a u t l e s membres s o n t p r i v e e s
int ip ; // i c i une v a r i a b l e membre ( a p p e l e e a t t r i b u t )

// i c i une f o n c t i o n membre ( a p p e l e e methode )

void CheckPrivate ( )
{
cout << " c l a s s e ␣ ok " << endl ;
}
 page 22 Aide-mémoire C++ par Marc Duruflé

protected :
// t o u s l e s membres p l a c e s a p r e s s o n t ‘ ‘ p r o t e g e s ’ ’
int jp ;

void CheckProtected ( )
{
cout << " c l a s s e ␣ ok " << endl ;
}

public :
// t o u s l e s membres p l a c e s a p r e s s o n t p u b l i c s
int kp ;

void CheckPublic ( )
{
cout << " c l a s s e ␣ ok " << endl ;
}

// on p e u t i n s e r e r a t o u t moment l e mot c l e
// p r i v a t e p u b l i c ou p r o t e c t e d pour s p e c i f i e r l e t y p e d e s membres q u i s u i v e n t
private :
int ip2 ;

};

int main ( )
{
// dans une f o n c t i o n e x t e r i e u r e a l a c l a s s e
// on n ’ a a c c e s qu ’ aux donnees p u b l i q u e s
NomClasse var ;

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

// pas d ’ a c c e s aux donnees p r i v e e s ou p r o t e g e e s

var . ip = 1 ; // e r r e u r de c o m p i l a t i o n
var . CheckProtected ( ) ; // e r r e u r de c o m p i l a t i o n

return 0 ;
}

9.2. Héritage
Trois 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 private
public public protected private
protected protected protected private
private interdit interdit interdit
Exemple
 page 23 Aide-mémoire C++ par Marc Duruflé

// c l a s s e mere
c l a s s Mother
{
// donnees p r i v e e s
private :
int i_private ;

// donnees p r o t e g e e s
protected :
int i_protected ;

// donnees p u b l i q u e s
public :
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 c

c l a s s Daughter : public Mother
{
void Test ( )
{
// on p e u t a c c e d e r a t o u s l e s membres de l a c l a s s e mere
i_protected = 0 ;

// s a u f l e s donnees p r i v e e s
i_private = 0 ; // e r r e u r de c o m p i l a t i o n
}
};

// pour un h e r i t a g e p r o t e g e
c l a s s Fille : protected Mother
{
};

c l a s s Father
{
public :
int j_public ;
};

// on p e u t f a i r e a u s s i un h e r i t a g e m u l t i p l e
c l a s s Fils : public Mother , public Father
{
};

9.3. Fonctions et classes amies

Exemple :
c l a s s Mother
{
private :
 page 24 Aide-mémoire C++ par Marc Duruflé

int ip ;
// f o n c t i o n amie
friend void affiche_ip ( const Mother &);

// c l a s s e amie
friend c l a s s Amie ;
};

// dans l a f o n c t i o n amie on p e u t a c c e d e r aux membres p r i v e e s de l a c l a s s e

void affiche_ip ( const Mother & var )
{
cout << "␣ i ␣=␣ " << var . ip << endl ;
}

// pour l e s c l a s s e s amies :
c l a s s Amie
{
public :
// l e s methodes ont a c c e s aux donnees p r i v e e s de Mother
void 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

c l a s s Base
{
protected :
int i ;
double x ;

// l e s c o n s t r u c t e u r s e t d e s t r u c t e u r s s o n t p u b l i c s
public :
// un c o n s t r u c t e u r n ’ a pas de t y p e de r e t o u r
// e t a l e meme nom que l a c l a s s e
Base ( )
{
// un c o n s t r u c t e u 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 s
i = 0;
x = 1.0;
 page 25 Aide-mémoire C++ par Marc Duruflé

// deuxieme c o n s t r u c t e u r
Base ( int j , double y )
{
i = j;
x = y;
}

// c o n s t r u c t e u r par c o p i e
Base ( const Base& var )
{
i = var . i ;
x = var . x ;
}

// un s e u l d e s t r u c t e u r p o s s i b l e
~Base ( )
{
// un d e s t r u c t e u 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 a u a d e t r u i r e
}

};

c l a s s Daughter : public Base

{
double y ;

public :
// on a p p e l l e l e c o n s t r u c t e u r de l a c l a s s e mere
// e t l e s c o n s t r u c t e u r s d e s a t t r i b u t s
Daughter ( 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 c o n v e r s i o n s i m p l i c i t e s , mot c l e e x p l i c i t
e x p l i c i t Daughter ( int j ) : Base ( )
{
y = 0.0;
}

// pas b e s o i n de d e c l a r e r l e d e s t r u c t e u r
// l e d e s t r u c t e u r par d e f a u t e s t i m p l i c i t e e t ne f a i t r i e n

};

int main ( )
{
 page 26 Aide-mémoire C++ par Marc Duruflé

// d e s qu ’ on d e c l a r e un o b j e t , un c o n s t r u c t e u r s e r a a p p e l e
// s i pas d ’ argument comme i c i , l e c o n s t r u c t e u r par d e f a u t Base ( ) e s t a p p e l e
Base b ;

// a p p e l du second c o n s t r u c t e u r de Base
Base a ( 4 , 5 . 0 ) ;

// a p p e l du c o n s t r u c t e u r par c o p i e ( 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 p e u t a u s s i a p p e l e r un c o n s t r u c t e u r a p r e s l a d e c l a r a t i o n
b = Base ( 6 , − 2 . 0 ) ;

Daughter z ; // e r r e u r a l a c o m p i l a t i o n
// c a r l e c o n s t r u c t e u r par d e f a u t n ’ a pas e t e d e f i n i

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

// l o r s de l ’ a c c o l a d e fermante , l e s d e s t r u c t e u r s s e r o n t a p p e l e s
return 0 ;
}
9.5. Pointeur this
C’est un pointeur vers l’objet instancié.
c l a s s Base ;

void affiche_objet ( const Base& v ) ;

c l a s s Base
{
public :
int ip ;

void ModifieIp ( int j )

{
ip = j ;

// s i on v e u t a p p e l e r une f o n c t i o n q u i prend en argument

// l ’ o b j e t courant , on u t i l i s e t h i s
affiche_objet ( ∗ t h i s ) ;
}

void SetIp ( int j )

{
ip = j ;
}

};

void affiche_objet ( const Base& v )

{
cout << " i ␣=␣ " << v . ip << endl ;
 page 27 Aide-mémoire C++ par Marc Duruflé

int main ( )
{
Base var ;

var . ModifieIp ( 4 ) ;
// i l a u r a i t e t e e q u i v a l e n t de f a i r e
// v a r . S e t I p ( 4 ) ; a f f i c h e _ o b j e t ( v a r ) ;

return 0 ;
}

9.6. Attributs et méthodes statiques

Les 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 sont
complètement équivalentes à des fonctions usuelles (extérieures à la classe) excepté qu’elles sont encapsulées
dans une classe.
c l a s s Exemple
{
public :
// a t t r i b u t s dynamiques
int ip ;
double x ;

// a t t r i b u t s s t a t i q u e s p r e c e d e s par l e mot c l e s t a t i c
s t a t i c int jp ;
s t a t i c double y ;

// methodes dynamiques
void SetIp ( int j )
{
ip = j ;
}

// methodes s t a t i q u e s p r e c e d e e s par l e mot c l e s t a t i c

s t a t i c void DisplayInfoClass ( )
{
cout << " C e t t e ␣ 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 r e u r de c o m p i l a t i o n
SetIp ( 3 ) ; // i n t e r d i t , e r r e u r de c o m p i l a t i o n

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

};

// d e c l a r a t i o n o b l i g a t o i r e d e s 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 e
int Exemple : : jp ( 3 ) ;
double Exemple : : y ( 2 . 0 3 ) ;
 page 28 Aide-mémoire C++ par Marc Duruflé

int main ( )
{
// pour m o d i f i e r un membre s t a t i q u e
Exemple : : jp = −10;
Exemple : : y = −0.45;

// pour a p p e l e r une f o n c t i o n s t a t i q u e
Exemple : : DisplayInfoClass ( ) ;

return 0 ;
}

9.7. Méthodes virtuelles, polymorphisme

Les 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.
c l a s s 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 e u r d o i t e t r e v i r t u e l
v i r t u a l ~Forme ( ) {}

// on p e u t d e f i n i r d e s f o n c t i o n s v i r t u e l l e s
// q u i s e r o n t s u r c h a r g e e s dans l e s c l a s s e s d e r i v e e s
v i r t u a l void Draw ( )
{
// ne f a i t r i e n , on s a i t pas comment d e s s i n e r une forme g e n e r a l e
cout << "Methode␣ i n d e f i n i e " << endl ;
}

// on p e u t d e c l a r e r d e s methodes v i r t u e l l e s p u r e s
// qu ’ on a pas b e s o i n de d e t a i l l e r , c a r on c o n s i d e r e
// qu ’ e l l e ne s e r o n t j a m a i s a p p e l e e s
v i r t u a l int GetNombrePoints ( ) = 0 ;

// dans une methode g e n e r i q u e , on p e u t u t i l i s e r l e s methodes v i r t u e l l e s

// q u i s o n t s p e c i a l i s e e s pour chaque forme
void AnalyseDessin ( )
{
// i c i l a f o n c t i o n Draw a p p e l e e n ’ e s t pas f o r c e m e n t l a f o n c t i o n Draw ( )
// d e f i n i e dans Forme , c e l a p e u t e t r e une f o n c t i o n d ’ une c l a s s e d e r i v e e
Draw ( ) ;

int n = GetNombrePoints ( ) ;
cout << " ␣Nombre␣ de ␣ p o i n t s ␣ de ␣ l a ␣ forme ␣=␣ " << n << endl ;
}

};

c l a s s Carre : public Forme

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

{
public :
// on s u r c h a r g e l e s f o n c t i o n s v i r t u e l l e s de Forme
int GetNombrePoints ( )
{
return 4 ;
}

void Draw ( )
{
cout << "−−−" << endl ;
cout << " | ␣ | " << endl ;
cout << "−−−" << endl ;
}

};

c l a s s Triangle : public Forme

{
public :
// on s u r c h a r g e l e s f o n c t i o n s v i r t u e l l e s de Forme
int GetNombrePoints ( )
{
return 3 ;
}

void Draw ( )
{
cout << " / | " << endl ;
cout << "−−" << endl ;
}

};

int main ( )
{
Forme b ; // e r r e u r de c o m p i l a t i o n c a r 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 = c o n t i e n t une methode v i r t u e l l e pure )

Carre quad ;

// l e s f o n c t i o n s Draw ( ) e t GetNombrePoints ( ) du Carre s e r o n t a p p e l e e s

quad . AnalyseDessin ( ) ;

Triangle tri ;

// l e s f o n c t i o n s Draw ( ) e t GetNombrePoints ( ) du T r i a n g l e s e r o n t a p p e l e e s
tri . AnalyseDessin ( ) ;

// on p e u t a u s s i c r e e r un o b j e t p o l y m o r p h i q u e
// ( q u i pourra e t r e un t r i a n g l e ou un c a r r e )
Forme ∗ forme ;
 page 30 Aide-mémoire C++ par Marc Duruflé

// i c i c ’ e s t un c a r r e
forme = new Carre ( ) ;

delete forme ;

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

9.8. Surcharge des opérateurs

// par exemple s i on v e u t p o u v o i r f a i r e d e s o p e r a t i o n s
// d i r e c t e m e n t s u r l e s v e c t e u r s
c l a s s Vector
{
protected :
// donnees
double∗ data ;
// t a i l l e v e c t e u r
int m ;

public :

// on s u r c h a r g e dans l a c l a s s e t o u s l e s o p e r a t e u r s i n t e r n e s

// o p e r a t e u r =
Vector& operator=(const Vector& v )
{
f o r ( int i = 0 ; i < m ; i++)
data [ i ] = v ( i ) ;

return ∗ t h i s ;
}

// o p e r a t e u r d ’ a c c e s ( )
double operator ( ) ( int i ) const ;

// i c i c ’ e s t l ’ o p e r a t e u r d ’ a c c e s q u i p e u t e t r e u t i l i s e pour V( i ) = c t e ;
double& operator ( ) ( int i ) ;

// l ’ o p e r a t e u r d ’ a c c e s ( ) p e u t e t r e s u r c h a r g e
// pour un nombre q u e l c o n q u e d ’ arguments (V( i , j ) = q u e l q u e c h o s e )
double& operator ( ) ( int i , int j ) ;

// o p e r a t e u r s += ∗= −=
Vector & operator +=(const Vector& v ) ;
Vector & operator ∗=(const Vector& v ) ;
Vector & operator −=(const Vector& v ) ;

// o p e r a t e u r de pre−i n c r e m e n t ++v
Vector & operator ++(void ) ;
 page 31 Aide-mémoire C++ par Marc Duruflé

// o p e r a t e u r de p o s t −i n c r e m e n t v++
Vector operator ++(int ) ;

// o p e r a t e u r s de comparaison
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 ;
bool operator >(const Vector&) const ;
};

// l e s operateurs externes sont d e f i n i s a l ’ e x t e r i e u r

Vector operator +(const Vector &, const Vector &);
Vector operator −(const Vector &, const Vector &);
Vector operator ∗ ( const Vector &, const Vector &);

// on p e u t g e r e r l e c a s m i x t e Vector / d o u b l e
Vector operator ∗ ( const double&, const Vector &);
Vector operator ∗ ( const Vector &, const double &);

// e n s u i t e dans l e main , on p e u t u t i l i s e r c e s s u r c h a r g e s
int 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 des
fichiers .cpp, .C, .cxx, .c++ ou .cc.

10.1. Prototype de fonctions, de classes

Un prototype ne contient que la déclaration de la classe ou de la fonction
// exemple de p r o t o t y p e d ’ une f o n c t i o n
// l a f o n c t i o n e s t d e f i n i e dans un a u t r e f i c h i e r
void MaFunction ( const double&, int , double ∗ ) ;

// p a r f o i s deux c l a s s e s s o n t e n 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 , a v a n t de l a d e t a i l l e r p l u s l o i n :
c l a s s MaClasse ;
 page 32 Aide-mémoire C++ par Marc Duruflé

// on p e u t a l o r s d e c l a r e r d e s p r o t o t y p e s de f o n c t i o n s
// a v e c MaClasse en argument
void FunctionClasse ( const MaClasse &);

// exemple de p r o t o t y p e d ’ une c l a s s e
c l a s s MaClasse
{
public :
int n ;
double x ;

// on ne met que l e s p r o t o t y p e s d e s f o n c t i o n s membres

void Fonc1 ( double ) ;
int Fonc2 ( int ) ;

};

// Pour d e f i n i r l e s f o n c t i o n 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éprocesseur

Les 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 i n c l u d e
// q u 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 <i o s t r e a m >

// l e f i c h i e r i o s t r e a m . h s e r a d i r e c t e m e n t i n s e r e dans l e f i c h i e r

// pour un f i c h i e r p e r s o n n e l , on met d e s g u i l l e m e n t s
#include " MonFichier . hxx"

// pour e v i t e r l e s m u l t i p l e s i n c l u s i o n s , l e s f i c h i e r s comportent
// t o u j o u r s d e s l i g n e s de ce t y p e :
#i f n d e f 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 u n i q u e parmi t o u s l e s f i c h i e r s i n c l u s
// l e f a i t de m e t t r e ce d e f i n e empeche une s e c o n d e i n c l u s i o n du meme f i c h i e r
// p u i s q u e FILE_MON_FICHIER_HEADER_HXX s e r a a l o r s d e f i n i

// on met i c i t o u t l e contenu du f i c h i e r
c l a s s Patati
{};
 page 33 Aide-mémoire C++ par Marc Duruflé

// e t on t e r m i n e par e n d i f
#endif

// l a n o t i o n de f l a g s e s t s o u v e n t u t i l i s e e , ce s o n t
// d e s i n d i c a t e u r s qu ’ on p e u t d e f i n i r l o r s de l a c o m p i l a t i o n
// ( o p t i o n −Dnom_flag )
// Par exemple s i on v e u t 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 B l a s e s t u t i l i s e e , on va c o m p i l e r :
// g++ −DUSE_BLAS t o 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 d i f f e r e m m e n t l e c a s
// ou on p e u t u t i l i s e r Blas , e t l e c a s ou on ne p e u t pas
#i f d e f USE_BLAS
// p a r t i e du code q u i ne s e r a 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 c o m p i l a t i o n s o i t par une d i r e c t i v e #d e f i n e )
// par exemple on u t i l i s e une r o u t i n e b l a s pour a d d i t i o n n e r deux v e c t e u r s
daxpy_ ( n , alpha , x , 1 , y , 1 ) ;

#e l s e

// dans ce c a s on a pas b l a s , on f a i t une somme s t a n d a r d

f o r ( 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 p e u t t e s t e r a u s s i que l e f l a g e s t non a c t i f
#i f n d e f USE_BLAS
// dans ce cas , on a pas B l a s

#endif

// l e s #d e f i n e p e r m e t t e n t a u s s i de d e f i n i r d e s 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 ) s t d : : c o u t << #x " : ␣ " << x << s t d : : e n d l

// on p e u t a l o r s u t i l i s e r DISP p a r t o u t , e t l e remplacement s e r a e f f e c t u e
// par l e p r e p r o c e s s e u r
DISP ( x ) ; // s e r a r e m p l a c e par s t d : : c o u t << " x : " << x << s t d : : e n d l ;
 page 34 Aide-mémoire C++ par Marc Duruflé

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.
// a v a n t d ’ e c r i r e t o u t e f o n c t i o n de l a l i b r a i r i e , on met l e mot c l e namespace
namespace NomLibrairie
{

int Fonc1 ( double y )

{
return int ( y ) ;
};

c l a s s MaClasse
{
public :
double x ;
};

} // f i n du namespace

// e n s u i t e s i on v e u t u t i l i s e r une f o n c t i o n du namespace ,
// s o i t on f a i t N o m L i b r a i r i e : :

void f ( )
{
NomLibrairie : : Fonc1 ( 2 . 0 ) ;
}

// s o i t on u t i l i s e l a commande u s i n g , e t on a pas b e s o i n de
// m e t t r e N o m L i b r a i r i e : :
using namespace NomLibrairie ;

int main ( )
{
Fonc1 ( 2 . 0 ) ;

return 0 ;
}

11. Entrées-sorties

Exemple :
// i o s t r e a m pour l e s e n t r e e s s o r t i e s s t a n d a r d
#include <i o s t r e a m >

// f s t r e a m pour l e s f i c h i e r s
#include <f s t r e a m >

using namespace std ;

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

int main ( )
{
// c o u t pour l e f l u x de s o r t i e a l ’ ecran
// c e r r pour l e f l u x d e s e r r e u r s
// e n d l e s t un r e t o u r c h a r i o t a v e c v i d a g e du b u f f e r
cout << "Coucou␣ " << endl ;

// c i n pour l e f l u x d ’ e n t r e e au c l a v i e r
int test_input ; double x ;
cout << " Entre z ␣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 d e f a u t , c o u t 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 p e u t en m e t t r e p l u s a v e c p r e c i s i o n
cout . 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 s
cout << "x␣=␣ " << x << endl ;

// pour e c r i r e dans un f i c h i e r : o f s t r e a m
ofstream file_out ( " s o r t i e . dat " ) ; // on e c r i t dans s o r t i e . d a t

// l a s y n t a x e e s t l a meme que pour c o u t

file_out << "x␣=␣ " << x << endl ;

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

// pour l i r e dans un f i c h i e r i f s t r e a m
ifstream file_in ( " e n t r e e . dat " ) ; // on l i t dans e n t r e e . d a t

// p r e m i e r e c h o s e 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 o u v e r t
i f ( ! file_in . is_open ( ) )
{
cout << " I m p o s s i b l e ␣ de ␣ l i r e ␣ l e ␣ f i c h i e r ␣ e n t r e e . dat " << endl ;
abort ( ) ; // a b o r t q u i t t e l e programme , p r a t i q u e pour d e b u g g u e r
}

// e n s u i t e on p e u t l i r e une donnee
file_in >> x ;

// on p e u t 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 marche
i f ( ! file_in . good ( ) )
{
// un e c h e c p e u t v e n 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 t e r m i n e
file_in . close ( ) ;

// on p e u t o u v r i r un a u t r e f i c h i e r a v e c l a methode open
 page 36 Aide-mémoire C++ par Marc Duruflé

file_in . open ( " a u t r e . dat " ) ;

file_in . close ( ) ;

// pour l i r e / e c r i r e en b i n a i r e on u t i l i s e w r i t e e t re ad
file_out . open ( " b i n a r y . dat " ) ;
// w r i t e demande d e s char , donc on c o n v e r t i t t o u t en char ∗
file_out . write ( reinterpret_cast<char∗>(&x ) , s i z e o f ( double ) ) ;
file_out . close ( ) ;

file_in . open ( " b i n a r y . dat " ) ;

// r ead demande d e s char , donc on c o n v e r t i t t o u t en char ∗
file_in . read ( reinterpret_cast<char∗>(&x ) , s i z e o f ( 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 v e u t e c r i r e une f o n c t i o n
// q u i marche a l a f o i s pour l e s c o m p l e x e s e t l e s r e e l s
// p l u t o t que de d u p l i q u e r l e code , on va e c r i r e
// une f o n c t i o n p r e n a n t en parametre un t y p e g e n e r i q u e ,
// par exemple pour l a norme d ’ un v e c t e u r :
template<c l a s s Vector>
double Norm ( const Vector& x )
{
double norm = 0 . 0 ;
f o r ( unsigned int i = 0 ; i < x . size ( ) ; i++)
norm += abs ( x [ i ] ) ;

return norm ;
}

// on p e u t a v o i r p l u s i e u r s t y p e s g e n e r i q u e s
template<c l a s s Matrix , c l a s s Vector1 , c l a s s Vector2>
void MltAdd ( const Matrix& A , const Vector1& x , Vector2& y )
{
// . . .
}

int main ( )
{
// l e s f o n c t i o n s s ’ u t i l i s e n t normalement
vector<double> x ;
cout << Norm ( x ) << endl ;

// pour l e s v e c t e u r s c o m p l e x e s
vector<complex<double> > xc ;
cout << Norm ( xc ) << endl ;
 page 37 Aide-mémoire C++ par Marc Duruflé

}
Exemple de classes génériques
// exemple d ’ une c l a s s e v e c t e u r
// T p e u t e t r e un i n t , d o u b l e , char , s t r i n g , e t c
template<c l a s s T>
c l a s s Vector
{
protected :
// donnees
T∗ data ;
int m ;

public :
int GetSize ( )
{
return m ;
}

};

// on p e u t m e t t r e p l u s i e u r s p a r a m e t r e s
template<c l a s s T , c l a s s Prop>
c l a s s Base
{
public :
// d e c l a r e r d e s f o n c t i o n s normales
void FoncNormale ( double , double ) ;

// e t d e s f o n c t i o n s t e m p l a t e
template<c l a s s Vector>
void FoncGeneric ( double , Vector &);
};

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

// pour l a f o n c t i o n t e m p l a t e , on a en p r e m i e r l e s p a r a m e t r e s
// t e m p l a t e de l a c l a s s e p u i s ceux de l a f o n c t i o n
template<c l a s s T , c l a s s Prop> template<c l a s s Vector>
void Base<T , Prop > : : FoncGeneric ( double x , Vector& y )
{
}

// on p e u t e n s u 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 r e m p l a c e r a completement l a c l a s s e
// g e n e r i q u e pour l e j e u de p a r a m e t r e s c h o i s i
template<c l a s s Prop>
c l a s s Base<int , Prop>
 page 38 Aide-mémoire C++ par Marc Duruflé

{
public :
};

// on p e u t 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 e
template<>
c l a s s Base<int , double>
{
};

int main ( )
{
// l o r s de l ’ i n s t a n c i a t i o n , i l f a u t p r e c i s e r l e t y p e d e s p a r a m e t r e s
Vector<int> v ;

// i c i l e c o m p i l a t e u r c h o i s i r a l a c l a s s e Base g e n e r i q u e
Base<string , int> A ;

// i c i l e c o m p i l a t e u r 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 e m e n t
Base<int , string> B ;

// i c i l e c o m p i l a t e u r 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 t o t a l e m e n t
Base<int , double> C ;
}
Les paramètres template peuvent être introduits par le mot-clé typename (au lieu de class), et on peut
aussi utiliser des constantes dont on connaitra la valeur à la compilation.
// i c i m d e s i g n e l a t a i l l e du v e c t e u r
// m e s t connu a l a c o m p i l a t i o n , ce q u i permet de p o u v o i r e c r i r e
// d e s a l g o s o p t i m i s e s ( meta−programing )
template<typename T , int m>
c l a s s TinyVector
{
// comme m e s t connu a l a c o m p i l a t i o n , on p e u t
// u t i l i s e r d e s t a b l e a u x s t a t i q u e s
T data [ m ] ;

public :
T operator ( ) ( int i )
{
return data [ i ] ;
}
};

int main ( )
{
// dans l e main , on d o i t p r e c i s e r l a t a i l l e
TinyVector<double , 3> y ;

}
 page 39 Aide-mémoire C++ par Marc Duruflé

13. Exceptions en C++

Exemple
#include <i o s t r e a m >
#include <e x c e p t i o n >

using namespace std ;

// pour chaque n o u v e l l e e x c e p t i o n , on f a i t une c l a s s e :

c l a s s MonException
{
public :
string comment ; // commentaire a s s o c i e a l ’ e x c e p t i o n

// c o n s t r u c t e u r p r e n a n t un commentaire en argument
MonException ( const string& c ) : comment ( c ) {}

};

int main ( )
{
try
{
// on met i c i l e code qu ’ on v e u t e x e c u t e r
// s i a un moment on a une e r r e u r , on p e u t l a n c e r une e x c e p t i o n
MonException a ( ‘ ‘ Argument invalide ’ ’ ) ;
throw a ;

// une e x c e p t i o n p e u t e t r e de n ’ i m p o r t e q u e l t y p e
// par exemple un e n t i e r
int b = 3 ;
throw b ;
}
catch ( MonException& err )
{
// c a s ou une e x c e p t i o n de t y p e MonException a e t e l a n c e e
// on f a i t l e t r a i t e m e n t a s s o c i e e a c e t t e e x c p e t i o n
}
catch ( int a )
{
// c a s ou une e x c e p t i o n de t y p e e n t i e r a e t e l a n c e e
}
catch ( . . . )
{
// t o u t e s l e s a u t r e s e x c e p t i o n s
// on p e u t a p p e l e r a b o r t par exemple s i on ne s a i t pas g e r e r
// ce c a s l a
abort ( ) ;
}

return 0 ;
}
 page 40 Aide-mémoire C++ par Marc Duruflé

14. Utilisation de la STL

14.1. Fonctions mathématiques

Les fonctions mathématiques sont contenues dans cmath.
Exemple
#include <cmath>

using namespace std ;

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

// s q r t : r a c i n e c a r r e e
// exp : e x p o n e n t i e l l e
// l o g : l o g a r i t h m e n e p e r i e n
// l o g 1 0 : l o g a r i t h m e en b a s e 10
// l o g 2 : l o g a r i t h m e en b a s e 2
// s i n , cos , tan : f o n c t i o n s t r i g o s u s u e l l e s
// a s i n , acos , atan : l e s a r c cos , s i n e t tan
// s i n h , cosh , tanh , a s in h , acos , atanh : l e s cos , s i n , e t c h y p e r b o l i q u e s
// tgamma : f o n c t i o n gamma
z = asin ( x ) ;

// a r r o n d i au p l u s p r o c h e
// i c i on c o n v e r t i t en e n t i e r p a r c e que round r e n v o i e un r e e l
int n = int ( round ( z ) ) ;

// a r r o n d i i n f e r i e u r
n = int ( floor ( z ) ) ;

// a r r o n d i s u p e r i e u r
n = int ( ceil ( z ) ) ;

// d ’ a u t r e s f o n c t i o n s e x i s t e n t
}

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

Exemple
#include<s t r i n g >
#include<i o s t r e a m >
#include<sstream >

using namespace std ;

// pour c o n v e r t i r un nombre en s t r i n g
template<typename T>
i n l i n e std : : string to_str ( const T& input )
 page 41 Aide-mémoire C++ par Marc Duruflé

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

// pour c o n v e r t i r un s t r i n g en nombre
template <c l a s s T>
i n l i n e T to_num ( std : : string s )
{
T num ;
std : : istringstream str ( s ) ;
str >> num ;
return num ;
}

int main ( )
{
// pour m a n i p u l e r l e s c h a i n e s de c a r a c t e r e s , ne pas u t i l i s e r c har ∗ (C)
// mais p l u t o t d e s s t r i n g
string s ( " t o t o " ) ;

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

// pour a c c e d e r a chaque c a r a c t e r e , o p e r a t e u r [ ]
s [ 1 ] = ’ y ’ ; // s v a u t maintenant t y t o

// on p e u t comparer d e s s t r i n g
i f ( s == " t a t a " )
cout << " i n c o r r e c t " << endl ;

// on p e u t c o n c a t e n e r a v e c l ’ o p e r a t e u r +
s = s + " . dat " ; // s v a u t maintenant t y t o . d a t

// on p e u t r e c h e r c h e r une c h a i n e
int pos = s . find ( " t o " ) ; // pos d e v r a i t v a l o i r 2
i f ( pos == string : : npos )
cout << "on␣n␣ a ␣ pas ␣ t r o u v e ␣ l a ␣ c h a i n e ␣ t o ␣ dans ␣ s " << endl ;

// on p e u t e x t r a i r e une sous−c h a i n e
string s_sub = s . substr ( pos , 3 ) ;
// pour e x t r a i r e 3 c a r a c 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 t o u s l e s c a r a c t e r e s a p a r t i r de s [ pos ]

// par exemple pour c o n v e r t i r i = 356 en s t r i n g

int i = 3 5 6 ;
s = to_str ( i ) ;
 page 42 Aide-mémoire C++ par Marc Duruflé

// e t pour c o n v e r t i r " 3 . 1 4 5 6 " en d o u b l e

s = string ( " 3 . 1 4 5 6 " ) ;
double x = to_num<double>(s ) ;
}

14.3. Vecteurs

#include<v e c t o r >

using namespace std ;

int main ( )
{
// l a c l a s s e v e c t o r s t o c k e l e s e l e m e n t s de maniere c o n t i g u e
// a c c e s r a p i d e , mais i n s e r t i o n l e n t e
vector<double> x ( 5 ) ; // v e c t e u r de 5 r e e l s

// a c c e s a v e c [ ]
x [ 0 ] = 1 . 0 6 e −7;
x [ 1 ] = −3.5 e8 ;

// on p e u t a g r a n d i r l e v e c t e u r en g a r d a n t l e s a n c i e n s e l e m e n t s
x . resize ( 6 ) ;

// l e s nouveaux e l e m e n t s d o i v e n t e t r e i n i t i a l i s e s
x [5] = 2.5;

// on p e u t a u s s i r a j o u t e r un e l e m e n t a l a f i n du v e c t e u r
// ( i e l e v e c t e u r e s t r e t a i l l e e t un e l e m e n t e s t r a j o u t e )
x . push_back ( 3 . 4 ) ; // e q u i v a l e n t a x . r e s i z e ( 7 ) ; x [ 6 ] = 3 . 4 ;

// on p e u t a u s s i i n s e r e r un e l e m e n t a v e c i n s e r t , e t d e t r u i r e l e v e c t e u r a v e c c l e a r
x . clear ( ) ;
}
14.4. Listes

#include<l i s t >
#include <i o s t r e a m >

using namespace std ;

int main ( )
{
// une l i s t e ne s t o c k e pas l e s e l e m e n t s de maniere c o n t i g u e
// ( p e n s e z a une l i s t e simplement c h a i n e e )
// l ’ i n s e r t i o n e s t r a p i d e , mais l ’ a c c e s e s t l e n t
list<double> v ;

// push_back e t i n s e r t e x i s t e n t
v . push_back ( 3 . 4 ) ;
v . push_back ( 0 . 3 ) ;
 page 43 Aide-mémoire C++ par Marc Duruflé

// pour p a r c o u r 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 r
list<double > : : iterator it ;
cout << ‘ ‘ v = ‘ ‘ ;
f o r ( it = v . begin ( ) ; it != v . end ( ) ; ++it )
cout << ‘ ‘ ‘ ‘ << ∗it ;

cout << endl ;

}
14.5. Piles

#include<s t a c k >

using namespace std ;

int main ( )
{
// s t a c k e s t un c o n t e n e u r c o r r e s p o n d a n t a une p i l e
// ( p r e m i e r e n t r e , p r e m i e r s o r t i )
stack<double> pile ;

// on e m p i l e l e s e l e m e n t s a v e c push
pile . push ( 0 . 3 3 ) ;
pile . push ( − 0 . 2 5 ) ;
pile . push ( 1 . 3 ) ; // l a p i l e v a u t ( 1 . 3 , −0.25 , 0 . 3 3 )

// on l i b e r e un e l e m e n t a v e c pop
pile . pop ( ) ; // l a p i l e v a u t ( −0.25 , 0 . 3 3 )

// pour a c c e d e r au d e r n i e r e l e m e n t t o p
double y = pile . top ( ) ; // y = −0.25 e t l a p i l e v a u t ( −0.25 , 0 . 3 3 )
}