Vous êtes sur la page 1sur 43

Aide-mmoire C++

Matmeca 2014
Marc Durufl

page 3

Aide-mmoire C++ par Marc Durufl

Table des matires


1 Commentaires

2 Types prdfinis
2.1 Types de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Qualificatifs additionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5
5
6

3 Pointeurs et rfrences

4 Tableaux en C
4.1 Tableau statique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2 Tableau dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3 Tableau plusieurs entres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

8
8
8
9

5 Structures, numrations

6 Fonctions
6.1 Surcharge de fonctions . . . . . . .
6.2 Passage par rfrence . . . . . . . .
6.3 Passage par pointeur . . . . . . . .
6.4 Pointeurs et rfrences de fonctions
6.5 La fonction main . . . . . . . . . .

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

7 Variables
8 Structures de contrle
8.1 Oprateurs . . . . . . . . . . .
8.2 Structure conditionnelle if . . .
8.3 Structure conditionnelle switch
8.4 Boucle for . . . . . . . . . . . .
8.5 Boucle while . . . . . . . . . .
8.6 Instructions break continue . .

10
10
12
13
14
15
15

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

17
17
19
19
20
20
21

9 C++ : la couche objet


9.1 Encapsulation des donnes . . . . . .
9.2 Hritage . . . . . . . . . . . . . . . .
9.3 Fonctions et classes amies . . . . . .
9.4 Constructeur, destructeur . . . . . .
9.5 Pointeur this . . . . . . . . . . . . .
9.6 Attributs et mthodes statiques . . .
9.7 Mthodes virtuelles, polymorphisme
9.8 Surcharge des oprateurs . . . . . . .

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

21
21
22
23
24
26
27
28
30

10 Structure dun code


10.1 Prototype de fonctions, de classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.2 Directives du prprocesseur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.3 Espace de nommages (namespace) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

31
31
32
34

11 Entres-sorties

34

12 Fonctions et classes gnriques

36

13 Exceptions en C++

39

.
.
.
.
.
.

.
.
.
.
.
.

page 4
14 Utilisation de la STL
14.1 Fonctions mathmatiques . .
14.2 Chanes de caractres (string)
14.3 Vecteurs . . . . . . . . . . . .
14.4 Listes . . . . . . . . . . . . .
14.5 Piles . . . . . . . . . . . . . .

Aide-mmoire C++ par Marc Durufl

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

40
40
40
42
42
43

page 5

Aide-mmoire 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 prdfinis
Type
void
bool
int
char
float
double
unsigned int
short
long
int64_t

Description
type vide
boolen
entier (sur 4 octets)
caractre (1 octet)
rel simple prcision (4 octets)
rel double prcision (8 octets)
entier positif
entier court
entier long
entier long (sur 8 octets)

2.1. Types de base


void
Type vide, utilis le plus souvent pour signaler quune 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

Caractre (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-mmoire 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

Rel simple prcision (cod sur 4 octets).

Ce type reprsente des nombres rels entre 1e-38 et 1e38 avec une prcision 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
Rel double prcision (cod sur 8 octets).
Ce type reprsente des nombres rels entre 1e-308 et 1e308 avec une prcision 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 dclarer une variable de plus faible prcision

page 7

Aide-mmoire 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 dclarer une variable de plus grande prcision

// 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 dclarer des entiers non-signs (positifs) ou signs

// 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 rfrences
Un pointeur est une variable contenant ladresse dune autre variable. Le contenu du pointeur q est alors
accd par q et ladresse dune variable x est accde 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 aud 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-mmoire 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
Cest 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
Cest un tableau dont on fixe la taille lors de lexecution
// 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-mmoire C++ par Marc Durufl

4.3. Tableau plusieurs entres


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 ny a pas dquivalent natif aux tableaux dynamiques multidimensionnels comme il existe en
Fortran90. Toutefois il est possible de construire des vecteurs de vecteurs, avec le dsavantage que ce type
de structure ne stockera pas les lments de manire contige. 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, numrations
Une structure contient plusieurs champs, cest lquivalent des types composs Fortran.
struct NomStructure
{
// nombre d e s i n v i t e s
int nombre_invites ;

page 10

Aide-mmoire 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 numration permet de dfinir des constantes entires 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 dfinie par ses arguments et son type de retour. On peut surcharger une fonction, cest
dire avoir deux fonctions portant le mme nom mais dont les arguments diffrent. Le mot cl return
renvoie la valeur de retour de la fonction et quitte la fonction.

page 11

Aide-mmoire 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 / ( xy ) = " << 1 . 0 / ( xy ) << 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 xyz ;
}
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-mmoire C++ par Marc Durufl

}
6.2. Passage par rfrence
Par dfaut, les arguments dune fonction sont passs par valeurs et ne sont donc pas modifis. 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 rfrences, afin de passer ladresse des arguments. Ainsi on
vite la copie locale des arguments, qui peut etre coteuse 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 motc 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-mmoire 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 mthode moins lgante est de passer les adresses des arguments. Cest une technique surtout
employe 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-mmoire C++ par Marc Durufl

