Examen 1 - pointeurs et allocation dynamique

Question 1

Données (Data segment

Answer 1

pour les variables globales et statiques

Question 2

Code (code segment)

Answer 2

pour le code compilé

Question 3

Tas (Heap)

Answer 3

pour l’allocation dynamique

Question 4

Pile (Stack)

Answer 4

pour les variables locales

Question 5

void UneFonction (int nombre3);
int nombre1;
void main()
{
Ennemi * e1;
e1 = new Ennemi;
UneFonction(7);
}
void UneFonction(int nombre3)
{
int nombre2;
}
cptInstance
nombre1
nombre2
nombre3
e1 (pointeur)
Pile
Tas
Code
Données
Main()
e1
(contenu)
class Ennemi
{
static int cptInstance;
// . . .
};

Answer 5

cptinstance et nombre 1 données
rien code
e1 (contenu) tas
nombre2 nombre3 e1(pointeur) pile

Question 6

(la taille d’un int)

Answer 6

4 octets

Question 7

transtyper l’adresse de a (un int*) en…. pour pouvoir visualiser le contenu de la mémoire un octet à la fois

Answer 7

pointeur de caractères
(unsigned char*)

Question 8

Passage par valeur

Answer 8

Supposons que l’on possède la déclaration de fonction suivante :
int doIt(int value){
{
return value+1;
}
Supposons que l’on fasse l’appel
int b = doIt(a);
En supposant que la variable value soit à l’emplacement mémoire 0x009efda8 on obtiendra lors
de l’appel de doIt le schéma mémoire suivant :
a
52 0 0 0
0x00effc08 0x00effc09 0x00effc0A 0x00effc0B
value
52 0 0 0
0x009efda8 0x009efda9 0x009efdaA 0x009efdaB
Nous obtiendrons deux emplacements mémoire distincts qui contiendront cependant les mêmes
valeurs

Question 9

Passage par référence

Answer 9

Lorsque l’on passe un paramètre par référence, on utilise l’adresse de l’original. Une fa çon
d’obtenir l’adresse de l’original est d’utiliser l’opérateur &.
int a = 52;
int* ptrA = &a;
Si l’on veut accéder ce qui se trouve à une adresse on utilise l’opérateur *.
int valeurDeA = *ptrA;
// Évidemment ici valeurDeA et a auront la même valeur soit 52

Question 10

ne fa çon
d’obtenir l’adresse de l’original

Answer 10

l’opérateur &

Question 11

Si l’on veut accéder ce qui se trouve à une adresse

Answer 11

l’opérateur *

Question 12

Si l’on exécute les instructions suivantes :
int a = 52;
int* ptrA = &52;
int* pValeur = ptrA + 1;

Answer 12

la valeur de pValeur sera celle de ptrA augmentée de 4 octets car ptrA est un pointeur de int
et un int occupe 4 octets en mémoire.

Question 13

int* pData;

Answer 13

// Ne pointe vers RIEN DE CONCRET. On ne veut pas faire cela.

Question 14

intialiser un pointeur

Answer 14

int* pData = new int;

Question 15

est alors possible d’accéder au contenu de pData pour y placer des infos ou pour lire le contenu

Answer 15

std::cout &laquo_space;*pData;
ou
*pData = 80;

Question 16

Si vous tentez de lire le contenu d ’un emplacement mémoire AVANT d’y affecter une valeur,…

Answer 16

le
contenu est indéterminé

Question 17

responsables de libérer la mémoire allouée avec new
lorsqu’elle n’est plus nécessaire.

Answer 17

delete pData; Le pointeur peut alors être réutilisé pour un autre emplacement mémoire mais le contenu
désormais pointé est indéterminé.

Question 18

void doIt()
{
int * pData = new int;
pData = 80;
}
void main()
{
doIt();
}

Answer 18

A la fin de l’exécution de la fonction doIt, la portée de la variable local pData sera terminée. La
variable sera libérée MAIS PAS L’ESPACE MÉMOIRE POINTÉ par pData. Cela causera une fuite de
mémoire

Question 19

chaque utilisation de new doit s’accompagner

Answer 19

d’un delete
correspondant.

Question 20

une fonction ou une méthode qui alloue la mémoire
est

Answer 20

généralement responsable de la libérer. En programmation objet, l’objet qui allouera de la
mémoire sera responsable de la libérer lorsque sa portée prendra fin.

Question 21

Allocation d’un tableau

Answer 21

int* pData = new int[10];

Question 22

Pour accéder à un élément d’un tableau

Answer 22

std::cout &laquo_space;pData[4];
est l’équivalent de
std ::cout &laquo_space;*(pData+4);

Question 23

Pour libérer un tableau

Answer 23

int* pData = new int[10];
// …
delete[] pData;

Question 24

Vous comprenez maintenant pourquoi les tableaux sont indexés à partir de 0 et non de 1

Answer 24

C’est
parce que l’indice correspond au décalage par rapport à l’adresse du tableau.

Question 25

int a = 5; //&a est

Answer 25

la référence (l’adresse) du premier
octet de la structure (ici, un entier)

Question 26

int * p; //variable de type

Answer 26

adresse pouvant recueillir la
référence (adresse) d’un entier stocké en mémoire p = &a;

Question 27

int * p = new int;

Answer 27

« allocation d’un bloc mémoire pouvant contenir un entier, la
variable p reçoit l’adresse du premier octet de ce bloc »
À ce stade-ci le bloc est créé en mémoire mais il contient une
donnée invalide (« junk »)

Question 28

int * p = new int;
*p = 52;
On utilise l’opérateur « * »

Answer 28

pour affecter une valeur du type qui a été
déclaré

Question 29

Statique

Answer 29

signifie que la mémoire pour ce tableau est allouée au moment de la compilation, pas dynamiquement pendant l’exécution.

Question 30

Type des éléments (int *) pour un tab

Answer 30

Chaque élément du tableau est un pointeur vers un entier.
Cela signifie que chaque élément peut stocker l’adresse mémoire d’un entier.

Question 31

initialiser un tab de pointeur

Answer 31

int* tab[10];

for (int i = 0; i < 10; i++) {
tab[i] = new int(0); // Alloue dynamiquement un int initialisé à 0
}

Question 32

int * tab[10];
int a = 12;
tab[0] = &a;
Rien de dynamique dans cette approche, rien à faire non plus
lorsqu’on n’a plus besoin de ce tableau (tout est sur la stack).

Answer 32

Ne surtout pas faire de delete sur tab[0], il ne réfère pas à une
allocation dynamique (l’exécution va planter)

Question 33

int * tab[10];
tab[0] = new int;
*tab[0] = 12 //même principe avec l’étoile

Answer 33

Cette fois-ci il y a un new: toutes les adresses stockées dans le
tableau vont pointer vers un bloc dynamique, il faut en faire la
suppression ! delete[] tab;
Ne fonctionne pas ici, cette instruction fonctionnait lorsqu’on avait
l’adresse du premier octet vers un tableau dynamique

Question 34

supression tab de pointeur

Answer 34

for(int j = 0; j < 10; j++)
{
delete tab[ j ]; //suppression de tous les blocs dynamiques
}

Question 35

Dans le cas d’une instance de classe, on veut accéder à des
méthodes ou propriétés de la classe
Sur une instance déclarée sur la stack,

Answer 35

nous connaissons déjà la
syntaxe avec l’opérateur d’accès « . » :
Ennemi e;
e.attaquer();

Question 36

En allocation dynamique pour acceder methode

Answer 36

on utilise simplement l’opérateur
d’accès « -> »
Ennemi * ptrEnnemi = new Ennemi();
ptrEnnemi->attaquer();
La dernière instruction est l’équivalent de
*(ptrEnnemi).attaquer();
Si pour une raison quelconque ptrEnnemi est null ou invalide,
l’exécution va s’arrêter avec une erreur de mémoire

Question 37

Destructeur

Answer 37

Le destructeur d’une classe (méthode spéciale préfixée du symbole
« ~ » est la dernière méthode appelée avant la suppression définitive
de l’instance en mémoire :

Question 38

void attaquerEnnemi()
{
Ennemi e;
e.attaquer();
int a = 38;
[…]
} ou est appeler destructeur (exemple stack)

Answer 38

à la sortie de cette méthode, la stack est libérée de la variable
locale « e », le destructeur de la classe Ennemi sera appelé.

Question 39

xemple (sur la heap) :
void attaquerEnnemi()
{
Ennemi * ptrEnnemi = new Ennemi();
ptrEnnemiattaquer();
delete ptrEnnemi; //Le destructeur de la classe
Ennemi est appelé ici;
int a = 38
[…]
}

Answer 39

you knooow

Question 40

Ennemi * tabEnnemis = new Ennemi[10]; comment utiliser methode ?

Answer 40

tabEnnemis[0].attaquer();
Il faut garder en tête que ce ne sont pas des pointeurs

Question 41

Ennemi * tabEnnemis[10]; comment utiliser methode ?

Answer 41

Cette fois-ci, on va stocker des adresses vers des instances de la
classe Ennemi
tabEnnemis[0]attaquer();
Cette fois-ci ce sont des pointeurs

Question 42

Une classe garde la référence d’une autre classe dans une
de ses variables Composition de classes

Answer 42

Habituellement on ne touche pas à cette référence, on
laisse la stack faire son travail ! Composition faible

Question 43

Composition de classes Une classe alloue dynamiquement une autre classe et
stocke l’adresse reçue dans une variable

Answer 43

Habituellement, la classe qui alloue la mémoire
s’occupe de la libérer Composition forte

Question 44

Le mode par référence permet de

Answer 44

passer la valeur originale d’une variable en paramètre à une méthode.
En plus d’éviter de prendre une copie indépendante souvent inutile, le passage par référence permet
3
aussi à cette méthode de modifier le paramètre reçu et donc la valeur initiale. C’est un peu l’équivalent du
mot clé ref en C#.

Question 45

utilité contructeur copie

Answer 45

Le problème est que les ennemies dans la classe héro ne sont pas copié en profondeur. La première cela
marche, mais ensuite lorsqu’il faut y ré-accéder le problème est que par défaut seul le premier ennemy est
copier car c’est là que pointe le pointeur.

Question 46

N’oubliez pas d’utiliser le modificateur override même s’il n’est pas strictement obligatoire. Au
fait, pourquoi doit-on le mettre s’il n’est pas obligatoire?

Answer 46

On doit le mettre pour signaler au compilateur que c’est une méthode hérité. Ainsi il pourra mieux
nous aider. De plus, cela rend le code plus lisible.

Question 47

int * ptrint1;
std::cout &laquo_space;*ptrint1;

Answer 47

pas initialisé, erreur rien au bout du pointeur

Question 48

int * ptrint2 = new int[3];
std::cout &laquo_space;ptrint2[3] &laquo_space;std::endl;

Answer 48

erreur, out of bound tableau 3 cases mais acces 4 eme element ?

Question 49

int * ptrint1;
std::couts«ptrintint1;

Answer 49

memoire non initilalisé

Question 50

int * ptrint4 = new int[10];
std::cout &laquo_space;*ptrint4 «std::endl;

Answer 50

affiche valeur premier element

Question 51

int * ptrint5 = new int[5];
for(int i = 0; i<5; i++){
ptrint5[i]=2*i;
}
std::cout&laquo_space;ptrint5[2] «std::endl;

Answer 51

4

Question 52

int * ptrint6 = new int[5];
for(int i = 0; i<5; i++){
ptrint6[i]=2*i;
}
std::cout&laquo_space;*(ptrint5+2) «std::endl;

Answer 52

4

Question 53

*ptab++

Answer 53

*ptab++ (post-incrémentation)

La valeur pointée par ptab est d'abord accédée.
Ensuite, le pointeur ptab est incrémenté.

Effet :

La valeur retournée est celle de l'emplacement initial.
Le pointeur ptab est modifié après avoir été déréférencé.

Exemple :

cpp
int tab[] = {1, 2, 3, 4, 5};
int *ptab = tab;
cout &laquo_space;*ptab++; // Affiche 1
cout &laquo_space;*ptab; // Affiche 2

Question 54

*++ptab

Answer 54

int tab[] = {1, 2, 3, 4, 5};
int *ptab = tab;

cout &laquo_space;*ptab; // Affiche 1
cout &laquo_space;*++ptab; // Affiche 2
cout &laquo_space;*ptab; // Affiche toujours 2
cout &laquo_space;*++ptab; // Affiche 3 *++ptab (pré-incrémentation)

Le pointeur ptab est d'abord incrémenté.
Ensuite, la valeur pointée par le nouveau ptab est accédée.

Effet :

Le pointeur ptab est modifié avant d'être déréférencé.
La valeur retournée est celle du nouvel emplacement pointé.

Question 55

vrai ou faux : pointeurs et references c la meme chose

Answer 55

faux, pointeur peut etre nul alors que une reference non, c’est un alias de la variable (varaible elle meme)
un pointeur peut changer de referer, la referance non, c tjrs la meme chose