Le langage C++ Langage orienté objet

Présentation au sujet: "Le langage C++ Langage orienté objet"— Transcription de la présentation:

1 Le langage C++ Langage orienté objet
Expérience des défauts/limites du C Sécurité de codage (compilateur)

2 C++ sur-ensemble du C Coder « à la C » avec compilateur C++ g++ CC
Visual Studio

3 Les entrées/sorties Flots d’E/S cin (C: stdin) cout (C: stdout)
cerr (C : stderr)

4 Entrées/sorties Opérateurs d’E/S plutôt que fonctions printf() et scanf() Exemple : affichage Diriger les sorties vers le flot de sortie cout cout << "bonjour" << endl; endl remplace le ‘\n’ du C : passage à la ligne

5 Entrées/sorties expression flot op données est de type flot
flot << données; (données vers flot) flot >> données; (obtenir les données depuis le flot) expression flot op données est de type flot possibilité d’enchaîner les E/S

6 Entrées/sorties en C : en C++ : long a; printf("saisir a:");
scanf("%ld",&a); printf("%ld au carre vaut %ld\n",a,a*a); en C++ : cout << "saisir a :"; cin >> a; // et hop, plus de format ni de & cout << a << "au carre vaut " << a*a << endl;

7 Variables définitions de variables à tout endroit du code
pas de retour au bloc de définition des variables durée de vie de la variable adaptée à son rôle

8 Variables exemple : for (long cpt=0; cpt < nb; cpt++) { double val;
instructions; } cpt et val n'existent que pour l'exécution de la boucle

9 Références alternative à l'utilisation des pointeurs
créer un alias pour une variable deux noms différents désignent la même variable (même adresse). opérateur &

10 Références syntaxe : pas de référence à une expression
type &nom_de_référence = variable; int i; int &j = i; pas de référence à une expression référence = pointeur dont on ne manipule que le contenu

11 Références long i; long k; long &j; long &j=4; long &j=i+2; long &j=i;
j=k; référence vers rien référence vers une constante référence vers une expression

12 Références passage de paramètres l'échange est effectif !
void f(long &a, long &b) { long tmp; tmp=a; a=b; b=tmp; return; } l'échange est effectif !

13 Références inconvénients :
impossible de distinguer un passage de références à l'appel long x, y; f(x,y); // par valeur ? par référence ? les arguments doivent être des variables

14 Références dangers : fonction retournant une référence
référence  adresse quelles précautions prendre ?

15 Références char &f(void) { char let='x'; return let; let créée ici }
char &f(char t) return t; char &f(char &t) let créée ici et détruite ici… t créée ici et détruite ici… t fait référence à une autre variable. ouf !

16 Arguments par défaut initialiser des arguments au niveau du prototype : valeurs prises si argument absent à l'appel liste des valeurs à partir des derniers arguments

17 Arguments par défaut prototype : utilisation :
void fonction(int, int=0, int=1); utilisation : void main() { int x,y; x=4; y=x+5; fonction(y); // fonction(y,0,1); fonction(2,x); // fonction(2,x,1); fonction(x,y,x+y); // ok, 3 arguments }

18 Arguments par défaut définition :
void fonction(int a, int b, int c) { cout << a << "," << b << "," << c; cout << endl; return; } Ne pas rappeler les valeurs par défaut.

19 Surcharge de fonctions
signature de fonction : carte d'identité auprès du compilateur en C : son nom en C++ : son nom + types des paramètres unicité de l'identité

20 Surcharge de fonctions
exemple prototype signature void f(int,int); f_int_int void f(int,double); f_int_double void f(double,int); f_double_int les 3 fonctions coexistent dans un programme

21 Surcharge de fonctions
erreur du compilateur si on ajoute : int f(int,int); le type de retour ne fait pas partie de la signature. choix de la fonction à l'appel.

22 Surcharge et références
le compilateur accepte la surcharge… void f(int&,int&); // connue comme f_int&_int& mais on ne peut plus appeler f_int_int ni f_int&_int& !

23 Surcharge et références
void main() { int i,j; int &k=i; f(i,j); // ambiguïté ! }

24 Utiliser des fonctions du C
incompatibilité des signatures ! indiquer que le langage d'origine est le C : extern "C" précédant le prototype. généralisable à tout un fichier .h

25 Utiliser des fonctions du C
symbole de langage à définir pour la compilation rappel : #ifdef / #ifndef / #define / #endif définir les symboles en ligne de commande : option –Dsymbole Z:\> g++ -c monprog.cpp -DDEBUG ouvrons le fichier complex.h de Dev

26 fonctions inline mécanisme d'appel de fonction:
overhead (temps supplémentaire) car : calcul des arguments placement sur la pile placement de de retour de la fonction saut à la fonction la fonction est exécutée placement de la valeur de retour sur la pile saut à de retour

27 fonctions inline désavantageux si : code de la fonction court
appels nombreux supprimer cet overhead en transformant l'appel de fonction en : expansion de code

28 fonctions inline expansion : remplace l'appel par le code de la fonction : programme plus volumineux similaire aux macros du C, mais vérifications faites par le compilateur sécurité accrue !

29 fonctions inline en C : #define CARRE(x) x*x int main() {
long a=CARRE(2+4); printf("%ld",a); } affiche : 14 car calcul de 2+4*2+4

30 fonctions inline en C++ : affiche 36 inline long carre(long);
int main() { cout << carre(2+4) << endl; } long carre(long t) return t*t; affiche 36

31 ah, ca on le saura que c'est un int !
Allocation dynamique malloc() et calloc() remplacées informations fournies redondantes : int *p; long nb; nb=12; p=(int *)malloc(nb*sizeof(int)); ah, ca on le saura que c'est un int ! tout-à-fait, Thierry !

32 Opérateurs new et delete
new : indiquer le type et le nombre de données à réserver. pour une seule valeur : double *p_doub; p_doub = new double; // allocation libérer la mémoire avec : delete p_doub; // libération

33 Opérateurs new[] et delete[]
tableaux dynamiques : char *txt; long taille; taille=42; txt = new char[42]; // allocation de 42 char // libération avec l'opérateur delete[] delete []txt;

34 mais encore… C++ utilise des instructions du C les tests les boucles
mais apporte beaucoup pour : les fonctions sans les changer les structures