C++ : variables

1. C++ : variables • Déclaration de variables • Allocation statique et durée de vie • Allocation dynamique

2. Déclaration de variables (1) La syntaxe générale d'une déclaration de variable est de la forme : <attribut> <type> <nom> <type> et <nom> sont obligatoires. • Ex : int indice; unsigned int compteur; • Les types de base sont : • char : entier sur 1 octet [-128; 127] • short : entier court sur 2 octets [-32768; 32767] • int : entier sur 4 octets • long : entier sur 4 octets • float : réel simple précision (4 octets) • double : réel double précision (8 octets) • ‡bool : booléen, prend la valeur true ou false • L'attribut apporte un complément au type • unsigned : type non signé • Ex : unsigned short // [0-65535] • const : la variable n'est pas modifiable • Ex : const int a = 4; • Alias de type • typedef <type> <alias> • Ex: typedef unsigned short USHORT ‡ : propre au C++

3. Déclaration de variables (2) • Type enum • enum direction {nord, est, sud, ouest}; • enum direction vent = sud; • Le compilateur associe à chaque direction un entier (int) à partir de 0 (par défaut). • Type pointeur • Le C et le C++ permettent d'avoir accès aux adresses mémoires où sont stockées les variables. Un pointeur est une variable spécialisée permettant de stocker et de manipuler ces adresses. • L'adresse d'une variable a s‘écrit &a. La taille de &a dépend de la machine. • L'accès à la donnée stockée à l'adresse pa s'obtient par *pa. int *pa;// pa est un pointeur sur une variable de type int int a = 4; // a est un entier initialisé à la valeur 4 pa = &a;// initialisation du pointeur par l'adresse de a std::cout << *pa << std::endl;// affiche 4 à l'écran • Un pointeur peut être initialisé à une valeur nulle : • float *p; • p = NULL; • Type void • C’est un pseudo-type qui signifie “rien”. • S’utilise comme type de pointeur ou comme type de retour d’une fonction. • Tableaux • char t[10]; // tableau de 10 caractères • double u[10][20]; // tableau à 2 dimensions • Attention : les indices d'un tableau commencent à 0. ‡ : propre au C++

4. Durée de vie d'une variable statique • Rappel : en C et C++, toute variable doit être déclarée. • On appelle portée de nom la portion du code où le nom d'une variable est connu. Elle commence à la ligne de déclaration et se termine à la fin du bloc dans lequel elle est définie (marqué par }). • Par conséquent, si la variable est de type complexe, l'objet est systématiquement détruit à la fin de la portée de nom. • La déclaration d'une variable locale "n" cache des déclarations de "n" dans • des blocs englobant • des déclarations globales de n (à n'utiliser qu'exceptionnellement). • l'interface de la classe à laquelle la fonction appartient, d'où l'intérêt d'utiliser une nomenclature spécifique pour les données membres • Cas particulier : une variable de type static est connue pendant toute la durée du programme. void MaFonction() { int i; // i est connu jusqu'à la fin de la fonction for (i = 0; i < 10; i++) { int j = 2*i; // j est connu uniquement dans la boucle for std::cout << j << std::endl; } }

5. Gestion dynamique de la mémoire : new / delete • L’allocation dynamique permet de s’affranchir des règles de portée de nom imposées par l'instanciation statique. C’est alors au programmeur de gérer la mémoire via • - l’utilisation des pointeurs • - les opérateurs new et delete • L’opérateur new permet d’instancier un objet : il réserve la place mémoire pour le stocker, engendre l’appel du constructeur et retourne l’adresse mémoire de la zone réservée • L’opérateur delete engendre l’appel du destructeur puis libère la place mémoire • Les opérateurs new et delete s’appliquent aussi bien aux types simples qu’aux types complexes (classes).

6. Type simple Instanciation dynamique vs statique : synthèse Instanciation dynamique Instanciation statique int *p0; p0 = new int; *p0 = 421; // p0 pointe sur un entier initialisé a 421 delete p0; int n = 421; float *tab; tab = new float[5]; // Réserve un tableau de 5 réels for (int i = 0; i < 5; i++) tab[i] = 1.4 * i; delete[] tab; float tab[5]; for (int i = 0; i < 5; i++) tab[i] = 1.4 * i; delete[] tab; Tableau // Appel du constructeur par défaut Cercle *p0 = new Cercle ; delete p0; // S’il existe un constructeur avec les arguments correspondants Cercle *p1 = new Cercle(arg1, arg2, arg3); p1->deplace(10, 20); delete p1; // Tableau de n objets de type Cercle Cercle *p2 = new Cercle [n]; delete[] p2; // Appel du constructeur par défaut : Cercle c0; // S’il existe un constructeur avec les arguments correspondants Cercle c1(arg1, arg2, arg3) c1.deplace(10, 20); // Tableau de 10 objets de type Cercle Cercle c2[10]; Type complexe