Está en la página 1de 48

Aide-mmoire C++

Marc Duru 4 septembre 2012

Table des matires


1 2 Commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Types prdnis 2.1 2.2 3 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Types de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Qualicatifs additionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 4 4 6 7 8 8 8 8 10 10 11 12 14 15 15 17 17 19 20 20 21 21 22 22 23 25 26 28 29 30 32 34 34 35 37 37 39 Pointeurs et rfrences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tableaux en C 4.1 4.2 5 6 Tableau statique

Tableau dynamique

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

7 8

Variables 8.1 8.2 8.3 8.4 8.5 8.6

Structures de contrle Oprateurs

Structure conditionnelle if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Structure conditionnelle switch . . . . . . . . . . . . . . . . . . . . . . . . . . Boucle for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Boucle while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Instructions break continue Encapsulation des donnes

C++ : la couche objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.1 9.2 9.3 9.4 9.5 9.6 9.7 9.8 Hritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fonctions et classes amies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Constructeur, destructeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Pointeur this . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Attributs et mthodes statiques . . . . . . . . . . . . . . . . . . . . . . . . . . Mthodes virtuelles, polymorphisme Surcharge des oprateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

10

Structure d'un code 10.1 10.2 10.3

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Prototype de fonctions, de classe . . . . . . . . . . . . . . . . . . . . . . . . . Directives du prprocesseur . . . . . . . . . . . . . . . . . . . . . . . . . . . . Espace de nommages (namespace) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

11 12

Entres-sorties

Fonctions et classes gnriques

Table des matires


13 14 Exceptions en C++ 14.1 14.2 14.3 14.4 14.5

page 4

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

42 44 44 45 46 47 47

Utilisation de la STL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fonctions mathmatiques Chanes de caractres (string) . . . . . . . . . . . . . . . . . . . . . . . . . . . Vecteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Piles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 Commentaires
/

Ceci est un commentaires (C et sur C++) plusieurs lignes

/
une ligne (C ++ u n i q u e m e n t )

//

Ceci

est

un

commentaire

sur

double x

3.0;

//

qui

peut

etre

dispose

la

suite

d ' une

instruction

2 Types prdnis
Type void bool int char oat 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 qu'une fonction ne retourne rien.

void affiche_reel ( double x )


{ }

exemple

de

function

qui

ne

renvoie

rien

cout

< <

``

`` < <

< <

endl ;

page 5

Aide-mmoire C++ par Marc Duru

bool bool test


//

Booleen (true or false)

true ;
les utiliser directement dans les conditions

if

on

cout

( test )

peut

< <

` ` Test

est vrai

`` < <

endl ;

char
// la

Caractre (cod sur un octet)

char lettre
// // la la

casse

est

importante ,

et

sont

des

caracteres

differents

'A ' ;
c a r a c t e r e < > nombre exemple '0 ' = 48

correspondance table ascii ,

est

assuree

par

char zero
// // il \t y

'0 ' ,

zero_bis
\n

par

= 48;
speciaux chariot ) , etc

aussi

des

caracteres ( retour

lettre

( tabulation ) ,

' \n ' ;

int
// // pas

Entier (cod sur 4 octets)

d ' overflow 147 483 647

( depassement ) et 2 147 483

si

est

compris

entre

2 int n
par on en

647

= 345;
defaut peut un entier un par ( ici 345) en est ecrit en base decimale

// //

entrer

literal 0x en

base

hexadecimale

n n

//

= 0 xA34E ;
pour les

commencant //

n = A34E

hexadecimal

//

entiers

en

base

8,

on

commence

par

= 023472;

oat

Rel simple prcision (cod sur 4 octets).

Ce type reprsente des nombres rels entre 1e-38 et 1e38 avec une prcision de 1e-7.
//

float x

pour

= 1.23 f ;

declarer

un

literal

simple

precision ,

ajouter

Table des matires

page 6

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.

double x

//

pour

declarer

un

= 1.23 ,

literal

5.04 e10 ;

double

precision

int64_t
// a inclure

Entier (cod sur 8 octets)

#include <s t d i n t . h>

pour

avoir

le

type

int64_t

using namespace std ;


// // pas d ' overflow et 9 e18 ( depassement ) si n est compris entre

9e 1 8 int64_t n

= 345;

2.2 Qualicatifs additionnels

short
// // il n 'y

Pour dclarer une variable de plus faible prcision

pas 2

de

regle , (

mais 768

par a

exemple 32 767)

short

int

est

en

general

short int n

stocke

sur

octets

32

= 1045;

long
// // // il n 'y

Pour dclarer une variable de plus grande prcision

pas 10 la

de

regle ,

mais

par

exemple

long

double

est

en

general

stocke mettre

sur L a

octets fin des

( double

precision

etendue )

long double x

= 0.1234 L ;

literaux

signed / unsigned unsigned int i


// Par defaut les

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

entiers

sont

signes ,

pour

declarer

un

entier

positif :

= 23;

page 7

Aide-mmoire C++ par Marc Duru


est alors que i peut aller de 0 a 4 milliards

//

l ' avantage

unsigned char c

//

les

caracteres

non

signes

existent

aussi

( allant

de

256)

= 23;

3 Pointeurs et rfrences
Un pointeur est une variable contenant l'adresse d'une autre variable. Le contenu du pointeur q est alors accd par

; ;

q et l'adresse d'une variable x est accde par & x :


// // x y vaut vaut un ici 1.0 2.0 pointeur que q ne la sur un double vers x rien

double x = double y = double q ;

1.0 2.0
// on

q = NULL ; // q = &x ; // q q = 3 . 0 ; // q = &y ; // q q = 4 . 0 ;


// y

on

declare specifie

pointe

pointe x vaut

maintenant 3.0 maintenant

vers

variable

pointe

vers

la

variable

=
x

q ;

vaut

maintenant

4.0

//

vaut

maintenant

4.0

// //

on

peut

allouer ni x,

un ni

nouvel y)

emplacement

memoire

pour

q = new double ; q = 2 . 0 ; // x e t q
= &x ;
car on a // on ici perd

