Vous êtes sur la page 1sur 13

Ecole Nationale de Techniques Avancées

Simulation Numérique
Chapitre 1
C++ une extension du C
Eric Lunéville

Génèse du C++
Premier langage orienté objet : projet Smaltalk (1970)
En 1980 Bjarne Stroustrup (ATT \& Bell) introduit des
extensions au C : C with classes
C++ = extension du C , C++ n'est pas un langage objet!
Volonté de corriger certains défauts ou limitations du C
Aspects syntaxiques (commentaires, déclarations, ...)
Allocation dynamique (opérateur new)
Conversion de type (casting)
Les références (pointeurs déguisés)
Les fonctions : (arguments par défaut , surcharge)
Les entrées/sortie standard (flux)
Les classes extension de struct
Sim. Numérique – chapitre1 1
Syntaxe : Commentaires
En C : bloc de commentaire

/∗ l i g n e de commentaire ∗/
....
/∗
b l o c de commentaire
∗/

En C++ : lignes de commentaires (plus souple)

// l i g n e de commentaire
// . . . . . .

se termine avec le caractère de fin de ligne

Les deux peuvent coexister, préférence pour le style C++

Sim. Numérique – chapitre1 2

Syntaxe : déclarations
En C : déclarations des variables en début de bloc

En C++ : déclarations n'importe où

{double x=0;
int N=10;
for ( int i =1; i <N; i ++)
{double l n g=l o g ( i ) ;
l n g=l n g ∗ l n g ;
double c=c o s ( i ) ; // i n v a l i d e en C
x+=l n g ∗ c ;
}
}

A éviter n’améliore pas la lisibilité !

Sim. Numérique – chapitre1- 3


Syntaxe : Structure
Simplification des structures en C++

/∗ d é c l a r a t i o n en C ∗/
struct complexe
{double x , y } ;
/∗ i n s t a n c i a t i o n d ’ un complexe ∗/
struct complexe z ;

// d é c l a r a t i o n en C ++
struct complexe
{double x , y } ;
// i n s t a n c i a t i o n d ’ un complexe
complexe z ;

Sim. Numérique – chapitre1- 4

Syntaxe : Fonction dans les structures


Il est possible d'adjoindre des fonctions aux structures

struct complexe
{double x , y ;
void p r i n t ( )
{ p r i n t f ( ” v a l e u r du complexe (%f ,% f ) ” , x , y ) ; }
};

int main ( )
{ complexe Z ;
Z . x=0;Z . y=1;
Z. print ( ) ;
}

Il est préférable d'utiliser des classes qui apportent un meilleur contrôle

Sim. Numérique – chapitre1- 5


Qu’est-ce qu’un pointeur?
Un pointeur est un type de variable qui contient
l’adresse d’une autre variable
adresse 15 16 zone mémoire 22
0x22 3.14

float *p float pi
Deux « catégories » de pointeurs :
pointeur typé : type * p; le plus courant
pointeur non typé : void * p; en fait de type void !

float pi =3.14;
f l o a t ∗p=&p i ; // ré fé r e n c e m e n t
f l o a t q i =∗p ; // dé ré fé r e n c e m e n t
void ∗ q=n u l l ; // p o i n t e u r non ty pé ,
// i n i t i a l i s é à n u l l ( 0 )
Sim. Numérique – chapitre1- 5b

Syntaxe : transtypage
Nouvelle syntaxe pour le transtypage des variables (casting)

float x ;
in t i ;
i =( in t ) x ; // t r a n s t y p a g e à l a C d u n r é e l en e n t i e r

float x ;
in t i ;
i=int ( x ) ; // t r a n s t y p a g e à l a C++ ( f o n c t i o n n e l )

Ne s’applique aux types dérivés (pointeur)

f l o a t ∗x ;
in t ∗ i ;
i =( in t ∗ ) ( x ) ; // p o i n t e u r : t r a n s t y p a g e à l a C

Nouveaux opérateur en C++ : static_cast, dynamic_cast


Sim. Numérique – chapitre1- 6
Allocation dynamique
En C : utilisation de malloc, free, realloc
nécessite de connaître la taille d'un bloc élémentaire sizeof
En C++, introduction des opérateurs new et delete
pas d’opérateur de réallocation !
{double ∗pX, ∗ pTab ;
int l g =10;
pX=new double ; // p o i n t e u r s u r un d o u b l e
pTab=new double [ l g ] ; // p o i n t e u r s u r un d ou b l e ,
. . . // pr em i e re c a s e du t a b l e a u
delete pX ; // d é s a l l o c a t i o n
delete [ ] pTab ;
}

Noter la syntaxe particulière delete [] pTab