delete [ ] vec ;
return 0 ;
}
6.4. Pointeurs et rfrences de fonctions
Grace ces fonctionnalits on peut construire des tableaux de fonctions ou passer une fonction en
paramtre.
// 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 = ( ba ) / N ;
f o r ( int i = 0 ; i < N ; i++)
{
double x = ( double ( i ) + 0 . 5 ) h + a ;
sum += hf ( 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 xx + 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-mmoire 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 appele lors de lexcution, il ne doit donc y avoir quune seule fonction
main lorsquon ralise ldition 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 rcuprer 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 dclares nimporte quel endroit du programme (on dit quelles sont dclares
la vole). La variable est dtruite lors de la fermeture de laccolade. Les variables globales sont dclares
lextrieur 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-mmoire 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-mmoire C++ par Marc Durufl

8. Structures de contrle
8.1. Oprateurs
()
oprateur daccs
[]
oprateur daccs
.
membre dun objet ou structure
->
raccourci pour (*pointeur).
!
oprateur non

non bit bit


++ incrmentation (i + + est quivalent i = i + 1)
dcrmentation (i est quivalent i = i 1)

cible dun pointeur ou multiplication


&
rfrence
/
division

oppos dun nombre ou soustraction


+
addition de deux nombres
%
modulo (a%b quivaut mod(a, b) en Fortran)
<< flux de sortie ou dcalage de bit
>> flux dentre ou dcalage de bit
<
signe strictement infrieur
>
signe strictement suprieur
<= signe infrieur ou gal
>= signe suprieur ou gal
== signe gal (pour la comparaison)
! = signe diffrent
&
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 = ab
& = a& = b quivaut a = a&b
| = a| = b quivaut a = a|b
On notera quil ny a pas doprateur puissance (comme ** en Fortran), il faut utiliser la fonction pow
(dans le package cmath). Voici un exemple dutilisation de ces oprateurs.
// 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-mmoire 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-mmoire 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 caractres). Cest lequivalent 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-mmoire 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 oud" << 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 ; itration) opration ;
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-mmoire 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 donnes
On peut ici utiliser le mot-cl struct, par dfaut les membres dune struct sont publiques, alors que les
membres dune class sont prives par dfaut.
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-mmoire 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. Hritage
Trois types dhritage (public, private, protected), voici comment les types de donnes des attributs de
la classe mre sont transforms aprs hritage :
Donnes
public
protected
private
Exemple

hritage public
public
protected
interdit

hritage protected
protected
protected
interdit

hritage private
private
private
interdit

page 23

Aide-mmoire 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-mmoire 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-mmoire 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-mmoire 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
Cest un pointeur vers lobjet 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-mmoire 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 mthodes statiques
Les attributs statiques sont partags par toutes les instances dune classe. Les mthodes statiques ne
doivent pas modifier dattribut dynamique, ni appeler des mthodes dynamiques. Les mthodes statiques sont
compltement quivalentes des fonctions usuelles (extrieures la classe) except quelles sont encapsules
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-mmoire 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. Mthodes virtuelles, polymorphisme
Les mthodes virtuelles permettent de factoriser du code en crivant des fonctions gnrales dans la
classe mre, qui appelle des mthodes dfinies 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-mmoire 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-mmoire 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 oprateurs
// 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 prei n c r e m e n t ++v
Vector & operator ++(void ) ;

page 31

Aide-mmoire 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
bool operator
bool operator
bool operator
bool operator
bool operator
bool operator

de comparaison
==(const Vector&) const ;
!=( const Vector&) const ;
<=(const Vector&) const ;
>=(const Vector&) const ;
<(const Vector&) const ;
>(const Vector&) const ;

};
// l e s
Vector
Vector
Vector

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


operator +(const Vector &, const Vector &);
operator (const Vector &, const 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 dun code
En dispose les dclarations des fonctions et classes (appeles prototypes) dans des fichiers den-tte
(headers) dont lextension se termine par .hpp, .H, .h++ ou .hxx. Les dfinitions sont elles places dans des
fichiers .cpp, .C, .cxx, .c++ ou .cc.
10.1. Prototype de fonctions, de classes
Un prototype ne contient que la dclaration 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-mmoire 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 prprocesseur
Les directives du prprocesseur 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-mmoire 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-mmoire C++ par Marc Durufl

10.3. Espace de nommages (namespace)


Lorsquon crit une librairie, toutes les fonctions et classes de la librairie sont encapsules dans un espace
de nommage. Lespace 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. Entres-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-mmoire 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 dun 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-mmoire 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 gnriques


Exemple de fonctions gnriques :
// 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-mmoire C++ par Marc Durufl

}
Exemple de classes gnriques
// 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-mmoire 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 paramtres 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 ( metaprograming )
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-mmoire 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-mmoire C++ par Marc Durufl

14. Utilisation de la STL


14.1. Fonctions mathmatiques
Les fonctions mathmatiques 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. Chanes de caractres (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-mmoire 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 << "onn 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 sousc 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-mmoire 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-mmoire 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 )
}