( qui

sera

sont

inchanges

c ' est

tres

dangereux reservee une au

// //

l ' adresse ce q u ' on

d e s s u s
de memoire

alors

appelle

fuite

q x

//

on

= =

new double [ 3 ] ;
q[1];
acceder aux

peut

aussi

allouer // 3

plusieurs cases cases ici avec

cases

( pas

une

seule )

//

et

autres

[]

//

delete [ ] q ;
les pour

pour

liberer

la

memoire ,

delete []

// //

references definir

peuvent

aussi ( sans

etre avoir

utilisees a ecrire de

double& alias_x
// tout

des

x;

alias

changement

sur

alias_x

se

repercutera

sur

et

vice

versa

Table des matires

page 8

alias_x

1.0;

//

et

alias_x

valent

4 Tableaux en C
4.1 Tableau statique
C'est un tableau dont on connait la taille lors de la compilation.
// // par par exemple defaut un les tableau valeurs de de 4 y reels ne : pas initialisees

double y [ 4 ] ;
// // on les

sont

utilise indices

l ' operateur

[] a 0

pour

acceder

aux

elements

du

tableau

y[0]
//

3.03;
peut

y[1]

commencent

2 e10 ; y [ 2 ]
tout le

= 5 . 5 4 e3 ;
tableau

y[3]
les

= 2 . 0 2 e 5;
{ } :

int n [ 4 ]

on

initialiser

avec

= { 31 ,

43 ,

3,

10};

4.2 Tableau dynamique


C'est un tableau dont on connait la taille lors de l'execution
// par exemple on demande la taille du tableau

cout << ` ` Entrez n cin >> n ;


// on alloue le

int n ;

`` < <

endl ;

double x ; // x p o i n t e u r x = new double [ n ] ;


// // on les utilise indices

tableau

avec vers

l ' operateur la premiere

new case du tableau

l ' operateur

[] a 0

pour

acceder

aux

elements

du

tableau

x[0]
//

3.03;

x[1]

commencent

2 e10 ; x [ 2 ]
avec

= 5 . 5 4 e3 ;

x[6]

= 2 . 0 2 e 5;

delete [ ] x ;

on

desalloue

le

tableau

l ' operateur

delete []

5 Structures, numrations
Une structure contient plusieurs champs, c'est l'quivalent des types composs Fortran.

page 9

Aide-mmoire C++ par Marc Duru

struct NomStructure
{
//

int nombre_invites ;
tableau

nombre

des

invites

double taille_invites ; char nom ;


};
// on declare une // nom de l ' evenement

//

contenant

la

taille

des

invites

NomStructure repas ;
pour modifier

variable

de

type

NomStructure

//

repas . nombre_invites
on peut aussi de

les

membres

de

la

structure ,

operateur

= 10;
a la volee une structure

// //

declarer nom :

struct { double x , y ; } var ;


et modifier

sans

donner

var . x
// on

//

3.0;

var . y
{

les

membres

de

la

variable

2.0;
le mot cle

typedef struct
//

peut

aussi

int i ; double x ;
la variable de

utiliser

NomStruct ;
NomStruct

typedef

NomStruct x ;

puis

declarer

type

Une numration permet de dnir des constantes entires dans un programme et de les nommer, ce qui rend le code plus lisible.
// // par exemple sait on enumere avec toutes le les : conditions aux limites

enum{ DIRICHLET , NEUMANN , IMPEDANCE } ;


//

q u ' on

traiter

code

int condition
ensuite , if

ces

constantes

NEUMANN ;
de

sont

des

entiers ,

q u ' on

peut

utiliser

// //

au

lieu

faire on

un

test le nom

if

( condition == {
// on fait le

( condition

== 1 ) ,

DIRICHLET )

met

traitement

de

la

condition

de

Dirichlet

Table des matires


}

page 10

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

6.1 Surcharge de fonctions


Une fonction est dnie par ses arguments et son type de retour. On peut surcharger une fonction, c'est dire avoir deux fonctions portant le mme nom mais dont les arguments dirent. Le mot cl return renvoie la valeur de retour de la fonction et quitte la fonction.

double Add ( double x , double y )


{ }
// on peut surcharger cette

//

exemple

trivial

d ' une

fonction

renvoyant

x+y

return x

y;

int Add ( int x , int y ) return x


+

fonction

pour

des

arguments

differents

{ }

y;

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


{ }
// on definit une procedure en mettant void comme type de retour

return x

z;

void test_procedure ( double x , double y )


{
//

if

return ;
on ne

( x ==

return

y)

peut

servir

ici

pour

quitter

la

procedure

//

cout

< <

` ` 1 / ( xy ) =

continue

que

lorsque

' ' < <

1 . 0 / ( xy ) < <

est

different

endl ;

de

}
// // // on on peut leur specifier donne pas une des arguments par optionnels ici z a la fin un des arguments optionnel

valeur il

defaut , 1.0

est

argument

s ' il

n ' est

rempli ,

vaut

page 11

Aide-mmoire C++ par Marc Duru


= 1.0)

double Mlt ( double x , double y , double z


{ }

return x y z ;

int main ( )
{

double x double y

//

pour

appeler

= =

Add ( 1 . 3 , 1 . 4 ) ; Add ( x , 0 . 4 5 , 1 . 2 3 ) ;

une

fonction ,

on

ecrit

son

nom

avec

les

arguments

test_procedure ( x , y ) ;

double z
// ou la //

//

on

peut

Mlt ( x , y ,
deux par

appeler

Mlt

avec

trois

arguments

2.3);
le dernier ici ) prenant

avec

arguments , defaut

z
}

Mlt ( x , y ) ;
0;

valeur

(1.0

return

6.2 Passage par rfrence


Par dfaut, les arguments d'une fonction sont passs par valeurs et ne sont donc pas modis. Une copie locale de ces arguments est faite.

double Add ( double x , double y )


{
// on la peut modifier de x et les y // valeur ne

//

exemple

de

fonction

avec

des

arguments

usuels

copies sera

locales pas

de

et en

y sortie de fonction

x y
}

+= +=

return x ;

y; x;

modifiee

int main ( )
{

double x double z return


// x et

= 3.2 , =
y

y = 2.3; Add ( x , y ) ;
toujours 3.2 et 2.3

valent

0;

Table des matires


}

page 12

Pour modier les arguments, on utilise des rfrences, an de passer l'adresse des arguments. Ainsi on vite la copie locale des arguments, qui peut etre coteuse si certaines variables sont volumineuses.
//

struct BigArray
};

exemple

d ' une

structure

volumineuse

double A [ 1 0 0 0 ] ;
on de passe plus x et tab par reference , locale de ils peuvent etre modifies

// //

void modify_argument ( double& x , BigArray& tab )


{

aucune

copie

tab

n ' est

effectuee

for
x

( int i = 0 ; i tab . A [ i ] = x ;

< 1000;

i++)

+= 1 . 0 ;

}
// // // on est le peut utiliser le mot s ' il

c l e
est la

const passe copie

pour par

specifier reference d ' un gros

q u ' un

argument

inchange , but est ici

meme

void test_argument ( const BigArray& t )


{ }

d ' eviter

locale

objet

t.A[0]

2.0;

//

erreur

la

compilation

int main ( )
{

double x

BigArray tab ; for ( int i = 0 ; i < 1 0 0 0 ; i++) tab . A [ i ] = double ( i ) ; modify_argument ( x , tab ) ;
x et tab ont ete modifies

2.0;

//

return
}

0;

6.3 Passage par pointeur


Une mthode moins lgante est de passer les adresses des arguments. C'est une technique surtout employe pour le passage de tableaux.

page 13

Aide-mmoire C++ par Marc Duru


le meme exemple que precedemment

void modify_argument ( double x , BigArray tab )


{
//

//

on

reprend

for

on

tab>A [ i ] =
+= 1 . 0 ;

int i

doit

alors

= 0;

i < x ;

adapter

la

1000;

i++)

fonction

x
}
// le

double sum ( double x , int n )


{

passage

par

pointeur

est

naturel

pour

un

tableau

double sum for ( int i


sum
+=

//

on

renvoie

la

somme

des

elements

du

tableau

0.0;

x[i];

= 0;

<

n ; i++)

return sum ;
}

int main ( )
{

double x
// on

BigArray tab ;
passe

2.0;

modify_argument (& x ,

ici

les

&tab ) ;

adresses

des

objets

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


// pour un tableau , c ' est on le un passe directement // puisque deja pointeur

sum ( vec , n ) ;

delete [ ] vec ; return


} 0;

Table des matires

page 14

6.4 Pointeurs et rfrences de fonctions


Grace ces fonctionnalits on peut construire des tableaux de fonctions ou passer une fonction en paramtre.
// // une reference de fonction s ' ecrit sous la forme

type_retour

(& nom_fct ) ( a r g u m e n t s )

// //

un

pointeur

de (

fonction

s ' ecrit

sous

la

forme

type_retour

nom_fct ) ( a r g u m e n t s )
construit une de fonction f entre en a generique et b, ou f

// // //

par pour est

exemple

on

calculer une

l ' integrale qui est

double integrate ( double a , double b , int N , double


{

fonction

passee

parametre

(& f ) (

double ) )

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


{

double x
sum
+=

hf ( x ) ;

= (

double ( i )

+ 0.5)h +

a;

return sum ;
}
// exemple de fonction dont on veut calculer l ' integrale

double func ( double x )


{ }

return x x

sin ( 0 . 5 x ) ;

int main ( )
{

cout cout
// //

< < < <

` ` Integrale

` ` Integrale
un un

de exp = ` ` << integrate ( 0 . 0 , 1 . 0 , 2 0 , exp ) << endl ; de func = ` ` << integrate ( 0 . 0 , 1 . 0 , 2 0 , func ) << endl ;
type un fptr qui est en un pointeur de fonction

on

declare

nouveau double

typedef double
// on declare

renvoyant

( fptr ) (

double ) ;

avec

double

parametre

fptr tab_fct [ 3 ] ;
on

un

tableau

contenant

trois

fonctions

de

ce

type

//

initialise

le

tableau

page 15

Aide-mmoire C++ par Marc Duru


= &exp ;

tab_fct [ 0 ] tab_fct [ 1 ] tab_fct [ 2 ]

= &func ;

= &asin ;

for

( int i = 0 ; i < 3 ; i++) cout << ` ` Integrale de f_i = ` ` < < integrate ( 0 . 0 , 1 . 0 , 2 0 , tab_fct [ i ] ) 0;

< <

endl ;

return
}

6.5 La fonction main


La fonction main est la fonction appele lors de l'excution, il ne doit donc y avoir qu'une seule fonction main lorsqu'on ralise l'dition des liens.

int main ( )
{
// // on un renvoie autre 0 si le programme y a eu s ' est une bien deroule entier s ' il erreur

return
}

0;

On peut galement rcuprer les arguments de la ligne de commande :


// // // // Par exemple si vous 2.5 avez execute votre programme en tapant :

./ a . out alors

toto

4
4, argv [ 0 ] vaudra et ` ` . / a . out ' ' argv [ 3 ] `` argv [ 2 ] ` `2.5 ' '

argc

vaudra

int main ( int argc , char argv )


// // les arguments peut sont des en

argv [ 1 ]

` ` toto ' ' ,

4 ' '

{
chaines double de caractere atof , et en int avec atoi q u ' on convertir avec

int n = atoi ( argv [ 3 ] ) ; double x = atof ( argv [ 2 ] ) ;


}

7 Variables
Les variables peuvent etre dclares n'importe quel endroit du programme (on dit qu'elles sont dclares la vole). La variable est dtruite lors de la fermeture de l'accolade. Les variables globales sont dclares l'extrieur de toute fonction.
//

int Nglob

par

exemple

on

declare

une

variable

globale

= 10;

Table des matires

page 16

void f ( double x )
{ }

//

elle

sera

connue

dans

toutes

les

fonctions

qui

suivent

cout

< <

` ` Nglob =

' ' < <

Nglob

< <

endl ;

void g ( double y )
{

double z = 2 . 0 y ; for ( int i = 0 ; i < Nglob ; i++) z = double ( i + 1 ) ; double w


cout
// // // on peut aussi declarer

5.43

z;

des

variable

locales

la

fonction

< <

` `w =
les

`` < <

< <

endl ;
locales ( ici w et z) sont detruites a la fermeture

toutes de

variables

l ' accolade

}
// ici w et // z ne sont de pas connues

3.0;

erreur

compilation

// //

on ne

peut peut

aussi

declarer la

des

variables apres

constantes ,

dont

on

const double epsilon


epsilon
= 3.0;
//

modifier

= 1e 10;
de

valeur

initialisation

erreur

compilation

page 17

Aide-mmoire C++ par Marc Duru

8 Structures de contrle
8.1 Oprateurs
() [] .
-> oprateur d'accs oprateur d'accs membre d'un objet ou structure raccourci pour (*pointeur). oprateur non non bit bit incrmentation (i dcrmentation (i rfrence division oppos d'un nombre ou soustraction addition de deux nombres modulo (a%b quivaut mod(a, b) en Fortran) ux de sortie ou dcalage de bit ux d'entre ou dcalage de bit signe strictement infrieur signe strictement suprieur signe infrieur ou gal signe suprieur ou gal signe gal (pour la comparaison) signe dirent et bit bit ou exclusif bit bit ou bit bit et logique ou logique structure if/else compacte aectation

! ++ & / + % << >> < > <= >= == != & | && || ?: = = += /= %= = = &= |=

+ + est quivalent i = i + 1) est quivalent i = i 1)