delete pTab peut provoquer des erreurs bizarres !

Sim. Numérique – chapitre1- 7

Opérateur de résolution ::
Nouvel opérateur de résolution ::
permettant de faire référence à une variable externe à un bloc
...
double x ; // v a r i a b l e EXTERNE

void f u n c ( )
{double x ; // x v a r i a b l e LOCALE
x =:: x ; // : : x f a i t r e f e r e n c e
// à l a v a r i a b l e e x t e r n e
...
}

permet de gérér des cas d’homonymie, à éviter !


utiliser en conjonction avec namespace

Sim. Numérique – chapitre1- 8


Espace de noms, namespace
Le C++ introduit le concept d’espace de noms (namespace)
regroupement de blocs de code

namespace moi
{double p i = 3 . 1 4 1 5 9 2 6 ; }

int main ( )
{ f l o a t p i = 3. 1 41 5 ;
double dp i=moi : : p i ; // p i d é f i n i dans moi
}

using namespace moi ;

permet de faire référence à pi sans ajouter moi::

std nom de l’espace de la librairie standard


Sim. Numérique – chapitre1- 9

Les références
Le C++ introduit le concept (majeur) :
référence = alias de pointeur
pointe une zone mémoire sans « déréférencement » (&)

déclaration : type & identificateur= …


doit obligatoirement être initialisée
int i ;
int &j=i ; // r é f é r e n c e s ur l ’ e n t i e r i
i =3; // a f f e c t a t i o n de i
p r i n t f ( ” j=%i \n” , j ) ; // i m p r e s s i o n d ’ une r é f é r e n c e
int &k ; //ERREUR de c o m p i l a t i o n

Impression : j= 3
j est une variable avec un comportement de pointeur
Sim. Numérique – chapitre1- 10
Passer une référence en argument
On peut transmettre une référence dans une fonction :
void f u n c t i o n a j o u t e 1 ( double & x ) {x=x +1;}

int main ( )
{double x=−1;
ajoute1 (x ) ;
}

évite de transmettre un pointeur :


void f u n c t i o n a j o u t e 1 ( double ∗ x ) {∗x=(∗x )+1;}

int main ( )
{double x=−1;
a j o u t e 1 (&x ) ; // t r a n s m i s s i o n du p o i n t e u r s u r x
}

Ne pas confondre int x; &x pointeur et int &x; x référence


Sim. Numérique – chapitre1- 11

Notion de left value


Une left value (lvalue) est une variable que l’on peut mettre
à gauche d’un signe = , elle peut donc recevoir une valeur
Une référence est une left value si l’objet pointé est
modifiable (on peut rendre l’objet pointé non modifiable avec const )

void f u n c t i o n a j o u t e 1 ( const double & x ) {x=x +1;}

int main ( )
{double x=−1;
ajoute1 (x ) ;
}

Erreur à la compilation : const double & modifiée

Passage par référence équivalent au passage par pointeur


Intéressant pour les gros objets et plus sûr
Sim. Numérique – chapitre1- 12
Usage de const
const permet de protéger une variable en écriture
légère différence entre C et C++ :
en C : extern const int N=5;
en C++ : static const int N=5;
pointeur et référence constante

const double * p pointeur sur un double constant

double const * p pointeur constant sur un double

const double & r référence et objet pointé constants

double const & r même signification

double & const r une référence est constante par definition

Sim. Numérique – chapitre1- 14

Retourner une référence


On peut retourner une référence et dans certains cas c'est
impératif !
double vec [ 1 0 ] ;
double& elemen t ( int i ) { return vec [ i − 1 ] ; }

int main ( )
{ for ( int i =1; i <=10; i ++) el ement ( i )= i ; }

element(i) est une réference (left value) et permet de modifier vec[i-1]

double element ( int i ) { return vec [ i − 1 ] ; }

permet seulement de lire vec[i-1]

Le retour par référence n’induit pas de recopie de l’objet pointé


contrairement au retour par valeur
Sim. Numérique – chapitre1- 4
Retour d'une référence : piège !
Il ne faut pas retourner une référence sur une variable locale
qui est détruite à la sortie de la fonction
double & f ( double x )
{double y=1;
return y ;
}
int main ( )
{double z=f ( 1 ) ;
}

erreur de compilation avec Bc++ (Borland)


avertissement avec gcc et résultat ok !

Utiliser les retours par référence avec précaution !

Sim. Numérique – chapitre1- 15

Définition des fonctions


C++ offre de nouvelles options dans la définition des fonctions

Valeur par défaut des arguments

Surcharge des fonctions

Nombre variable d'arguments

Inlining

Sim. Numérique – chapitre1- 16


