Documentos de Académico
Documentos de Profesional
Documentos de Cultura
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
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
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11 12
Entres-sorties
page 4
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
42 44 44 45 46 47 47
Utilisation de la STL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fonctions mathmatiques Chanes de caractres (string) . . . . . . . . . . . . . . . . . . . . . . . . . . . Vecteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Piles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1 Commentaires
/
/
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)
void
//
Type vide, utilis le plus souvent pour signaler qu'une fonction ne retourne rien.
exemple
de
function
qui
ne
renvoie
rien
cout
< <
``
`` < <
< <
endl ;
page 5
true ;
les utiliser directement dans les conditions
if
on
cout
( test )
peut
< <
` ` Test
est vrai
`` < <
endl ;
char
// la
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
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
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
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
page 6
double
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
pour
avoir
le
type
int64_t
9e 1 8 int64_t n
= 345;
short
// // il n 'y
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
pas 10 la
de
regle ,
mais
par
exemple
long
double
est
en
general
stocke mettre
sur L a
( double
precision
etendue )
long double x
= 0.1234 L ;
literaux
entiers
sont
signes ,
pour
declarer
un
entier
positif :
= 23;
page 7
//
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
; ;
1.0 2.0
// on
on
declare specifie
pointe
pointe x vaut
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
// //
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
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
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};
int n ;
`` < <
endl ;
tableau
avec vers
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
struct NomStructure
{
//
int nombre_invites ;
tableau
nombre
des
invites
//
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 :
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
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
page 10
6 Fonctions
Syntaxe : type_retour nom_fonction(arg1, arg2, arg_default = value_default) ;
//
exemple
trivial
d ' une
fonction
renvoyant
x+y
return x
y;
fonction
pour
des
arguments
differents
{ }
y;
return x
z;
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
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
//
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 ( )
{
= 3.2 , =
y
y = 2.3; Add ( x , y ) ;
toujours 3.2 et 2.3
valent
0;
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
// //
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
pour par
q u ' un
argument
meme
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;
page 13
//
on
reprend
for
on
tab>A [ i ] =
+= 1 . 0 ;
int i
doit
alors
= 0;
i < x ;
adapter
la
1000;
i++)
fonction
x
}
// le
passage
par
pointeur
est
naturel
pour
un
tableau
//
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
sum ( vec , n ) ;
page 14
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
// // //
exemple
on
calculer une
fonction
passee
parametre
(& f ) (
double ) )
double x
sum
+=
hf ( x ) ;
= (
double ( i )
+ 0.5)h +
a;
return sum ;
}
// exemple de fonction dont on veut calculer l ' integrale
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
= &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
}
int main ( )
{
// // on un renvoie autre 0 si le programme y a eu s ' est une bien deroule entier s ' il erreur
return
}
0;
./ a . out alors
toto
4
4, argv [ 0 ] vaudra et ` ` . / a . out ' ' argv [ 3 ] `` argv [ 2 ] ` `2.5 ' '
argc
vaudra
argv [ 1 ]
4 ' '
{
chaines double de caractere atof , et en int avec atoi q u ' on convertir avec
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;
page 16
void f ( double x )
{ }
//
elle
sera
connue
dans
toutes
les
fonctions
qui
suivent
cout
< <
` ` Nglob =
Nglob
< <
endl ;
void g ( double y )
{
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
modifier
= 1e 10;
de
valeur
initialisation
erreur
compilation
page 17
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
! ++ & / + % << >> < > <= >= == != & | && || ?: = = += /= %= = = &= |=
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.
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 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
//
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 //
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;
0110
1100 = 1110
= 6 & 12; = 6 ^
// < <
pour
les
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 )
if
else
//
cout
si
il
une
seule
instruction ,
pas
d ' accolade
` `i ` `i
vaut
endl ;
3' ' < <
cout
est different de
des accolades
endl ;
double x ; i f ( i == 3 )
{
sinon
on
met
endl ;
page 20
else i f
{
( i == 5 )
endl ;
else
{
et de
endl ;
//
par
exemple
sur
un
caractere
case
//
: ``
cout
instructions
lettre
dans
=
la
a'
le
cas
endl ;
ou
l e t t r e ='a '
//
mettre
break
fin
( obligatoire )
: : :
lettre vaut b c ou d
break ; default :
//
cout
< <
``
lettre
b c ou d '
endl ;
cout
les
autres
< <
` ` lettre
cas
inconnue '
non
traites
endl ;
somme
entiers
page 21
i;
0;
<
10;
i++)
// // //
sum
devrait y
etre a
egale
plusieurs
for
{
int i
on
on
decremente
= 10;
doit
par
>= 0 ;
i
i =
< <
2)
8, 6, 4, 2, 0
//
obtenir
`` < <
= 10 ,
endl ;
Exemple :
// //
dans
un
premier
cas
on
teste
la
condition
avant
d ' effectuer
l ' operation
10)
do
//
second
cas ,
on
fait
l ' operation
avant
de
tester
la
condition
= 20; {
cout i++;
`` < <
< <
endl ;
while
(i <
10);
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
class NomClasse
{
//
int ip ;
ici
par
defaut // ici
les une
membres
sont
variable
membre
void CheckPrivate ( )
{ }
//
une
fonction
membre
( appelee
methode )
cout
< <
` ` classe
ok '
endl ;
protected :
//
int jp ;
tous
les
membres
places
apres
sont
page 23
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
protected
pour
specifier
};
int main ( )
{
// // dans on une fonction exterieure donnees a la classe n 'a acces qu ' aux publiques
NomClasse var ;
// OK
donnees de //
privees
ou
protegees
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 :
page 24
class Mother
// donnees
privees
//
protegees
//
publiques
};
// classe fille , par exemple pour un heritage public
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
{
page 25
};
// on peut faire aussi un heritage multiple
class Fils
};
class Mother
{
private int ip ;
//
:
amie
fonction
&);
//
};
//
&
var )
cout
< <
``
`` < <
var . ip
< <
endl ;
:
methodes ont acces
&
var ,
aux
int j )
donnees
privees
de
Mother
var . ip
j;
int main ( )
{
page 26
affiche_ip ( var ) ;
}
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
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
};
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;
les
conversions
Base ( )
implicites ,
mot
cle
explicit
{ }
// //
pas le
besoin
de
declarer par
le
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
constructeur
page 28
Daughter w ( 2 ,
5.23 ,
0.43);
//
ok
return
}
//
lors
de
l ' accolade
fermante ,
les
destructeurs
seront
appeles
0;
ip
// //
=
si
j;
on veut appeler on une fonction this qui prend en argument
affiche_objet ( this ) ;
l ' objet
courant ,
utilise
ip
j;
cout
< <
` `i =
`` < <
v . ip
< <
endl ;
int main ( )
{
page 29
//
var . SetIp ( 4 ) ;
return
}
0;
class Exemple
{
public
//
:
dynamiques
int ip ; double x ;
//
attributs
attributs
statiques
precedes
par
le
mot
cle
static
//
dynamiques
ip
j;
statiques
precedees
par
le
mot
cle
static
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
obligatoire
des
attributs
statiques
l ' exterieur
de
la
classe
page 30
int main ( )
{
//
pour
modifier
un
membre
statique
//
Exemple : : DisplayInfoClass ( ) ;
0;
une
fonction
statique
return
}
class Forme
{
public
//
: ~ Forme ( )
une classe abstraite le destructeur doit etre virtuel
virtual
on qui
pour
{}
des fonctions dans virtuelles classes derivees
// //
peut
definir
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
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
pas une
forcement fonction
la
fonction classe
Draw ( ) derivee
Draw ( ) ;
Forme ,
d ' une
page 31
cout
} };
int n
< <
`` < <
< <
endl ;
class Carre
{
public Forme
les fonctions virtuelles de Forme
public
// on
:
surcharge
{ }
void Draw ( )
{
< < `` ' ' < < < < ` `| | ' ' < < < < `` ' ' < <
} };
class Triangle
{
public Forme
les fonctions virtuelles de Forme
public
// on
:
surcharge
{ }
void Draw ( )
{
cout cout
< <
` `/|
endl ; endl ;
} };
int main ( )
{
Forme b ;
//
erreur
de
compilation
car
la
classe
est
abstraite
page 32
Carre quad ;
//
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 )
( qui
pourra
etre
triangle
//
new Carre ( ) ;
un
carre
delete forme ;
//
forme
et
maintenant
new Triangle ( ) ;
un
triangle
directement
les
vecteurs
public
// on
:
surcharge dans la classe tous les operateurs internes
//
Vector&
operateur
page 33
for
data [ i ]
int i
= 0;
i v(i );
<
m ; i++)
return
}
//
this ;
operateur
d ' acces
()
peut
etre
quelconque
d ' arguments
operateurs
+=
= =
+=(
//
Vector
operateur
&
operator
de
pre
void ) ;
++v
//
Vector
operateur
operator
de
post
++(
int ) ;
i n c r e m e n t
v++
//
operateurs
const Vector &) const ; ! = ( const Vector &) const ; <=( const Vector &) const ; >=( const Vector &) const ; <( const Vector &) const ; >( const Vector &) const ;
==(
comparaison
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
page 34
int main ( )
Vector x , y , z ;
++x ;
= 2.0 x +
y;
x(0)
//
3.0;
...
return
}
0;
fonction
definie
dans
est de
alors la
class MaClasse ;
on peut avec
declarer
l ' existence
d ' une
avant
detailler
// //
alors
declarer en
des
prototypes
de
fonctions
MaClasse
argument
&);
exemple
de
prototype
d ' une
classe
//
on
ne
met
que
les
prototypes
des
fonctions
membres
page 35
};
// // Pour a definir les de fonctions la classe membres : Fonc1 et Fonc2
l ' exterieur
= 2.0 y ;
return m
n;
#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
#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
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
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
cas
on
pas
blas ,
on
fait
une
somme
standard
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
#define
// // on par
permet
d ' afficher
DISP ( x )
alors
":
peut le
partout ,
DISP ( x ) ;
preprocesseur // sera remplace par std : : cout < < `` x: `` < < x < < std : : endl ;
page 37
namespace NomLibrairie
{
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 ) ;
mettre
NomLibrairie : :
Fonc1 ( 2 . 0 ) ;
return
}
0;
11 Entres-sorties
Exemple :
page 38
#include #include
//
<i o s t r e a m >
pour les fichiers
fstream
<f s t r e a m >
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
cin
pour
flux
d ' entree
au
clavier
endl ;
significatifs
avec
//
' );
//
file_out
une
< <
` `x =
est
la
meme
`` < <
que
< <
endl ;
pour
cout
//
file_out . close ( ) ;
pour lire
fois
les
ecritures
terminees
//
dans
un
fichier
ifstream
' );
//
on
lit
dans
entree . dat
//
if
premiere
(! {
file_in . is_open ( ) )
chose
faire
verifier
que
le
fichier
est
ouvert
` ` Impossible
// abort
endl ;
quitte
pour
debugguer
}
// ensuite on peut lire une donnee
page 39
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
( par
exemple
` ` Echec
de lecture '
endl ;
au
lieu
}
// on ferme le flux une fois termine
file_in . close ( ) ;
on peut
//
ouvrir
un
autre
fichier
avec
la
methode
open
' );
//
binaire
on
utilise
write
et
read
' );
donc on convertit
//
sizeof ( double ) ) ;
tout
en
char
sizeof ( double ) ) ;
tout
en
char
return
}
dupliquer prenant en
code ,
ecrire generique ,
fonction exemple
parametre d ' un
type :
pour
la
norme
vecteur
page 40
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 ( )
{
//
les
fonctions
s ' utilisent
normalement
complexes
// T
protected :
T data ; int m ;
// donnees
return m ;
page 41
public
//
:
des fonctions normales
declarer
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
generique
public
specialisation
totale
int main ( )
{
Vector<int > v ;
//
lors
de
l ' instanciation ,
il
faut
preciser
le
type
des
parametres
page 42
//
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
des
algos
optimises
p r o g r a m i n g )
compilation , statiques
on
peut
T data [ m ] ; T
{ } };
int main ( )
{
//
TinyVector <double ,
dans
le
main ,
on
doit
3>
y;
preciser
la
taille
13 Exceptions en C++
Exemple
#include #include
page 43
class MonException
string comment ;
// constructeur
pour
chaque
nouvelle
exception ,
on
fait
une
classe
public
//
commentaire
associe
l ' exception
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 ,
' );
n ' importe
quel
type
( 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
page 44
14 Utilisation de la STL
14.1 Fonctions mathmatiques
Les fonctions mathmatiques sont contenues dans cmath. Exemple
#include
<cmath>
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
cos ,
acos , cosh , :
atan tanh ,
asinh , gamma
acos ,
//
asin ( x ) ;
fonction
// //
arrondi ici on
au
plus
int n
=
int ( round ( z ) ) ;
inferieur
convertit
n n
}
//
arrondi
int ( floor ( z ) ) ;
//
arrondi
int ( ceil ( z ) ) ;
superieur
//
d ' autres
fonctions
existent
page 45
#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
//
pour
convertir
un
string
en
nombre
int main ( )
{
// // pour mais manipuler plutot des les chaines de caracteres , ne pas utiliser char
(C)
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 ==
comparer
des
string
< <
endl ;
page 46
` `.
dat '
' ;
//
//
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;
//
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
= 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
x[5]
// //
on ( ie
peut le
aussi vecteur
rajouter est //
un
element et a un
la
fin
du est
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 ( )
{
page 48
stack<double> pile ;
//
( premier
entre ,
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 =
0.25
0.25 ,
0.33)