cible d'un pointeur ou multiplication

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 qu'il n'y a pas d'oprateur puissance (comme ** en Fortran), il faut utiliser la fonction pow (dans le package cmath). Voici un exemple d'utilisation de ces oprateurs.

Table des matires


// // on on suppose peut q u ' un objet A( i , matrice j) pour est cree avec un une surcharge de la

page 18

de

l ' operateur

()

Matrice A ; A (0 , 3) =
//

utiliser

modifier

element

matrice

2.3;
[] est utilise pour les tableaux , vecteurs , etc

vector<double> v ; v [ 0 ] = 1 . 2 e10 ;
// // on on peut

l ' operateur

declarer que

un

pointeur

sur

une

matrice une fonction GetM ( )

Matrice B ;
= &A ;
et on peut

suppose

l ' objet

Matrice

contient

//

faire

pointer

sur

//

int n
=
!

B>GetM ( ) ;
est

= ( B ) .

appeler

GetM ( ) ;

GetM ( )

soit

avec

soit

avec

>

//

int i = 5 ; if (! (i >
i
= 7;
: et

l ' operateur

non ,

! ( i >3)

equivaut

( i <=3)

3)

// &&

if

( {

( ( i ==3)
ici

logique ,

||

( i == 7 ) ) && ( i <= 5 ) )
i = 3 devrait passer la condition

||

ou

logique

//

seul

}
// != est l ' operateur different

if

((i
//

!=
i

3 ) && ( i >= 2 ) )
peut etre egal

{
a 2 ou superieur ou egal a 4

}
// ++ a gauche droite signifie signifie // // q u ' on q u ' on a a i incremente utilise = i +1; = avant d' utiliser le resultat le resultat d ' incrementer

v[++i ] v [ i++] v [ i ]
//

// ++ a

d ' abord v[ i ] i = =

avant

= =

3.4; 3.4;

equivaut equivaut

3.4; i +1;

v[ i ]

3.4;

idem

pour

la //

decrementation equivaut a

= 3.4; i = i

3.4;

v[ i ]

1;

page 19

Aide-mmoire C++ par Marc Duru


d ' une // division vaut 1 euclidienne si i est :

//

int r
on

reste

i %2;

impair

// //

peut

faire

les

operations 2.0)

