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

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 %ld\n",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érenceslong 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

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érenceschar &f(void){

char let='x';return let;

}

char &f(char t){

return t;}

char &f(char &t){

return t;}

let créée iciet 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 :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_intvoid f(int,double); f_int_doublevoid 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érencesvoid 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 –DsymboleZ:\> -DDEBUGg++ -c monprog.cpp

ouvrons le fichier complex.h de Dev

fonctions inline

mécanisme d'appel de fonction:

overhead (temps supplémentaire) car :calcul des argumentsplacement sur la pileplacement de l'@ de retour de la fonctionsaut à la fonction

la fonction est exécutéeplacement de la valeur de retour sur la pilesaut à 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*xint main(){

long a=CARRE(2+4);printf("%ld",a);

}

affiche : 14 car calcul de 2+4*2+4

fonctions inlineen C++ :inline long carre(long);

int main(){

cout << carre(2+4) << endl;}

long carre(long t){

return t*t;}

affiche 36

Allocation dynamiquemalloc() 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 deletenew : 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