Aide Memoire C++

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 . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
40
40
40
42
42
43
page 5
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
// \ 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
// 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
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
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
// 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
// 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
}
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
{
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
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
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
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
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
// 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
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;
}
e l s e i f ( i == 5 )
{
x = 0.52;
}
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
// 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
// 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
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 ( )
{
}
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 ( )
{
}
// 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
// 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
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
}
// 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
// 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
}
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
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
{
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 ;
}
};
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 ;
}
};
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
// 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
// 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
// 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
// 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
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
// 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 >
page 35
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
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_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 ) ) ;
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
}
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
{
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
13. Exceptions en C++

Exemple
#include <e x c e p t i o n >
// 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
14. Utilisation de la STL

14.1. Fonctions mathmatiques
Les fonctions mathmatiques sont contenues dans cmath.
Exemple
#include <cmath>
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 >
// 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
{
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
// 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 >
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 >
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
// 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 >
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 )
}

Aide Memoire C++

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Aide Memoire C++

Cargado por

Copyright:

Formatos disponibles

Aide-mmoire C++

Aide-mmoire C++ par Marc Durufl

Table des matires

9 C++ : la couche objet

10 Structure dun code

12 Fonctions et classes gnriques

Aide-mmoire C++ par Marc Durufl

Aide-mmoire C++ par Marc Durufl

2.1. Types de base

Booleen (true or false)

bool test = true ;

Caractre (cod sur un octet)

Aide-mmoire C++ par Marc Durufl

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

Rel simple prcision (cod sur 4 octets).

Entier (cod sur 8 octets)

2.2. Qualificatifs additionnels

Pour dclarer une variable de plus faible prcision

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

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

Pour dclarer des entiers non-signs (positifs) ou signs

Aide-mmoire C++ par Marc Durufl

Aide-mmoire C++ par Marc Durufl

4.3. Tableau plusieurs entres

Aide-mmoire C++ par Marc Durufl

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

Aide-mmoire C++ par Marc Durufl

Aide-mmoire C++ par Marc Durufl

Aide-mmoire C++ par Marc Durufl

Aide-mmoire C++ par Marc Durufl

Aide-mmoire C++ par Marc Durufl

Aide-mmoire C++ par Marc Durufl

non bit bit

cible dun pointeur ou multiplication

oppos dun nombre ou soustraction

ou exclusif bit bit

Aide-mmoire C++ par Marc Durufl

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)

Aide-mmoire C++ par Marc Durufl

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

9. C++ : la couche objet

Aide-mmoire C++ par Marc Durufl

Aide-mmoire C++ par Marc Durufl

Aide-mmoire C++ par Marc Durufl

Aide-mmoire C++ par Marc Durufl

Aide-mmoire C++ par Marc Durufl

Aide-mmoire C++ par Marc Durufl

Aide-mmoire C++ par Marc Durufl

// 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

Aide-mmoire C++ par Marc Durufl

Aide-mmoire C++ par Marc Durufl

Aide-mmoire C++ par Marc Durufl

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

Aide-mmoire C++ par Marc Durufl

Aide-mmoire C++ par Marc Durufl

Aide-mmoire C++ par Marc Durufl

10.3. Espace de nommages (namespace)

Aide-mmoire C++ par Marc Durufl