classiques

double x
y
// ~ :

par

exemple

ici

= (x + 2.0)3.0
non bit a

= 1.2 ,

y = (x +

3.0

1.0/ x ;

bit

1.0/ x ;

0.8;

i i i i

//

par

exemple //

~(00000001011) = 1111110100 faire i =

soit

12

en

decimal

= ~11;
: et

devrait

12
bit | a bit , ^ : ou exclusif ( i =14) ( i =4) ( i =10)

// &

bit // // //

bit ,

et

ou

= 6

12; 12;

devrait devrait devrait

faire faire faire

0110

1100 = 1110

= 6 & 12; = 6 ^

0110 & 1100 = 0100 0110 ^ 1100 = 1010

cout << ` ` coucou ' cin >> i ; i


//

// < <

pour

les

sorties , > >

' < <

endl ;

pour

les

entrees

= ,

+=, //

/= ,

=,

%=, a

etc faire

fonctionnent i = i + 4

sur

le

meme

principe

+= 4 ;
? :

equivaut

//

= ( i >= 3 )
equivaut

pour

un

if

else

compact

?
a

1.23
if

0.4;
{ x = 1.23;} else { x = 0.4; }

//

( i >= 3 )

8.2 Structure conditionnelle if


Le mot cl else est optionnel.
//

if

else
//

cout

( i == 3 ) < < < <

si

il

une

seule

instruction ,

pas

d ' accolade

` `i ` `i

vaut

3' ' < <

endl ;
3' ' < <

cout

est different de
des accolades

endl ;

double x ; i f ( i == 3 )
{

sinon

on

met

x = 0.45; cout << ` ` i vaut

3' ' < <

endl ;

Table des matires

page 20

else i f
{

( i == 5 )

x = 0.52; cout << ` ` i vaut

5' ' < <

endl ;

else
{

x = 0.2; cout << ` ` i est different de

et de

5' ' < <

endl ;

8.3 Structure conditionnelle switch


On ne peut ici que comparer des constantes (entiers ou caractres). C'est l'equivalent du select case fortran.

char lettre ; switch ( lettre )


{

//

par

exemple

sur

un

caractere

case
//

'a ' < <

: ``

cout

instructions

lettre

dans

=
la

a'

le

cas

' < <

endl ;

ou

l e t t r e ='a '

break ; case case case


//

//

mettre

break

fin

( obligatoire )

'b ' 'c ' 'd '


ici

: : :
lettre vaut b c ou d

break ; default :
//

cout

< <

``

lettre

b c ou d '

' < <

endl ;

cout

les

autres

< <

` ` lettre

cas

inconnue '

non

traites

' < <

endl ;

8.4 Boucle for


Syntaxe : for (initialisation ; test ; itration) opration ; Example :
// Comme // ici on pour fait if , la pas d ' accolade des si une de 0 seule a 9 instruction

somme

entiers

page 21

Aide-mmoire C++ par Marc Duru

int sum = 0 ; for ( int i =


sum
+=

i;

0;

<

10;

i++)

// // //

sum

devrait y

etre a

egale

45 instructions , pas de 2 on met des accolades

lorsqu ' i l ici

plusieurs

for
{

int i
on

on

decremente

= 10;
doit

par

>= 0 ;
i

i =
< <

2)
8, 6, 4, 2, 0

cout << ` ` i sum = i ;


}

//

obtenir

`` < <

= 10 ,

endl ;

8.5 Boucle while


Syntaxe : while (condition) operation ; do operation while (condition) ;

Exemple :

// //

dans

un

premier

cas

on

teste

la

condition

avant

int i = 0 ; while ( i <


i++;
dans un

d ' effectuer

l ' operation

10)

do

//

second

cas ,

on

fait

l ' operation

avant

de

tester

la

condition

= 20; {

cout i++;

< ' ' <

`` < <

< <

endl ;

while

(i <

10);

8.6 Instructions break continue


Exemple :
// continue permet de sauter les instructions placees apres

Table des matires

page 22

for
{

int i

= 0;

<

10;

i++)

if
// //

continue ;
toutes

( i == 0 )

les

lignes pour i

qui = 0,

suivent

ne

seront

pas i > 0

cout

executees

< <

` `i =

`` < <

< <

endl ;

mais

le

seront

pour

}
// break sort de la boucle

for
{

int i

= 0;

<

10;

i++)

if
// // //

break ;
ici pour

( i == 5 )

a i

cause = 5,

du les

break ,

on

sort 6, 7,

de 8,

la 9

boucle ne seront

valeurs

jamais

parcourues

9 C++ : la couche objet


9.1 Encapsulation des donnes
On peut ici utiliser le mot-cl struct, par dfaut les membres d'une struct sont publiques, alors que les membres d'une class sont prives par dfaut. Exemple :

class NomClasse
{
//

int ip ;
ici

par

defaut // ici

les une

membres

sont

privees ( appelee attribut )

variable

membre

void CheckPrivate ( )
{ }

//

une

fonction

membre

( appelee

methode )

cout

< <

` ` classe

ok '

' < <

endl ;

protected :
//

int jp ;

tous

les

membres

places

apres

sont

` ` proteges ' '

page 23

Aide-mmoire C++ par Marc Duru

void CheckProtected ( )
{ }

cout

< <

` ` classe

ok '

' < <

endl ;

public
//

:
les membres places apres sont publics

int kp ;

tous

void CheckPublic ( )
{ }
// // on peut inserer public a ou tout moment le mot cle le type des membres qui suivent

cout

< <

` ` classe

ok '

' < <

endl ;

private : int ip2 ;

private

protected

pour

specifier

};

int main ( )
{
// // dans on une fonction exterieure donnees a la classe n 'a acces qu ' aux publiques

NomClasse var ;

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


// pas d ' acces aux

// OK

var . ip = 1 ; // e r r e u r var . CheckProtected ( ) ;

donnees de //

privees

ou

protegees

compilation erreur de compilation

return
}

0;

9.2 Hritage
Trois types d'hritage (public, private, protected), voici comment les types de donnes des attributs de la classe mre sont transforms aprs hritage :

Table des matires


Donnes public protected private Exemple
// classe mere

page 24

hritage public public protected interdit

hritage protected protected protected interdit

hritage private private private interdit

class Mother
// donnees

private : int i_private ;


donnees

privees

//

protected : int i_protected ; public : int i_public ;


donnees

protegees

//

publiques

};
// classe fille , par exemple pour un heritage public

class Daughter void Test ( )


{
//

public Mother

i_protected
sauf les

on

peut

acceder

tous

les

membres

de

la

classe

mere

= 0;
donnees // privees de compilation

//

i_private

= 0;

erreur

} };
// pour un heritage protege

class Fille
};

protected Mother

class Father
{

public : int j_public ;

page 25

Aide-mmoire C++ par Marc Duru

};
// on peut faire aussi un heritage multiple

class Fils
};

