Vrai ou faux ? Une variable automatique de type tableau
int v[ /* ??? */ ]
peut avoir une taille quelconque.
Vrai ou faux ? Une variable automatique de type tableau
int v[ /* ??? */ ]
est limitée à une taille maximale
qui est identique pour toutes les plateformes d'exécution.
Vrai ou faux ? Une variable automatique de type tableau
int v[ /* ??? */ ]
est limitée à une taille maximale
qui est dépendante de la plateforme d'exécution.
Vrai ou faux ? Un tableau alloué dynamiquement est limitée à une taille maximale
qui est identique pour toutes les plateformes d'exécution.
Vrai ou faux ? Un tableau alloué dynamiquement est limitée à une taille maximale
qui est liée à la quantité de mémoire disponible sur la
plateforme d'exécution.
Vrai ou faux ? L'allocation dynamique a lieu dans la même zone mémoire
que les variables automatiques.
Vrai ou faux ? L'allocation dynamique a lieu dans une zone mémoire différente
de celle des variables automatiques.
Vrai ou faux ? L'allocation dynamique a lieu dans la zone mémoire nommée
la pile (
stack).
Vrai ou faux ? L'allocation dynamique a lieu dans la zone mémoire nommée
le tas (
heap).
Vrai ou faux ? Lorsqu'une allocation dynamique a lieu dans une fonction,
la mémoire en question est automatiquement libérée
à la sortie de cette fonction.
Vrai ou faux ? Lorsqu'une allocation dynamique a lieu dans une fonction,
la mémoire en question est automatiquement libérée
à la fin du programme.
Écrire
complètement la portion de code qui permet d'obtenir
dans une variable nommée
p
un seul entier alloué dynamiquement.
Écrire
complètement la portion de code qui permet d'obtenir
dans une variable nommée
p
un tableau de
2000 entiers alloué dynamiquement.
Écrire
complètement la portion de code qui permet d'obtenir
dans une variable nommée
p
un seul réel alloué dynamiquement.
Écrire
complètement la portion de code qui permet d'obtenir
dans une variable nommée
p
un tableau de
2000 réels alloué dynamiquement.
Dans cette portion de code,
y a-t-il un problème avec l'utilisation de
free() ?
Si oui, lequel ?
void *a=malloc(8000);
if(a==NULL)
{
abort();
}
free(a);
Dans cette portion de code,
y a-t-il un problème avec l'utilisation de
free() ?
Si oui, lequel ?
void *v=malloc(8000);
if(v==NULL)
{
abort();
}
int *a=(int *)v;
free(a);
Dans cette portion de code,
y a-t-il un problème avec l'utilisation de
free() ?
Si oui, lequel ?
Il y a un problème.
Le pointeur transmis à
free() ne correspond pas à un
bloc alloué dynamiquement.
(voir
cette section)
Dans cette portion de code,
y a-t-il un problème avec l'utilisation de
free() ?
Si oui, lequel ?
Il y a un problème.
Le pointeur transmis à
free() ne correspond pas à un
bloc alloué dynamiquement.
(voir
cette section)
Dans cette portion de code,
y a-t-il un problème avec l'utilisation de
free() ?
Si oui, lequel ?
int v[100];
int *a=v;
free(a);
Il y a un problème.
Le pointeur transmis à
free() ne correspond pas à un
bloc alloué dynamiquement.
(voir
cette section)
Dans cette portion de code,
y a-t-il un problème avec l'utilisation de
free() ?
Si oui, lequel ?
void *v=malloc(8000);
if(v==NULL)
{
abort();
}
int *a=((int *)v)+16;
free(a);
Il y a un problème.
Le pointeur transmis à
free() ne correspond pas exactement
au début du bloc alloué dynamiquement.
(voir
cette section)
Dans cette portion de code,
y a-t-il un problème avec l'utilisation de
free() ?
Si oui, lequel ?
void *v=malloc(8000);
if(v==NULL)
{
abort();
}
int *a=(int *)v;
free(v);
free(a);
Il y a un problème.
Les pointeurs
v et
a désignent la même adresse, donc
la seconde invocation de
free() tente de libérer un tableau
dynamique qui a déjà été libéré.
(voir
cette section)
Écrire
complètement la portion de code qui permet de
redimensionner un tableau dynamique désigné par une
variable nommée
p afin qu'il puisse désormais contenir
4000 entiers.
Écrire
complètement la portion de code qui permet de
redimensionner un tableau dynamique désigné par une
variable nommée
p afin qu'il puisse désormais contenir
4000 réels.
Dans cette portion de code,
y a-t-il un problème avec l'utilisation de
realloc() ?
Si oui, lequel ?
int *a=(int *)malloc(8000);
if(a==NULL)
{
abort();
}
a[16]=5;
a=(int *)realloc(a, 16000);
if(a==NULL)
{
abort();
}
a[16]+=8;
free(a);
Dans cette portion de code,
y a-t-il un problème avec l'utilisation de
realloc() ?
Si oui, lequel ?
int *a=(int *)malloc(8000);
if(a==NULL)
{
abort();
}
a[16]=5;
realloc(a, 16000);
a[16]+=8;
free(a);
Il y a un problème.
L'adresse renvoyée par
realloc() est ignorée.
Le redimensionnement a pu déplacer le tableau dynamique
initialement désigné par
a : son utilisation ultérieure
et sa libération peuvent donc échouer.
(voir
cette section)
Dans cette portion de code,
y a-t-il un problème avec l'utilisation de
realloc() ?
Si oui, lequel ?
int *a=(int *)malloc(8000);
if(a==NULL)
{
abort();
}
a[16]=5;
free(a);
a=(int *)realloc(a, 16000);
if(a==NULL)
{
abort();
}
a[16]+=8;
Il y a un problème.
Le tableau dynamique désigné par
a a été libéré avant d'être
redimensionné.
(voir
cette section)
Dans cette portion de code,
y a-t-il un problème avec l'utilisation de
realloc() ?
Si oui, lequel ?
int *a=(int *)malloc(8000);
if(a==NULL)
{
abort();
}
a+=16;
*a=5;
a=realloc(a, 16000);
if(a==NULL)
{
abort();
}
*a+=8;
free(a);
Il y a un problème.
Le pointeur transmis à
realloc() ne correspond pas exactement
au début du bloc alloué dynamiquement.
(voir
cette section)
En quoi la fonction
realloc() est-elle souvent plus
avantageuse que l'usage de la séquence : allouer un
nouveau bloc, y recopier l'ancien avant de libérer l'ancien ?
Si suffisamment d'espace libre existe juste après le bloc mémoire, il
restera au même emplacement et la coûteuse recopie des données n'aura
pas lieu.
(voir
cette section)
Lorsqu'un tableau dynamique doit mémoriser des éléments
dont le nombre n'est pas connu à l'avance,
quel est l'inconvénient d'augmenter systématiquement sa taille
selon de
très petits incréments ?
Si le tableau doit finalement mémoriser un très grand nombre
d'éléments, de très nombreuses réallocations seront nécessaires
pour atteindre la capacité utile.
(voir
cette section)
Lorsqu'un tableau dynamique doit mémoriser des éléments
dont le nombre n'est pas connu à l'avance,
quel est l'inconvénient d'augmenter systématiquement sa taille
selon de
très grands incréments ?
Si le tableau ne doit finalement mémoriser qu'un très petit nombre
d'éléments, le grand incrément réservera inutilement un très
grand espace mémoire.
(voir
cette section)
Lorsqu'un tableau dynamique doit mémoriser des éléments
dont le nombre n'est pas connu à l'avance,
quel est la stratégie raisonnable à adopter pour choisir la
taille de l'incrément pour redimensionner le tableau ?
Il faut commencer par de petits incréments et faire grandir
les incréments quand la taille du tableau augmente.
(voir
cette section)