le langage c++ langage orienté objet expérience des défauts/limites du c sécurité de codage...
TRANSCRIPT
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