public Mother , public Father

9.3 Fonctions et classes amies


Exemple :

class Mother
{

private int ip ;
//

:
amie

friend void affiche_ip ( const Mother


classe amie

fonction

&);

//

friend class Amie ;


dans la fonction amie on peut acceder aux membres privees de la classe

};
//

void affiche_ip ( const Mother


{ }
// pour les classes amies :

&

var )

cout

< <

``

`` < <

var . ip

< <

endl ;

class Amie public


// les

:
methodes ont acces

void ChangeIp ( Mother


{ } };

&

var ,

aux

int j )

donnees

privees

de

Mother

var . ip

j;

int main ( )
{

Mother var ; Amie a ; a . ChangeIp ( var ,


3);

Table des matires

page 26

affiche_ip ( var ) ;
}

9.4 Constructeur, destructeur


class Base
{

protected int i ; double x ;


//

public
un et a

les

constructeurs

et

destructeurs

sont

publics

:
constructeur le n 'a que pas la de type de retour meme nom classe

// //

Base ( ) i x
//

{
un constructeur sert a initialiser les attributs

= 0; = 1.0;

}
// deuxieme constructeur

Base ( int j , i x
= =

double y )

j; y;

}
// constructeur par copie

Base ( const Base& var ) i x


= =

var . i ; var . x ;

}
// un seul destructeur possible

~ Base ( ) {
// //

un ici

destructeur pas de

sert a

liberer detruire

la

memoire

utilisee

par

l ' objet

tableau

page 27

Aide-mmoire C++ par Marc Duru

};

class Daughter
{

public Base

double y ; public
// // on et

:
appelle les le constructeur des de la classe mere constructeurs attributs

Daughter ( double z )

Base ( ) , y ( z )

{} :

Daughter ( int j ,
{ }
// pour eviter

double w , double z )

Base ( j , w )

z;

explicit Daughter ( int j )


y
= 0.0;

les

conversions

Base ( )

implicites ,

mot

cle

explicit

{ }
// //

pas le

besoin

de

declarer par

le

destructeur est implicite et ne fait rien

destructeur

defaut

};

int main ( )
{
// // des si q u ' on pas declare un objet , ici , un le constructeur constructeur sera par appele defaut Base ( ) est appele d ' argument comme

Base b ;

//

Base a ( 4 ,
appel

appel

du

second

constructeur

de

Base

5.0);
du constructeur par copie ( equivalent a initialiser c = a)

//

Base c ( a ) ;
on

//

Base ( 6 , 2 . 0 ) ;
//

peut

aussi

appeler

un

constructeur

apres

la

declaration

Daughter z ;
// car le

erreur

la par

compilation defaut n 'a pas ete defini

constructeur

Table des matires

page 28

Daughter w ( 2 ,

5.23 ,

0.43);

//

ok

return
}

//

lors

de

l ' accolade

fermante ,

les

destructeurs

seront

appeles

0;

9.5 Pointeur this


C'est un pointeur vers l'objet instanci.

class Base ; void affiche_objet ( const Base& v ) ; class Base


{

public : int ip ; void ModifieIp ( int j )


{

ip
// //

=
si

j;
on veut appeler on une fonction this qui prend en argument

affiche_objet ( this ) ;

l ' objet

courant ,

utilise

void SetIp ( int j )


{ } };

ip

j;

void affiche_objet ( const Base& v )


{ }

cout

< <

` `i =

`` < <

v . ip

< <

endl ;

int main ( )
{

Base var ; var . ModifieIp ( 4 ) ;


// il aurait ete equivalent de faire

page 29

Aide-mmoire C++ par Marc Duru


a f f i c h e _ o b j e t ( var ) ;

//

var . SetIp ( 4 ) ;

return
}

0;

9.6 Attributs et mthodes statiques


Les attributs statiques sont partags par toutes les instances d'une classe. Les mthodes statiques ne doivent pas modier d'attribut dynamique, ni appeler des mthodes dynamiques. Les mthodes statiques sont compltement quivalentes des fonctions usuelles (extrieures la classe) except qu'elles sont encapsules dans une classe.

class Exemple
{

public
//

:
dynamiques

int ip ; double x ;
//

attributs

static int jp ; static double y ;


methodes

attributs

statiques

precedes

par

le

mot

cle

static

void SetIp ( int j )


{ }
// methodes

//

dynamiques

ip

j;

static void DisplayInfoClass ( )


cout
< < ` ` Cette

statiques

precedees

par

le

mot

cle

static

classe ne sert a rien '


erreur , de

' < <

endl ;

ip = 0 ; // i n t e r d i t , SetIp ( 3 ) ; // i n t e r d i t jp
} };
// declaration

compilation de compilation

erreur

= 3;

//

oui

on

le

droit

int Exemple : : jp ( 3 ) ; double Exemple : : y ( 2 . 0 3 ) ;

obligatoire

des

attributs

statiques

l ' exterieur

de

la

classe

Table des matires

page 30

int main ( )
{
//

Exemple : : jp = 10; Exemple : : y = 0 . 4 5 ;


pour appeler

pour

modifier

un

membre

statique

//

Exemple : : DisplayInfoClass ( ) ;
0;

une

fonction

statique

return
}

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 dnies dans les classes lles.

class Forme
{

public
//

: ~ Forme ( )
une classe abstraite le destructeur doit etre virtuel

virtual
on qui

pour

{}
des fonctions dans virtuelles classes derivees

// //

peut

definir

virtual void Draw ( )


//

seront

surchargees

les

cout

ne

fait

< <

` ` Methode

rien ,

on

indefinie '

sait

pas

comment

' < <

endl ;

dessiner

une

forme

generale

}
// // // on peut a declarer pas ne des de methodes virtuelles car on pures considere

q u ' on

besoin seront

detailler , appelees

virtual int GetNombrePoints ( )


dans qui une sont methode

qu ' e l l e

jamais

= 0;

// //

generique , pour

on

peut

utiliser

les

methodes

virtuelles

void AnalyseDessin ( )
{
// // ici la definie dans

specialisees

chaque

forme

fonction

Draw

appelee cela peut

n ' est etre

pas une

forcement fonction

la

fonction classe

Draw ( ) derivee

Draw ( ) ;

Forme ,

d ' une

page 31

Aide-mmoire C++ par Marc Duru

cout
} };

