Le langage C Langage orient objet Exprience des

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 << "bonjour" << endl; endl remplace le ‘n’ du C : passage à la ligne

Entrées/sorties 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 : long a; printf("saisir a: "); scanf("%ld", &a); printf("%ld au carre vaut %ldn", a, a*a); en C++ : long a; 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 : 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; référence vers rien long &j; long &j=4; référence vers une constante long &j=i+2; référence vers une expression long &j=i; j=k;

Références passage de paramètres 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 adresse quelles précautions prendre ?

Références char &f(void) { char let='x'; let créée ici et détruite ici… return let; } char &f(char t) { return t; } t créée ici et détruite ici… char &f(char &t) { return t; 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 : 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); void f(int, double); void f(double, int); f_int_double 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& mais on ne peut plus appeler f_int ni f_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 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++ : inline long carre(long); int main() { cout << carre(2+4) << endl; } long carre(long t) { return t*t; } affiche 36

Allocation dynamique malloc() et calloc() remplacées informations fournies redondantes : int *p; long nb; ah, ca on le saura que c'est un int ! nb=12; p=(int *)malloc(nb*sizeof(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 sans les changer mais apporte beaucoup pour : les fonctions les structures