L'allocation dynamique

1

long monNombre = 0;

Selon le type de variable que vous demandez à créer (char, int, double, float...), vous avez besoin de plus ou moins de mémoire.

En effet, pour stocker un nombre compris entre -128 et 127 (un char), on n'a besoin que d'un octet en mémoire (c'est tout petit ).
En revanche, un int occupe généralement 4 octets en mémoire. Quant au double, il occupe 8 octets.

Le problème est... que ce n'est pas toujours le cas. Cela dépend de votre ordinateur : peut-être que chez vous un int occupe 8 octets, qui sait ?
Notre objectif ici est de vérifier quelle taille occupe chacun des types sur votre ordinateur.

Il y a un moyen très facile pour savoir cela : utiliser l'opérateur sizeof().
Contrairement aux apparences, ce n'est pas une fonction mais une fonctionnalité de base du langage C. Vous devez juste indiquer entre parenthèses le type que vous voulez analyser.
Pour connaître la taille d'un int, on devra donc écrire :

Code : C

A la compilation, cela sera remplacé par un nombre : le nombre d'octets que prend int en mémoire. Chez moi, sizeof(int) vaut 4, ce qui signifie que int occupe 4 octets. Chez vous, c'est probablement la même valeur, mais ce n'est pas une règle. Testez, vous verrez
Vous pouvez faire des printf pour afficher cela :

Code : C

Chez moi, cela affiche :

Code : Console

Je n'ai pas mis tous les types que nous connaissons, je vous laisse le soin de tester vous-même la taille des autres types
Vous remarquerez que long et int occupent la même place en mémoire. Créer un long revient donc ici exactement à créer un int, cela prend 4 octets dans la mémoire.






Oui ! sizeof marche aussi sur les structures !

Code : C

Code : Console

Plus une structure contient de sous-variables, plus elle prend de mémoire. Terriblement logique n'est-ce pas ?

Une nouvelle façon de voir la mémoire

Jusqu'ici, mes schémas de mémoire étaient encore assez imprécis. On va enfin pouvoir les rendre précis et corrects maintenant qu'on connaît la taille de chacun des types de variables (c'est pas trop tôt )

Si on déclare une variable de type long :

Code : C

... et que sizeof(long) indique 4 octets sur notre ordinateur, alors la variable occupera 4 octets en mémoire !

Supposons que la variable nombre soit allouée à l'adresse 1600 en mémoire. On aurait alors le schéma suivant :




Ici, on voit bien que notre variable "nombre" de type long qui vaut 18 occupe 4 octets dans la mémoire.
Elle commence à l'adresse 1600 (c'est son adresse) et termine à l'adresse 1603. La prochaine variable ne pourra donc être stockée qu'à partir de l'adresse 1604 !

Si on avait fait la même chose avec un char, alors on n'aurait occupé qu'un seul octet en mémoire :



Imaginez maintenant un tableau de long !
Chaque "case" du tableau occupera 4 octets. Si notre tableau fait 100 cases :

Code : C

Alors on occupera en réalité 4 * 100 = 400 octets en mémoire



Bien sûr ! La place en mémoire est réservée, aucun autre programme n'a le droit d'y toucher (à part le vôtre). Une fois qu'une variable est déclarée, elle prend immédiatement de la place en mémoire.


Notez que si on crée un tableau de type "Coordonnees" :

Code : C

... on utilisera (allez c'est facile ) : 8 * 100 = 800 octets en mémoire.

Il est important de bien comprendre ces petits calculs pour la suite du chapitre.
C'est de la multiplication de niveau Primaire ça

Rentrons maintenant dans le vif du sujet.
Le but du chapitre, c'était quoi justement ?

Ah oui : apprendre à demander de la mémoire manuellement.
On va avoir besoin d'inclure la librairie <stdlib.h> (si vous avez suivi mes conseils, vous devriez avoir inclus cette librairie dans tous vos programmes de toute façon ).

Cette librairie contient 2 fonctions dont nous allons avoir besoin :

• malloc ("Memory ALLOCation", c'est-à-dire "Allocation de mémoire") : demande au système d'exploitation la permission d'utiliser de la mémoire.
• free ("Libérer") : permet d'indiquer à l'OS que l'on n'a plus besoin de la mémoire qu'on avait demandée. La place en mémoire est libérée, un autre programme peut maintenant s'en servir au besoin.

Quand vous faites une allocation manuelle de mémoire (ce qu'on va apprendre à faire maintenant), vous devez toujours suivre ces 3 étapes :

1. Appeler malloc pour demander de la mémoire
2. Vérifier la valeur retournée par malloc pour savoir si l'OS a bien réussi à allouer la mémoire.
3. Une fois qu'on a fini d'utiliser la mémoire, on doit la libérer avec free. Si on ne le fait pas, on s'expose à des fuites de mémoire, c'est-à-dire que votre programme risque au final de prendre beaucoup de mémoire alors qu'il n'a en réalité plus besoin de tout cet espace.

Tiens, ces 3 étapes ça vous rappelle pas le chapitre sur les fichiers ça ?
Ben moi si



Nous allons maintenant étudier la fonction malloc.

malloc : demande d'allocation de mémoire

Le prototype de la fonction malloc est assez comique vous allez voir :

Code : C

La fonction prend un paramètre : le nombre d'octets à réserver. Ainsi, il suffira d'écrire sizeof(long) dans ce paramètre pour réserver suffisamment d'espace pour stocker un long.

Mais c'est surtout ce que la fonction renvoie qui est curieux : elle renvoie un... void*
Si vous vous souvenez du chapitre sur les fonctions, je vous avais dit que "void" signifiait "vide" et qu'on utilisait ce type pour indiquer que la fonction ne retournait aucune valeur.
Alors ici, on aurait une fonction qui retourne un "pointeur sur vide" ?

En voilà une bien bonne !
Ces programmeurs ont décidemment un sens de l'humour très développé



Oui oui j'y viens Je me rappelle juste la première fois que j'ai vu le prototype de malloc, je suis resté la bouche ouverte un petit moment devant mon écran avant de comprendre

En fait, cette fonction renvoie un pointeur indiquant l'adresse que l'OS a réservé pour votre variable. Si l'OS a trouvé de la place pour vous à l'adresse 1600, la fonction renvoie donc un pointeur contenant l'adresse 1600.
Le problème, c'est que la fonction malloc ne sait pas quel type de variable vous cherchez à créer. En effet, vous ne lui donnez qu'un paramètre : le nombre d'octets en mémoire dont vous avez besoin. Si vous demandez 4 octets, ça pourrait aussi bien être un int qu'un long par exemple !

Comme malloc ne sait pas quel type elle doit retourner, elle renvoie le type void*. Ce sera un pointeur sur n'importe quel type. On peut dire que c'est un pointeur universel.


Passons à la pratique. Si je veux m'amuser (hahem) à créer manuellement une variable de type long en mémoire, je devrai indiquer à malloc que j'ai besoin de sizeof(long) octets en mémoire.
Je récupère le résultat du malloc dans un pointeur sur long.

Code : C

A la fin de ce code, memoireAllouee est un pointeur contenant une adresse qui vous a été réservée par l'OS, par exemple l'adresse 1600 (pour reprendre mes schémas de tout à l'heure).

Tester le pointeur

La fonction malloc a donc renvoyé dans notre pointeur memoireAllouee l'adresse qui a été réservée pour vous en mémoire.
2 possibilités :

• Si l'allocation a marché, notre pointeur contient une adresse.
• Si l'allocation a échoué, notre pointeur contient l'adresse NULL.

Il est peu probable qu'une allocation échoue, mais cela peut arriver. Imaginez que vous demandiez à utiliser 34 Go de mémoire vive, il y a très peu de chances que l'OS vous réponde favorablement

Il est néanmoins recommandé de tester si l'allocation a marché. On va faire ceci : si l'allocation a échoué, c'est qu'il n'y avait plus de mémoire de libre (c'est un cas critique). Dans un tel cas, le mieux est d'arrêter immédiatement le programme parce qu'il ne pourra pas continuer convenablement de toute manière.

On va utiliser une fonction standard qu'on n'avait pas encore vue jusqu'ici : exit(). Elle arrête immédiatement le programme. Elle prend un paramètre : la valeur que le programme doit retourner (ça correspond au return du main()).

Code : C

Si le pointeur est différent de NULL, le programme peut continuer, sinon il faut afficher un message d'erreur ou même mettre fin au programme, parce qu'il ne pourra pas continuer correctement s'il n'y a plus de place en mémoire.

free : libérer de la mémoire

Tout comme on utilisait la fonction fclose pour fermer un fichier dont on n'avait plus besoin, on va utiliser la fonction free pour libérer la mémoire quand on n'en a plus besoin.

Code : C

La fonction free a juste besoin de l'adresse mémoire à libérer. On va donc lui envoyer notre pointeur, c'est-à-dire memoireAllouee dans notre exemple.
Voici le schéma complet et final, ressemblant à s'y méprendre à ce qu'on a vu dans le chapitre sur les fichiers :

Code : C

Exemple concret d'utilisation

On va faire quelque chose qu'on a appris à faire il y a longtemps : on va demander l'âge de l'utilisateur et on va le lui afficher.
La seule différence avec ce qu'on faisait avant, c'est qu'ici la variable va être allouée manuellement (on dit aussi dynamiquement) au lieu d'automatiquement comme auparavant. Alors oui, du coup, le code est un peu plus compliqué. Mais faites l'effort de bien essayer de le comprendre, c'est important :

Code : C

Code : Console




Revenons à notre code. On y a alloué dynamiquement une variable de type long.
Au final, ce qu'on a écrit revient exactement au même que d'utiliser la méthode "automatique" qu'on connaît bien maintenant :

Code : C

Code : Console

En résumé : il y a 2 façons de créer une variable, c'est-à-dire d'allouer de la mémoire. Soit on le fait :

• Automatiquement : c'est la méthode que vous connaissez et qu'on a utilisée jusqu'ici.
• Manuellement (= dynamiquement) : c'est la méthode que je vous enseigne dans ce chapitre.

Un peu plus compliquée... certes.
Mais inutile, non ! On est parfois obligé d'allouer manuellement de la mémoire, comme on va le voir maintenant

Pour le moment, on s'est servis de l'allocation dynamique uniquement pour créer une petite variable. Or en général, on ne se sert pas de l'allocation dynamique pour ça On utilise la méthode automatique qui est plus simple.

Quand a-t-on besoin de l'allocation dynamique me direz-vous ?
Le plus souvent, on se sert de l'allocation dynamique pour créer un tableau dont on ne connaît pas la taille avant l'exécution du programme.

Imaginons par exemple un programme qui stocke l'âge de tous les amis de l'utilisateur dans un tableau. Vous pourriez créer un tableau de long pour stocker les âges, comme ceci :

Code : C

Mais qui vous dit que l'utilisateur a 15 amis ? Peut-être qu'il en a plus que ça !
Lorsque vous rédigez le code source, vous ne connaissez pas la taille que vous devez donner à votre tableau. Vous ne le saurez qu'à l'exécution, lorsque vous demanderez à l'utilisateur combien il a d'amis.
L'intérêt de l'allocation dynamique est là : on va demander le nombre d'amis à l'utilisateur, puis on fera une allocation dynamique pour créer un tableau ayant exactement la taille nécessaire (ni trop petit, ni trop grand ). Si l'utilisateur a 15 amis, on créera un tableau de 15 long, s'il en a 28 on créera un tableau de 28 long etc.

Comme je vous l'ai appris, il est interdit en C de créer un tableau en indiquant sa taille à l'aide d'une variable :

Code : C

(Notez : ce code marche peut-être sur certains compilateurs mais uniquement dans des cas précis, il est recommandé de ne pas l'utiliser !)
L'avantage de l'allocation dynamique, c'est qu'elle nous permet de créer un tableau qui a exactement la taille de la variable nombreDAmis, et cela grâce à un code qui marchera partout !


On va demander au malloc de nous réserver nombreDAmis * sizeof(long) octets en mémoire :

Code : C

Ce code permet de créer un tableau de type long qui a une taille correspondant exactement au nombre de ses amis !



Voici ce que va faire le programme dans l'ordre :

1. On demande à l'utilisateur combien il a d'amis
2. On crée un tableau de long faisant une taille égale à son nombre d'amis (via malloc)
3. On demande l'âge de chacun de ses amis un à un, qu'on stocke dans le tableau
4. On affiche l'âge des amis pour montrer qu'on a bien mémorisé tout cela
5. A la fin, on n'a plus besoin du tableau contenant l'âge des amis : on le libère avec la fonction free.

Code : C

Code : Console

Ce programme est tout à fait inutile : il demande les âges et les affiche ensuite. J'ai choisi de faire cela car c'est un exemple "simple" (enfin si vous avez compris le malloc ).

Que je vous rassure, dans la suite du cours nous aurons l'occasion d'utiliser le malloc pour des choses plus intéressantes que le stockage de l'âge de ses amis

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

int main(int argc, char *argv[])
{
    long* pointeur = NULL;

    pointeur = malloc(sizeof(long));
    if (pointeur == NULL)
    {
        exit(0);
    }

    printf("Quel age avez-vous ? ");
    scanf("%ld", &pointeur);
    printf("Vous avez %ld ans\n", *pointeur);

    free(pointeur);
    

    return 0;
}

1

malloc(sizeof(int) * 25);