int n

< <

GetNombrePoints ( ) ; ' ' Nombre de points de la forme

`` < <

< <

endl ;

class Carre
{

public Forme
les fonctions virtuelles de Forme

public
// on

:
surcharge

int GetNombrePoints ( ) return


4;

{ }

void Draw ( )
{

cout cout cout

< < `` ' ' < < < < ` `| | ' ' < < < < `` ' ' < <

endl ; endl ; endl ;

} };

class Triangle
{

public Forme
les fonctions virtuelles de Forme

public
// on

:
surcharge

int GetNombrePoints ( ) return


3;

{ }

void Draw ( )
{

cout cout

< <

` `/|

' ' < <

< < `` ' ' < <

endl ; endl ;

} };

int main ( )
{

Forme b ;

//

erreur

de

compilation

car

la

classe

est

abstraite

Table des matires


// ( abstraite = contient une methode virtuelle pure )

page 32

Carre quad ;
//

quad . AnalyseDessin ( ) ; Triangle tri ;

les

fonctions

Draw ( )

et

GetNombrePoints ( )

du

Carre

seront

appelees

tri . AnalyseDessin ( ) ;
// // on peut aussi

//

les

fonctions

Draw ( )

et

GetNombrePoints ( )

du

Triangle

seront

appelees

creer un

un

objet

polymorphique ou un carre )

Forme forme ; forme


ici c ' est

( qui

pourra

etre

triangle

//

new Carre ( ) ;

un

carre

delete forme ;
//

forme

et

maintenant

new Triangle ( ) ;

un

triangle

9.8 Surcharge des oprateurs


// // par exemple si sur on veut pouvoir faire des operations

class Vector protected


// donnees //

directement

les

vecteurs

double data ; int m ;


taille vecteur

public
// on

:
surcharge dans la classe tous les operateurs internes

//

Vector&

operateur

operator =( const Vector& v )

page 33

Aide-mmoire C++ par Marc Duru

for

data [ i ]

int i

= 0;

i v(i );

<

m ; i++)

return
}
//

this ;

double operator ( ) ( int i ) const ; double& operator ( ) ( int i ) ;


// // l ' operateur pour un d ' acces () nombre // ici c ' est l ' operateur d ' acces qui peut etre utilise p o u r V( i ) = cte ;

operateur

d ' acces

()

peut

etre

surcharge (V( i , j) = quelque chose )

double& operator ( ) ( int i , int j ) ;


//

quelconque

d ' arguments

Vector Vector Vector

operateurs

& & &

operator operator operator


de

+=

= =
+=(

const Vector& v ) ; =( const Vector& v ) ; =( const Vector& v ) ;


i n c r e m e n t
++(

//

Vector

operateur

&

operator
de

pre

void ) ;

++v

//

Vector

operateur

operator
de

post

++(

int ) ;

i n c r e m e n t

v++

bool bool bool bool bool bool


};
// les

//

operateurs

operator operator operator operator operator operator

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

comparaison

Vector Vector Vector Vector Vector


on

operator operator operator


peut

operateurs

+(

const Vector & , const Vector & ) ; ( const Vector & , const Vector & ) ; ( const Vector & , const Vector & ) ;
( const double & , ( const Vector & ,
le cas mixte Vector / double

externes

sont

definis

l ' exterieur

//

operator operator

gerer

const Vector & ) ; const double & ) ;

Table des matires


// ensuite dans le main , on peut utiliser ces surcharges

page 34

int main ( )

Vector x , y , z ;
++x ;

= 2.0 x +

y;

x(0)
//

3.0;

...

return
}

0;

10 Structure d'un code


En dispose les dclarations des fonctions et classes (appeles prototypes) dans des chiers d'en-tte (headers) dont l'extension se termine par .hpp, .H, .h++ ou .hxx. Les dnitions sont elles places dans des chiers .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 la de prototype est d ' une fonction un autre fichier

void MaFunction ( const double & , int , double ) ;


// // parfois de deux classes sont entrelacees , classe , il

fonction

definie

dans

est de

alors la

utile plus loin :

class MaClasse ;
on peut avec

declarer

l ' existence

d ' une

avant

detailler

// //

alors

declarer en

des

prototypes

de

fonctions

void FunctionClasse ( const MaClasse


//

MaClasse

argument

&);

class MaClasse public : int n ; double x ;

exemple

de

prototype

d ' une

classe

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

//

on

ne

met

que

les

prototypes

des

fonctions

membres

page 35

Aide-mmoire C++ par Marc Duru

};
// // Pour a definir les de fonctions la classe membres : Fonc1 et Fonc2

void MaClasse : : Fonc1 ( double y )


{ }

l ' exterieur

= 2.0 y ;

int MaClasse : : Fonc2 ( int m )


{ }

return m

n;

10.2 Directives du prprocesseur


Les directives du prprocesseur commencent toutes par #.
// // La qui directive inclut de la plus utilisee directe est le la directive d ' un include fichier

#include
// le

maniere

contenu

<i o s t r e a m >
iostream . h sera directement insere dans le fichier

fichier

#include
// // pour

//

pour

un

fichier

personnel ,

on

met

des

guillements

` ` M o n F i c h i e r . hxx ' '


eviter des les multiples de ce inclusions , type : les fichiers comportent

#ifndef #define
// // // le

toujours

lignes

FILE_MON_FICHIER_HEADER_HXX FILE_MON_FICHIER_HEADER_HXX
ici ce doit etre unique parmi tous les fichiers du inclus meme fichier de mettre define empeche une sera seconde alors inclusion defini

l ' identificateur fait

puisque

FILE_MON_FICHIER_HEADER_HXX

//

class Patati
{};
et on

on

met

ici

tout

le

contenu

du

fichier

#endif
// // la des

//

termine

par

endif

notion

de

flags

est

souvent peut

utilisee , lors

ce de

sont la compilation

indicateurs

q u ' on

definir

Table des matires


// // // // ( option Par la g++

page 36

Dnom_flag )
si on veut est specifier utilisee , dans on va le code que : Blas compiler

exemple librairie

DUSE_BLAS
le

t o t o . cc

l b l a s
on le va traiter ou on differemment ne peut pas le cas

// //

et ou

dans on

fichier utiliser

t o t o . cc , Blas , et

#i f d e f
// // // par

peut

cas

USE_BLAS
du lors code de on qui la ne sera activee soit que par si une le flag USE_BLAS est defini compilation directive #d e f i n e ) deux vecteurs

partie ( soit

daxpy_ ( n , alpha , x ,

exemple

utilise

1,

y,

une

routine

blas

pour

additionner

1);

#else
//

for

dans

y[i]

int i
+=

ce

i < n ; i++) alpha x [ i ] ;


= 0;

cas

on

pas

blas ,

on

fait

une

somme

standard

#endif #define #undef


// on // // pour activer manuellement un flag

USE_BLAS
desactiver le flag :

pour

USE_BLAS
peut tester aussi que le flag est non actif

#ifndef
//

