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

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

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

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

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

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;

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

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

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 &

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

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

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 !

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

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

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 !

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

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 }

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.

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é

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

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.

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& !

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

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

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

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

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

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 !

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

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

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 !

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

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;

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