Valeur par défaut des arguments
On peut préciser des valeurs par défaut des derniers
arguments d'une fonction :
double f o n c ( double x , int de r =0)
{switch ( der )
{ case 0 : . . . // c a l c u l de la valeur
case 1 : . . . // c a l c u l de l a d é r i v é e
}
}
int main ( )
{double f , d f ;
f =f o n c ( 0 ) ; // c a l c u l de l a v a l e u r en 0
d f=f o n c ( 0 , 1 ) ; // c a l c u l de l a d é r i v é e en 0
}

possible avec plusieurs arguments par défaut mais ordre à respecter !

double f o n c ( double x , in t de r =0,double par =0) { . . . }

Sim. Numérique – chapitre1- 17

Surcharge des fonctions


C++ différencie les fonctions suivant leur nom
et leurs arguments d’entrée (signature d’une fonction)
On parle de surcharge générique des fonctions
double f o n c ( double x , double y ) { . . . . } // v e r s . r é e l l e
int f o n c ( in t x , int y ) { . . . . } // v e r s . e n t i è r e

int main ( )
{double r=f o n c ( 0 . , 0 . ) ; // a p p e l de l a v e r s i o n r é e l l e
r=f o n c ( 0 , 0 ) ; // a p p e l de l a v e r s i o n e n t i è r e
}

Ne différencie pas l'argument de retour !

double f o n c ( double x , double y ) { . . . . }


int f o n c ( double x , double y ) { . . . . }

erreur de compilation (redéclaration)


Sim. Numérique – chapitre1- 18
Nombre d'arguments variable
On peut indiquer un nombre d'arguments variable à l'aide :

double f o n c ( double x , . . . ) { }

Le complilateur n'analyse pas le type et le nombre d'arguments !


Les arguments sont stockés dans la variable va_list
On y accède via les fonctions :

Va_start()
Va_arg()
Va_end())

Il est impossible de récupérer le type des variables transmises

programmation lourde, pas de contrôle et finalement peu d’intérêts


hormis la fonction main

Sim. Numérique – chapitre1- 19

Fonctions inline
Une fonction inline est une fonction dont le corps est substitué
à son appel dans le code (action du compilateur)
Evite de passer par la pile et de brancher le code en cours d'exécution
(plus rapide). Surtout intéressant pour les petites fonctions
En C, on utilise une macro :
#define c a r r e ( y ) ( y∗y )
double a =2;
double c=c a r r e ( a +1); // r e t o u r n e l a v a l e u r 5 ! !
Code généré après substitution : a+1*a+1 = 2*a +1

En C++, on on utilise l'attribut inline à la fonction :


i n l i n e double c a r r e ( double y ){ return y∗y ; }

Utilisation plus sure


Sim. Numérique – chapitre1- 20
Entrées/Sorties (flux)
Entrées/sorties standard en C : printf() et scanf()
Nouvel opérateur en C++ : opérateurs de flux >> et <<
flux standards (entête <iostream>) :
cin : flux d’entrée standard (clavier)
cout : flux de sortie standard (écran)
#include <i o s t r e a m >
#include <s t r i n g >
using namespace s t d ;
int main ( )
{double p i = 3. 1 41 59 26 ; int i =3, j ;
s t r i n g msg=” i m p r e s s i o n : \ n” ;
cout<<msg<<pi<<” , ”<<i ; // é c r i t u r e écr an
ci n >>j ; // l e c t u r e c l a v i e r
}

Les flux (stream) sont des classes


Sim. Numérique – chapitre1- 21

Entrées/Sorties (flux)
Impression simple en format libre
Les opérateurs de flux gèrent les types primaires
Possibilités de formatage
Extensions de ces opérateurs à des objets quelconques
Lecture/Ecriture dans un fichier à l'aide d'un flux fstream :
#include <f st r e am >
#include <s t r i n g >
using namespace s t d ;
I n t main ( )
{ f s t r e a m s o r t i e ( ” f i c h i e r s o r t i e ” ) ; // c r é a t i o n
double p i = 3. 1 41 59 26 ; int i =3;
s t r i n g msg=” i m p r e s s i o n : \ n” ;
s o r t i e <<msg<<pi<<” , ”<<i ; // é c r i t u r e f i c h i e r
sortie . close (); // f e r m e t u r e f i c h i e r
Sim. Numérique – chapitre1- 22
Récapitulatif
Nombreuses améliorations et extensions sémantiques

Utliser les versions C++, plus simples et robustes :

commentaires
allocation dynamique
surcharge des fonctions
arguments par défaut
passage par référence
inlining des fonctions
flux d’entrée/sortie

Sim. Numérique – chapitre1- 23