USE_BLAS
ce cas , on a pas Blas

dans

#endif
// // // les par #d e f i n e exemple permettent la macro le aussi de definir des macros

DISP nom et contenu d ' une variable :

#define
// // on par

permet

d ' afficher

DISP ( x )
alors

std : : cout < < #x


utiliser DISP

":

" < < x < < std : : endl


et le remplacement sera effectue

peut le

partout ,

DISP ( x ) ;

preprocesseur // sera remplace par std : : cout < < `` x: `` < < x < < std : : endl ;

page 37

Aide-mmoire C++ par Marc Duru

10.3 Espace de nommages (namespace)


Lorsqu'on crit une librairie, toutes les fonctions et classes de la librairie sont encapsules dans un espace de nommage. L'espace de nommage de la STL est std.
// avant d ' ecrire toute fonction de la librairie , on met le mot cle namespace

namespace NomLibrairie
{

int Fonc1 ( double y )


{ };

return int ( y ) ;

class MaClasse
{

public : double x ;
fin du namespace

}; }
// // //

ensuite soit on

si

on

veut

utiliser

une

fonction

du

namespace ,

fait

NomLibrairie : :

void f ( )
{ }
// // soit on utilise la commande using , et on a pas besoin de

NomLibrairie : : Fonc1 ( 2 . 0 ) ;

using namespace NomLibrairie ; int main ( )

mettre

NomLibrairie : :

Fonc1 ( 2 . 0 ) ;

return
}

0;

11 Entres-sorties
Exemple :

Table des matires


// iostream pour les entrees sorties standard

page 38

#include #include
//

<i o s t r e a m >
pour les fichiers

fstream

<f s t r e a m >

using namespace std ; int main ( )


