Les commentaires Entres/sorties avec cin , cout et cerr Intrts de cin , cout et cerr Les manipulateurs Les conversions explicites Dfinition de variables Variable de boucle Visibilit des variables Les constantes Constantes et pointeurs Les types composs Variables rfrences Allocation mmoire
LES COMMENTAIRES Le langage C++ offre un nouvelle faon dajouter des commentaires. En plus des symboles /* et */ utiliss en C, le langage C++ offre les symboles // qui permettent dignorer tout jusqu la fin de la ligne. Exemple : /* commentaire traditionnel sur plusieurs lignes valide en C et C++ */ void main() { // commentaire de fin de ligne valide en C++ #if 0 // une partie dun programme en C ou C++ peut toujours
// tre ignore par les directives au prprocesseur // #if .... #endif #endif }
Il est prfrable dutiliser les symboles // pour la plupart des commentaires et de nutiliser les commentaires C ( /* */ ) que pour isoler des blocs importants dinstructions.
ENTREES/SORTIES AVEC cin, cout ET cerr
Les entres/sorties en langage C seffectue par les fonctions scanf et printf de la librairie standard du langage C. Il est possible dutiliser ces fonctions pour effectuer les entres/sorties de vos programmes, mais cependant les programmeurs C++ prfrent les entres/sorties par flux (ou flot ou stream ). Trois flots sont prdfinis lorsque vous avez inclus le fichier dentte iostream.h : cout qui correspond la sortie standard cin qui correspond lentre standard cerr qui correspond la sortie standard derreur. Loprateur (surcharg) << permet denvoyer des valeurs dans un flot de sortie, tandis que >> permet dextraire des valeurs dun flot dentre. Exemple : #include <iostream.h> void main() { int i=123; float f=1234.567; char ch[80]="Bonjour\n", rep; cout << "i=" << i << " f=" << f << " ch=" << ch; cout << "i = ? "; cin >> i; // lecture dun entier cout << "f = ? "; cin >> f; // lecture dun rel cout << "rep = ? "; cin >> rep; // lecture dun caractre cout << "ch = ? "; cin >> ch; // lecture du premier mot dune chane cout << "ch= " << ch; // cest bien le premier mot ...
} /* rsultat de lexcution i=123 f=1234.57 ch=Bonjour i = ? 12 f = ? 34.5 rep = ? y ch = ? c++ is easy ch= c++ */
tout comme pour la fonction scanf, les espaces sont considrs comme des sparateurs entre les donnes par le flux cin. notez labsence de loprateur & dans la syntaxe du cin. Ce dernier na pas besoin de connatre ladresse de la variable lire.
INTERET DE cin, cout ET cerr
vitesse dexcution plus rapide : la fonction printf doit analyser lexcution la chane de formatage, tandis quavec les flots, la traduction est faite la compilation. vrification de type : pas daffichage erron #include <stdio.h> #include <iostream.h> void main() { int i=1234; double d=567.89; printf("i= %d d= %d !!!!!\n", i, d); // ^erreur: %lf normalement cout << "i= " << i << " d= " << d << "\n"; } /* Rsultat de lexcution ************ i= 1234 d= 5243 !!!!!!! i= 1234 d= 567.89 *******************************/
taille mmoire rduite : seul le code ncessaire est mis par le compilateur, alors que pour, par exemple printf , tout le code correspondant toutes les possibilits daffichage est mis. on peut utiliser les flux avec les types utilisateurs (surcharge possible des oprateurs >> et <<).
LES MANIPULATEURS Les manipulateurs sont des lments qui modifient la faon dont les lments sont lus ou crits dans le flot. Les principaux manipulateurs sont : dec oct hex endl setw(int n) setprecision(int n) setfill(char) flush Exemple : #include <iostream.h> #include <iomanip.h> void main() { int i=1234; float p=12.3456; cout << << << << "|" << setw(8) << setfill(*) hex << i << "|\n" << "|" setw(6) << setprecision(4) p << "|" << endl;
lecture/criture dun entier en dcimal lecture/criture dun entier en octal lecture/criture dun entier en hexadcimal insre un saut de ligne et vide les tampons affichage de n caractres affichage de la valeur avec n chiffres avec ventuellement un arrondi de la valeur dfinit le caractre de remplissage vide les tampons aprs criture
} /* rsultat de lexcution |*****4d2| |*12.35| */
LES CONVERSIONS EXPLICITES
En C++, comme en langage C, il est possible de faire des conversions explicites de type, bien que le langage soit plus fortement typ : double d; int i; i = (int) d;
Le C++ offre aussi une notation fonctionnelle pour faire une conversion explicite de type :
double d; int i; i = int(d);
Cette faon de faire ne marche que pour les types simples et les types utilisateurs. Pour les types pointeurs ou tableaux le problme peut tre rsolu en dfinissant un nouveau type : double d; int *i; typedef int *ptr_int; i = ptr_int(&d);
La conversion explicite de type est surtout utile lorsquon travaille avec des pointeurs du type void * .
DEFINITION DE VARIABLES En C++ vous pouvez dclarer les variables ou fonctions nimporte o dans le code. La porte de telles variables va de lendroit de la dclaration jusqu la fin du bloc courant. Ceci permet de dfinir une variable aussi prs que possible de son utilisation afin damliorer la lisibilit. Cest particulirement utile pour des grosses fonctions ayant beaucoup de variables locales. Exemple : #include <stdio.hlgt; void main() { int i=0; // dfinition dune variable i++; // instruction int j=1; // dfinition dune autre variable j++; // instruction int somme(int n1, int n2); // dclaration dune fonction printf("%d+%d=%d\n", i, j, somme(i, j)); // instruction }
VARIABLE DE BOUCLE On peut dclarer une variable de boucle directement dans linstruction for. Ceci permet de nutiliser cette variable que dans le bloc de la boucle. Exemple : #include <iostream.h> void main() { for(int i=0; i<10; i++) cout << i << ; // i nest pas utilisable lextrieur du bloc for } /* rsultat de lexcution 0 1 2 3 4 5 6 7 8 9 */
VISIBILITE DES VARIABLES
Loprateur de rsolution de porte :: permet daccder aux variables globales plutt quaux variables locales. #include <iostream.h> int i = 11; void main() { int i = 34; { int i = 23; ::i = ::i + 1; cout << ::i << " } cout << ::i << "
" << i << endl;
" << i << endl; } /* rsultat de lexcution 12 23 12 34
Lutilisation abusive de cette technique nest pas une bonne pratique de programmation (lisibilit). Il est prfrable de donner des noms diffrents plutt que de rutiliser les mmes noms.
En fait, on utilise beaucoup cet oprateur pour dfinir hors dune classe les fonctions membres.
LES CONSTANTES Les habitus du C ont lhabitude dutiliser la directive du prprocesseur #define pour dfinir des constantes. Il est reconnu que lutilisation du prprocesseur est une source derreurs difficiles dtecter. En C++, lutilisation du prprocesseur se limite aux cas les plus srs : inclusion de fichiers compilation conditionnelle. Le mot rserv const permet de dfinir une constante. Lobjet ainsi spcifi ne pourra pas tre modifi durant toute sa dure de vie. Il est indispensable dinitialiser la constante au moment de sa dfinition. Exemple : const int N = 10; // N est un entier constant. const int MOIS=12, AN=1995; // 2 constantes entires int tab[2 * N]; // autoris en C++ (interdit en C)
CONSTANTES ET POINTEURS Il faut distinguer ce qui est point du pointeur lui mme. La donne pointe est constante : const char *ptr1 = "QWERTY"; ptr1++; // autoris *ptr1 = A; // ERROR: assignment to const type
Le pointeur est constant :
char * const ptr2 = "QWERTY"; ptr2++; // ERROR: increment of const type *ptr2 = A; // autoris
Le pointeur et la donne sont constants :
const char * const ptr3 = "QWERTY"; ptr3++; // ERROR: increment of const type *ptr3 = A; // ERROR: assignment to const type
LES TYPES COMPOSES
En C++, comme en langage C, le programmeur peut dfinir des nouveaux types en dfinissant des struct , enum ou union. Mais contrairement au langage C, lutilisation de typedef nest plus obligatoire pour renommer un type. Exemple : struct FICHE { // dfinition du type FICHE char *nom, *prenom; int age; }; // en C, il faut ajouter la ligne : // typedef struct FICHE FICHE; FICHE adherent, *liste; enum BOOLEEN { FAUX, VRAI}; // en C, il faut ajouter la ligne : // typedef enum BOOLEEN BOOLEEN; BOOLEEN trouve; trouve = FAUX; trouve = 0; // ERREUR en C++ : vrification stricte des types trouve = (BOOLEEN) 0; // OK
VARIABLES REFERENCES En plus des variables normales et des pointeurs, le C++ offre les variables rfrences. Une variable rfrence permet de crer une variable qui est un "synonyme" dune autre. Ds lors, une modification de lune affectera le contenu de lautre.
int i; int & ir = i; // ir est une rfrence i int *ptr; i=1; cout << "i= " << i << " ir= " << ir << endl; // affichage de : i= 1 ir= 1 ir=2; cout << "i= " << i << " ir= " << ir << endl; // affichage de : i= 2 ir= 2 ptr = &ir; *ptr = 3; cout << "i= " << i << " ir= " << ir << endl; // affichage de : i= 3 ir= 3
Une variable rfrence doit tre initialise et le type de lobjet initial doit tre le mme que lobjet rfrence. Intrt : passage des paramtres par rfrence utilisation dune fonction en lvalue
ALLOCATION MEMOIRE Le C++ met la disposition du programmeur deux oprateurs new et delete pour remplacer respectivement les fonctions malloc et free (bien quil soit toujours possible de les utiliser).
Loprateur new Loprateur new rserve lespace mmoire quon lui demande et linitialise. Il retourne soit ladresse de dbut de la zone mmoire alloue, soit 0 si lopration choue. int *ptr1, *ptr2, *ptr3; // allocation dynamique dun entier ptr1 = new int; // allocation dun tableau de 10 entiers ptr2 = new int [10];
// allocation dun entier avec initialisation ptr3 = new int(10); struct date {int jour, mois, an; }; date *ptr4, *ptr5, *ptr6, d = {25, 4, 1952}; // allocation dynamique dune structure ptr4 = new date; // allocation dynamique dun tableau de structure ptr5 = new date[10]; // allocation dynamique dune structure avec initialisation ptr6 = new date(d);
Loprateur delete Loprateur delete libre lespace mmoire allou par new un seul objet, tandis que loprateur delete[] libre lespace mmoire allou un tableau dobjets. // libration dun entier delete ptr1; // libration dun tableau dentier delete[] ptr2;
Lapplication de loprateur delete un pointeur nul est lgale et nentraine aucune consquence facheuse (lopration est tout simplement ignore).
A chaque instruction new doit correspondre une instruction delete. Il est important de librer lespace mmoire ds que celui ci nest plus ncessaire. La mmoire alloue en cours de programme sera libre automatiquement la fin du programme.
La fonction set_new_handler Si une allocation mmoire par new choue, une fonction derreur utilisateur peut tre appele. La fonction set_new_handler , dclare dans new.h, permet de dsactiver la procdure standard (qui est de renvoyer zro) et dappeler votre fonction derreur. #include <iostream.h> #include <stdlib.h> // exit() #include <new.h> // set_new_handler() // fonction derreur dallocation mmoire dynamique void erreur_memoire( void) {
cerr << "\nLa mmoire disponible est insuffisante !!!" << endl; exit(1); } void main() { set_new_handler( erreur_memoire ); double *tab = new double [1000000000]; set_new_handler(0); // ractive la fonction derreur standard }
