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

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++

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++

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; }

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).

Instanciation dynamique vs statique : synthèse Instanciation statique int *p0; p0 = new int; *p0 = 421; // p0 pointe sur un entier initialisé a 421 delete p0; Type simple 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