{
// // // cout cerr endl pour pour est le le un flux flux retour de des sortie a l ' ecran erreurs avec vidage du buffer

cout

< <

` ` Coucou
le

chariot

`` < <

endl ;

//

cout << ` ` Entrez un entier suivi d un flottant ' cin >> test_input >> x ;
// // par on defaut , peut en cout mettre affiche plus 5 chiffres

int test_input ; double x ;

cin

pour

flux

d ' entree

au

clavier

' < <

endl ;

significatifs

cout . precision ( 1 5 ) ; // i c i 15 cout << ` ` x = ` ` << x << endl ;


pour ecrire dans un fichier

avec

precision chiffres significatifs

//

ofstream file_out ( ` ` sortie . dat '


la syntaxe

ofstream // on ecrit dans s o r t i e . dat

' );

//

file_out
une

< <

` `x =

est

la

meme

`` < <

que

< <

endl ;

pour

cout

//

file_out . close ( ) ;
pour lire

fois

les

ecritures

terminees

//

ifstream file_in ( ` ` entree . dat '

dans

un

fichier

ifstream

' );

//

on

lit

dans

entree . dat

//

if

premiere

(! {

file_in . is_open ( ) )

chose

faire

verifier

que

le

fichier

est

ouvert

cout << abort ( ) ;

` ` Impossible
// abort

de lire le fichier entree . dat '


le programme , pratique

' < <

endl ;

quitte

pour

debugguer

}
// ensuite on peut lire une donnee

page 39

Aide-mmoire C++ par Marc Duru


> >

file_in
//

x;
verifier si la lecture de cette donnee a marche

if

on

(! {

file_in . good ( ) )
un echec peut

peut

// //

venir si il y

d ' une a un

mauvaise mot

donnee d ' un nombre )

cout << abort ( ) ;

( par

exemple

` ` Echec

de lecture '

' < <

endl ;

au

lieu

}
// on ferme le flux une fois termine

file_in . close ( ) ;
on peut

//

file_in . open ( ` ` autre . dat ' file_in . close ( ) ;


pour lire /ecrire en

ouvrir

un

autre

fichier

avec

la

methode

open

' );

//

file_out . open ( ` ` binary . dat '


write demande des char ,

binaire

on

utilise

write

et

read

' );
donc on convertit

//

file_out . write ( reinterpret_cast <char >(&x ) , file_out . close ( ) ;


' );
donc on convertit

sizeof ( double ) ) ;

tout

en

char

file_in . open ( ` ` binary . dat '


// read demande des char ,

file_in . read ( reinterpret_cast <char >(&x ) , file_out . close ( ) ;


0;

sizeof ( double ) ) ;

tout

en

char

return
}

12 Fonctions et classes gnriques


Exemple de fonctions gnriques :
// // // // // par qui exemple , marche que a de si la l ' on veut pour le ecrire les une fonction et les reels fois complexes on un va

plutot une par

dupliquer prenant en

code ,

ecrire generique ,

fonction exemple

parametre d ' un

type :

template<class Vector> double Norm ( const Vector& x )


{

pour

la

norme

vecteur

Table des matires

page 40

double norm = 0 . 0 ; for ( unsigned int i


norm
+=

abs ( x [ i ] ) ;

= 0;

<

x . size ( ) ; i++)

return norm ;
}
// on peut avoir plusieurs types generiques

template<class Matrix , class Vector1 , class Vector2> void MltAdd ( const Matrix& A , const Vector1& x , Vector2& y )
{
// ...

int main ( )
{

vector<double> x ; cout << Norm ( x ) << endl ;


// pour les vecteurs

//

les

fonctions

s ' utilisent

normalement

vector<complex<double> > xc ; cout << Norm ( xc ) << endl ;


} Exemple de classes gnriques
// exemple peut d ' une etre un classe int ,

complexes

vecteur double , char , string , etc

template<class T> class Vector


{

// T

protected :
T data ; int m ;
// donnees

public : int GetSize ( )


{ } };
// on peut mettre plusieurs parametres

return m ;

page 41

Aide-mmoire C++ par Marc Duru

template<class T , class Prop> class Base


{

public
//

:
des fonctions normales

void FoncNormale ( double , double ) ;


// et des fonctions template

declarer

template<class Vector> void FoncGeneric ( double , Vector & ) ;


};
// definition des fonctions a l ' exterieur de la classe

template<class T , class Prop> void Base<T , Prop > : : FoncNormale ( double x , double y )
{ }
// // pour la fonction de la template , puis on a en de premier la les

parametres

template<class T , class Prop> template<class Vector> void Base<T , Prop > : : FoncGeneric ( double x , Vector& y )
{ }
// // // on la peut ensuite ainsi pour faire une specialisation partielle la de la classe

template

classe

ceux

fonction

classe

definie le jeu de

remplacera parametres

completement choisi

classe

template<class Prop> class Base<int , Prop>


{ };
// on peut faire une

generique

public

template<> class Base<int , double>


{ };

specialisation

totale

int main ( )
{

Vector<int > v ;

//

lors

de

l ' instanciation ,

il

faut

preciser

le

type

des

parametres

Table des matires

page 42

Base<string , Base<int Base<int


}
// ici // ici le

//

ici

le

compilateur

int > A ;

choisira

la

classe

Base

generique

string> B ;

compilateur

choisira

la

classe

Base

specialisee

partiellement

le

double> C ;

compilateur

choisira

la

classe

specialisee

totalement

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.
// ici m designe c onn u a la la taille du vecteur ce qui permet de pouvoir ecrire

// m //

est

compilation , ( meta

template<typename T , int m> class TinyVector


{
// // comme m utiliser est des c onn u a la tableaux

des

algos

optimises

p r o g r a m i n g )

compilation , statiques

on

peut

T data [ m ] ; T
{ } };

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

int main ( )
{
//

TinyVector <double ,

dans

le

main ,

on

doit

3>

y;

preciser

la

taille

13 Exceptions en C++
Exemple

#include #include

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

page 43

Aide-mmoire C++ par Marc Duru

using namespace std ;


//

class MonException
string comment ;
// constructeur

pour

chaque

nouvelle

exception ,

on

fait

une

classe

public

//

commentaire

associe

l ' exception

MonException ( const string& c )

prenant

un

commentaire

comment ( c )

en

argument

{}

};

int main ( )
{

try
{
// // on si met a un ici le code on a q u ' on une veut executer on peut lancer une exception moment erreur ,

MonException a ( ` ` Argument invalide ' throw a ;


// // une par exception exemple un peut etre de entier

' );

n ' importe

quel

type

int b = 3 ; throw b ; catch


{
// // cas on ou fait

( MonException&
une le

err )
de type MonException a cette a ete lancee

exception traitement

associee

excpetion

catch
{
//

int a )
cas ou une exception de type entier a ete lancee

catch
{
// // //

(...)
toutes on ce peut cas les autres exceptions par exemple si on ne sait pas gerer

appeler la

abort

abort ( ) ;
0;

return

Table des matires


}

page 44

14 Utilisation de la STL
14.1 Fonctions mathmatiques
Les fonctions mathmatiques sont contenues dans cmath. Exemple

#include

<cmath>

using namespace std ; int main ( )


{

double x double z
// // // // // // // // sqrt exp log : :

//

calcul

de

= 2.3 , =
:

y = 0.8; pow ( x , y ) ;
carree

x^y

racine

exponentielle logarithme : : neperien en en base base 2 trigos cos , usuelles sin atanh et : tan les cos , sin , etc hyperboliques 10

log10 log2 sin , asin , sinh , tgamma

logarithme logarithme tan :

cos ,

fonctions : les arc

acos , cosh , :

atan tanh ,

asinh , gamma

acos ,

//

asin ( x ) ;

fonction

// //

arrondi ici on

au

plus

proche en entier parce que round renvoie un reel

int n
=

int ( round ( z ) ) ;
inferieur

convertit

n n
}

//

arrondi

int ( floor ( z ) ) ;

//

arrondi

int ( ceil ( z ) ) ;

superieur

//

d ' autres

fonctions

existent

page 45

Aide-mmoire C++ par Marc Duru

14.2 Chanes de caractres (string)


Exemple

#include <s t r i n g > #include <i o s t r e a m > #include <s s t r e a m > using namespace std ; template<typename T> inline std : : string to_str ( const T& input )
{
// pour convertir un nombre en string

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

template < class T> inline T to_num ( std : : string s )


{

//

pour

convertir

un

string

en

nombre

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

int main ( )
{
// // pour mais manipuler plutot des les chaines de caracteres , ne pas utiliser char

(C)

string s ( ` ` toto '


nombre de

string

' );
: size ()

//

cout

< <

` ` nombre

caracteres

de lettres
chaque vaut

`` < <

s . size ( )

< <
[]

endl ;

s[1]
//

//

pour

acceder

a s

caractere ,

operateur

'y ' ;
peut

//

maintenant

tyto

if

on

cout

( s ==

` ` tata ' ' )

comparer

des

string

< <

` ` incorrect ' ' < <

endl ;

Table des matires


// on peut concatener avec s vaut l ' operateur maintenant + t y t o . dat

page 46

` `.

dat '

' ;

//

//

int pos i f ( pos


on

s . find ( ` ` to ' ' ) ; // p o s d e v r a i t v a l o i r 2 == string : : npos ) cout << ` ` on n a pas trouve la chaine to dans s '
=
peut extraire

on

peut

rechercher

une

chaine

' < <

endl ;

//

string s_sub
pour

s . substr ( pos ,
3

une

sous

c h a i n e
3);
a partir de s [ pos ]

//

extraire

caracteres

s_sub
//

s . substr ( pos ) ;
extraire tous les caracteres a partir de s [ pos ]

pour

//

s s

int i
=
et

par

exemple

pour

convertir

= 356

en

string

to_str ( i ) ;
pour convertir ` `3.1456 ' ' en double

= 356;

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 ( )
{
// // la classe vector stocke les elements lente de 5 reels de maniere contigue acces rapide , mais insertion // vecteur

vector<double> x ( 5 ) ; x[0] x[1]


// // acces

= 1 . 0 6 e 7; =

avec

[]

3.5 e8 ;

x . resize ( 6 ) ;
// les

on

peut

agrandir

le

vecteur

en

gardant

les

anciens

elements

nouveaux

elements

doivent

etre

initialises

page 47

Aide-mmoire C++ par Marc Duru


2.5;

x[5]
// //

on ( ie

peut le

aussi vecteur

rajouter est //

un

element et a un

la

fin

du est

vecteur rajoute ) = 3.4;

x . push_back ( 3 . 4 ) ; x . clear ( ) ;
}
// on peut aussi

retaille equivalent

element

x . resize (7);

x [6]

inserer

un

element

avec

insert ,

et

detruire

le

vecteur

avec

clear

14.4 Listes
#include < l i s t > #include <i o s t r e a m > using namespace std ; int main ( )
{
// // // une liste a ne une stocke liste pas les elements de maniere contingu ( pensez simplement mais chainee ) est lent

list<double> v ;
// push_back et

l ' insertion

est

rapide ,

l ' acces

v . push_back ( 3 . 4 ) ; v . push_back ( 0 . 3 ) ;
// pour

insert

existent

list<double > : : iterator it ; cout << ` ` v = ` ` ; for ( it = v . begin ( ) ; it != v . end ( ) ; cout << ` ` ` ` << it ; cout
} < <

parcourir

la

liste ,

le

mieux

est

d' utiliser

un

iterateur

++it )

endl ;

14.5 Piles
#include <s t a c k > using namespace std ; int main ( )
{

Table des matires


// // stack est un conteneur premier correspondant sorti ) a une pile

page 48

stack<double> pile ;
//

( premier

entre ,

pile . push ( 0 . 3 3 ) ; pile . push ( 0 . 2 5 ) ; pile . push ( 1 . 3 ) ; // pile . pop ( ) ;


pour on libere un //

on

empile

les

elements

avec

push

la

pile

vaut

(1.3 ,

0.25 ,

0.33)

//

element la pile

avec vaut (

pop

0.25 ,

0.33)

double y
}

//

acceder

pile . top ( ) ;

au

dernier //

element y =

top et la pile vaut (

0.25

0.25 ,

0.33)

También podría gustarte