Le C en 20 heures

La fonction malloc, déclarée dans stdlib.h permet de réserver un bloc mémoire au cours de l'exécution du programme.

Ainsi, malloc(N) fournit l'adresse d'un bloc en mémoire de N octets libres ou la valeur NULL (c'est-à-dire 0) s'il n'y a pas assez de mémoire.

Supposons que nous ayons besoin d'un bloc en mémoire pour un texte de moins de 4000 caractères.

1. nous créons un pointeur tab vers un caractère (char *tab).
2. nous exécutons l'instruction : tab = malloc(4000); qui fournit l'adresse d'un bloc de 4000 octets libres et l'affecte à tab.

S'il n'y a plus assez de mémoire, c'est la valeur NULL (c'est-à-dire 0) qui est affectée à tab.

Si nous souhaitons réserver de la mémoire pour des données d'un type dont la grandeur varie d'une machine / d'un système à l'autre, nous aurons besoin de la grandeur effective d'une donnée de ce type. Il faut alors utiliser l'opérateur sizeof afin de préserver la portabilité du programme :

• sizeof(<var>) : fournit la taille, en octets, de la variable <var>
• sizeof(<constante>) : fournit la taille de la constante <const>
• sizeof(<type>) : fournit la taille pour un objet du type <type>

Exemple :

Soit la déclaration des variables suivantes :

short tab1[10];
char tab2[5][10];

int x;
int *pNum;
printf("Introduire le nombre de valeurs :");
scanf("%d", &x);
pNum = malloc(x*sizeof(int));

Certains compilateurs imposent d'écrire

pNum = (int *) malloc(x*sizeof(int));

En effet, étant donné que malloc renvoie un pointeur quelconque (void *), nous devons convertir cette adresse par un cast en un pointeur sur un entier, d'où l'usage de (int *).

Voici d'autres exemples :

char * pointeur_sur_chaine;
char * pointeur_sur_float;
pointeur_sur_chaine = (char *) malloc(1000*sizeof(char));
pointeur_sur_float = (float *) malloc(10000*sizeof(float));

 Le programme suivant lit 20 phrases au clavier, recherche des blocs de mémoire libres assez grands pour la mémorisation et passe les adresses aux composantes du tableau phrases[]. S'il n'y a pas assez de mémoire pour une chaîne, le programme affiche un message d'erreur et s'interrompt avec le code d'erreur ‐1. Nous devons utiliser une variable d'aide phrase comme zone intermédiaire (non dynamique). Pour cette raison, la longueur maximale d'une phrase est fixée à 100 caractères(23).

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define LONGUEUR_MAX_PHRASE 100 /* longueur maximum d'une phrase */
#define NOMBRE_MAX_PHRASES 20   /* nombre maximum de phrases */
int main() {
   char phrase[LONGUEUR_MAX_PHRASE];
   char *phrases[NOMBRE_MAX_PHRASES];
   int i;
   for (i=0; i<NOMBRE_MAX_PHRASES; i++) {
      printf("Entrez une phrase SVP...");
      gets(phrase);
      /* Réservation de la mémoire */
      phrases[i] = (char *) malloc(strlen(phrase)+1);
      /* S' il y a assez de mémoire, ... */
      if (phrases[i]!=NULL) {
         /* copier la phrase à l'adresse renvoyée par malloc, ... */
         strcpy(phrases[i],phrase);
      }
      else {
         /* sinon faire une sortie "catastrophe" */
         printf("Attention! Plus assez place en mémoire !!! \n");
         exit(-1);
      }
   }
   return 0;
}

Lorsque nous n'avons plus besoin d'un bloc de mémoire que nous avons réservé à l'aide de malloc, nous pouvons le libérer à l'aide de la fonction free déclarée dans <stdlib.h>.

L'appel à free(<Pointeur>) libère le bloc de mémoire désigné par<Pointeur>. L'appel à la procédure n'a pas d'effet si le pointeur passé en paramètre possède la valeur zéro.

char * pointeur_sur_chaine;
pointeur_sur_chaine = (char *) malloc(1000*sizeof(char));
...
/* à présent, nous n'avons plus besoin de cette zone mémoire : */
free(pointeur_sur_chaine);
pointeur_sur_chaine=NULL;

Vous savez qu'une fonction n'est pas capable de modifier ses arguments :

#include <stdio.h>
void calcule_double (int x){
   x=x+x;
}
main () {
   int i=2;
   calcule_double(i);
   printf("i vaut à présent :%d",i);/* i vaut toujours 2 !!! */
}

La solution consiste donc à faire (voir le déroulé plus loin).

#include <stdio.h>
void calcule_double (int * pointeur_int){
   * pointeur_int = (* pointeur_int) +  (* pointeur_int);
}
main () {
   int i=2;
   calcule_double(&i);
   printf("i vaut à présent :%d",i);   /* i vaut bien 4 !!! */
}

Imaginons que pointeur_int se trouve en mémoire logé à l'adresse 20 et i à l'adresse 10 : 

À présent, déroulons le programme principal :

1. int i=2 : déclaration et initialisation de i à 2
2. calcule_double(&i) : appel de la fonction calcule_double, avec la valeur 10 (l'adresse de i)
3. void calcule_double (int * pointeur_int) : on lance cette fonction et  pointeur_int vaut donc 10

   

4. * pointeur_int = (* pointeur_int)+(* pointeur_int) : (* pointeur_int) pointe suri. L'ancienne valeur de i va être écrasée par la nouvelle valeur : 2+2
5. printf("i vaut à présent : %d", i) : on se retrouve avec 4 comme valeur de i.

Étudions le programme suivant dont le but est simplement de modifier la valeur de n :

#include <stdio.h> 
void saisie (int *pointeur);
int main() {
   int n;
   saisie(&n);
   printf("n vaut : %d",n);
   return 0;
}
void saisie (int *pointeur) {
   printf("Entrez un nombre :");
   scanf ("%d",pointeur);
}

Imaginons que pointeur se trouve en mémoire logé à l'adresse 100 et n à l'adresse 1000 : 

À présent, déroulons le programme :

1. int n : déclaration de n. Il vaut n'importe quoi vu qu'il n'a pas été initialisé !
2. saisie(&n) : appel de la fonction saisie, avec la valeur 1000 (l'adresse de n)
3. void saisie (int *pointeur) : pointeur vaut donc 1000
4. printf("Entrez un nombre :")
5. scanf("%d",pointeur) : la fonction scanf va stocker ce que l'utilisateur tape au clavier à partir de l'adresse mémoire 1000 (imaginons que l'on entre la valeur 42).
6. retour dans main, la valeur entrée (42) a été stockée à l'adresse 1000, donc dans n. Le programme affichera n vaut : 42