Tableaux, pointeurs et allocation dynamique

Définition

Déclaration

1

int * ptrint;

Utilisations

• Un pointeur doit toujours être initialisé avant utilisation.

Initialisation

• Avec la valeur NULL :
  
  Code : C

  1	int * ptrint = NULL;

  
  Le pointeur NULL souvent sous la forme (void*)0 , est une macro déclarée dans stddef.h. Elle est utilisée pour des opérations exclusivement sur le type pointeur (affectation, comparaison...).
  
  
• Avec l'adresse d'une de nos variables déclarées.
  
  Code : C

  1 2	int variable; int * ptrint = &variable;

  
  Rappelez-vous de l'opérateur '&', qui permet d'avoir l'adresse mémoire d'un objet. Il s'utilise toujours accompagné du nom de l'objet que l'on souhaite connaitre son adresse mémoire.
  Avec cette initialisation, on est sûr que l'espace mémoire que notre pointeur indique, nous est alloué.
  
  
• En faisant une allocation dynamique (que nous allons voir plus loin dans ce tutoriel).
  
  Code : C

  1	int * ptrint = malloc(10);

Accéder à l'adresse pointée

1
2
3
4
5
6

int * ptrint;        //Déclaration du pointeur
int variable;        //Déclaration d'une variable

ptrint = &variable;  //Initialisation de notre pointeur

*ptrint = 10;        //On inscrit 10 à l'espace pointé par notre pointeur (en l'occurrence la variable).

Argument de fonctions : passage par valeur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

void ma_fonction(int n){  //Fonction appelée
      n = 10;
}

int main (void){                         //Fonction appelante
      int variable = 123;

      ma_fonction(variable);
      printf("La valeur de variable est %d\n",variable);

      return 0;
}

La valeur de variable est 123

Argument de fonctions : passage par adresse

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

void ma_fonction(int * ptrn){
      *ptrn = 10;    //On inscrit la valeur 10 à l'emplacement mémoire indiqué par ptrn
}

int main (void){
      int variable = 123;

      ma_fonction( &variable );                            //On appelle la fonction
      printf("La valeur de variable est %d\n",variable);

      return 0;
}

La valeur de variable est 10

Définition

Déclaration (syntaxe)

1

int tableau[10];

Utilisation

Initialisation

1
2

int tableau[3];
tableau = ....;

• L'utilisation des accolades {} :
  Code : C

  1	int tableau[4] = {15,2,14,23};

  
  Les cases de ce tableau qu'on vient de déclarer seront donc initialisées respectivement avec les valeurs 15, 2, 14 et 23. Vous remarquerez que le nombre de valeurs correspond à la taille de notre tableau (à savoir 4 éléments). Il est possible de n'initialiser qu'un certain nombre de cases dans ce tableau ainsi :
  Code : C

  1	int tableau[4] = {15,2};

  
  Ainsi nous aurons initialisé que les deux premières cases. Vous vous demandez peut être ce que deviennent les autres cases , elles sont toutes initialisées avec des 0 (zéros).
  
  En conséquence une initialisation à zéro de la première case uniquement, initialiserait tout notre tableau à zéro :
  Code : C

  1	int tableau[4] = {0};

  
  
• L'utilisation des accolades {} avec un tableau dont la taille n'est pas spécifiée :
  Code : C

  1	int tableau[] = {15,2,14,23};

  
  Deux choses très importantes à noter dans ce type de déclarations :
  1_ Le tableau sera alloué pour contenir le nombre d'éléments présents entre les accolades (en l'occurrence 4).
  2_ Le tableau sera initialisé avec ces éléments.
  
  Par conséquent, il ne faut pas mélanger cette déclaration avec l'initialisation type {0} :
  
  Code : C

  1	int tableau[] = {0};

  
  Car cela ne va allouer qu'une seule case. Erreur très courante dans le cas des chaines de caractères.
  
  
  Que faire pour n'initialiser que certaines cases dans le tableau ?
  
  
  Seul le standard C99 permet de faire ce genre d'initialisations, contrairement au C90.
  Code : C

  1	int t[10] = {[indice]=5,6};

  
  indice ici doit être remplacé par une valeur constante indiquant l'indice qu'on souhaite initialiser avec la valeur 5, il est évidemment obligatoire que cet indice soit inférieur à la taille du tableau.
  
  Pour se familiariser avec ce type d'initialisations prenons quelques exemples :
  
  Exemple 1:
  Code : C

  1	int t[10] = {2,3,[4]=5,6,9};

  
  résultat :
  

  2

  3

  0

  0

  5

  6

  9

  0

  0

  0

  
  
  Exemple 2:
  Code : C

  1	int t[10] = {[4]=5,6,[9]=9};

  
  résultat :
  

  0

  0

  0

  0

  5

  6

  0

  0

  0

  9

  
  
  Exemple 3:
  Code : C

  1	int t[10] = {2,3,[1]=5,[5]=6,[3]=9};

  
  résultat :
  

  2

  5

  0

  9

  0

  6

  0

  0

  0

  0

  
  Ce que je ne vous ai pas encore dit, est que si l'indice spécifié correspond à une case déjà initialisée, alors sa valeur sera écrasée par la nouvelle valeur (par le 5 dans cet exemple dans un premier temps) et toute les autres cases restantes à sa "droite" seront initialisées à 0; le même phénomène est constaté avec [3]=9, la case d'indice 3 sera initialisée à 9 alors que toutes les cases restantes seront mises à 0.
  Je vous propose de suivre les étapes de plus près :
  Etape 1 : Les deux premières cases sont initialisées à 2 et 3 (les autres ont pour le moment des valeurs indéterminées 'x').

  2

  3

  x

  x

  x

  x

  x

  x

  x

  x

  
  Etape 2 : la case d'indice 1 est initialisée à 5, et les cases restantes à droite sont initialisées à 0 jusqu'au prochain indice ([5]).

  2

  5

  0

  0

  0

  6

  x

  x

  x

  x

  
  Etape 3 : la case d'indice 3 est initialisée à 9, et les cases restantes à droite sont toutes initialisées à 0.

  2

  5

  0

  9

  0

  6

  0

  0

  0

  0

  
  
  Exemple 4:
  Code : C

  1	int t[10] = {1,[10]=5,6,[14]=9};

  
  résultat :
  Erreur de compilation, en effet, il est interdit de mettre un indicateur d'indice qui dépasse la taille de notre tableau.
  
  Exemple 5:
  Code : C

  1	int t[] = {1,[10]=5,6,[14]=9};

  
  résultat : Nous avons déclaré un tableau de type "incomplet"; en d'autres mots, un tableau dont la taille n'a pas encore été donnée. Ce tableau prendra donc la taille de l'initialisateur, et dans ce cas de figure, le tableau sera de taille 15 car le plus grand indice est le 14 (les indices seront donc entre 0 et 14 donc une taille de 15 cases).
  

  1

  0

  0

  0

  0

  0

  0

  0

  0

  0

  5

  6

  0

  0

  9

  
  
  
• L'utilisation des doubles-cotes "" :
  
  Cette initialisation est réservée aux déclarations de tableaux de type char appelés aussi chaines de caractères, elle est très identique aux déclarations présentées ci-dessus.
  Code : C

  1	char tableau[4] = "ABC";

  
  Ici le tableau sera initialisé avec les valeurs 'A', 'B', 'C' et '\0'.
  
  Code : C

  1	char tableau[4] = "ABCD";

  
  Ceci va initialiser les 4 premières cases du tableau avec les données 'A', 'B', 'C' et 'D', le '\0' ne sera pas placé en fin de la chaine par défaut de taille. Donc ceci est une source de bogues très courants quand vous essayez de manipuler ce tableau.
  Veillez toujours à compter le '\0' en plus des caractères d'initialisation.
  
  Code : C

  1	char tableau[] = "ABC";

  
  Ici le tableau sera alloué pour contenir les données 'A', 'B', 'C' et '\0'. Donc aura une taille de 4 cases.
  
  Code : C

  1	char tableau[] = "";

  
  Ceci va allouer un tableau d'une seule case, donc prenez en garde lors de vos manipulations de ce tableau.

Parcourir un tableau

1

tableau[0] = 12;

1
2
3

int tableau[4];

tableau[4] = 15;

1

int i;

1
2
3
4
5
6

int i;

for( i=0 ; i < taille ; i++)  //Attention la condition est : i < taille !
{
     tableau[i] = 0;
}

'typedef' et le type tableau

1

typedef int my_int;

1
2
3
4
5
6
7

typedef int tab4 [4];

int main(void){
     tab4 tableauDe4 = {1,2,3,4};

     return 0;
}

1
2
3
4
5
6
7

typedef int tab [];

int main(void){
     tab tableauDe4 = {1,2,3,4};

     return 0;
}

1

int tableauDe4[] = {1,2,3,4};

Passer un tableau en argument à une fonction

• Utiliser la déclaration d'un tableau :
  
  Si l'on dispose d'un tableau de taille 'N' qu'on souhaite passer en argument à une de nos fonctions, on ferait donc comme ceci :
  
  Code : C

  1	void ma_fonction(int tableau[N]);

  
  
  Et si l'on ne connait pas à priori la taille de notre tableau (ou que l'on ne souhaite pas utiliser d'indication sur la taille), on peut faire comme ceci :
  
  Code : C

  1	void ma_fonction(int tableau[]);

  
  
  Remarque : int tableau[N] , int tableau[] , et int * tableau sont strictement équivalentes seulement pour les paramètres formels d'une fonction.
  
  
• Utiliser un pointeur
  
  On peut utiliser un pointeur pour réceptionner un tableau envoyé en argument, en déclarant l'argument ainsi :Code : C

  1	void ma_fonction(int * tableau);

  
  
  
• Utiliser un typedef
  
  Comme on l'a vu, on pourrait utiliser un typedef pour déclarer un argument de type tableau, on ferait donc ainsi :Code : C

  1 2 3

  typedef int tabN[N]; void ma_fonction(tabN tableau);

  Ou sans utiliser de taille :Code : C

  1 2 3

  typedef int tab[]; void ma_fonction(tab tableau);

  
  
  

Retourner un tableau

1

int (ma_fonction(void))[4];

• Hors cas d'utilisation du mot-clef static , la déclaration d'un tableau est faite de manière automatique, ce qui fait qu'il a une portée locale. Donc le retourner à une autre fonction, impliquerait l'utilisation d'un espace mémoire déjà détruit.
Code : C

1 2 3 4

int (ma_fonction(void))[5]{ //Ceci génère une erreur de syntaxe int tab[5] = {0}; return tab; //Retour du tableau }



ou

Code : C

1 2 3 4

int (* fonction(void))[5]{ //ceci est correct syntaxiquement mais aboutirait à un bogue int tab[5] = {0}; return &tab; //Retour d'un pointeur sur le tableau }



ou

Code : C

1 2 3 4

int * fonction(void){ //ceci est correct syntaxiquement mais aboutirait à un bogue int tab[5] = {0}; return tab; //Retour d'un pointeur sur le premier élément du tableau }



ou

Code : C

1 2 3 4

int * fonction(void){ //ceci est correct syntaxiquement mais aboutirait à un bogue int tab[5] = {0}; return &(tab[0]); //Retour d'un pointeur sur le premier élément du tableau }

1
2
3
4
5
6
7
8
9

typedef struct {
     int tableau[5];
}STableauDe5;

STableauDe5 ma_fonction(void){
     STableauDe5 tab = {{0}};
     
     return tab;
}

1
2
3
4
5
6

int main (void){
     STableauDe5 tab;

     tab = ma_fonction();
     return 0;
}

Allocation dynamique d'un tableau à une dimension

La fonction malloc

1

void *malloc (size_t size);

• size : la taille en "byte" (octet par abus de langage) de l'espace mémoire à allouer.
• La valeur retournée : la fonction malloc retourne un pointeur sur le premier "byte" de l'espace alloué, ou le pointeur NULL en cas d'échec.

1

pointeur = malloc(nombreElements * sizeof(*pointeur));

La fonction calloc

1

void *calloc (size_t nmemb, size_t size);

• nmemb : le nombre d'éléments constituant l'espace mémoire à allouer.
• size : la taille en "byte" de chaque élément constituant l'espace mémoire à allouer.
• La valeur retournée : la fonction calloc retourne un pointeur sur le premier "byte" de l'espace alloué, ou le pointeur NULL en cas d'échec.

1

pointeur = calloc(nombreElements , sizeof(*pointeur));

La fonction realloc

1

void *realloc (void *ptr, size_t size);

• ptr : l'ancien espace mémoire alloué, et dont on voudrait modifier la taille. Si ce paramètre est NULL , alors la fonction se comporte comme malloc.
• size : la taille en "byte" du nouvel espace à allouer.
• La valeur retournée : la fonction realloc retourne un pointeur sur le premier "byte" du nouvel espace alloué, ou le pointeur NULL en cas d'échec.

1

pointeur = realloc(pointeur, nouvelleTaille);

Règles de bon usage:
Une utilisation telle qu'on vient de voir, est risquée. Pourquoi ?
Car en cas d'échec d'allocation, non seulement elle ne détruit pas l'ancien espace alloué, mais aussi elle retourne le pointeur NULL.

Dans l'expression pointeur = realloc(....), quelque soit le résultat, on aura écrasé l'ancienne valeur de pointeur. Donc on se retrouve dans un cas de mémoire déjà allouée, mais dont on ne connait plus où elle se trouve, ce qui vous rend incapable à la libérer; et c'est ce qu'on appel une fuite mémoire .

Solution :

Comme solution simple, on pourrait utiliser une variable intermédiaire, de type pointeur aussi :

Code : C

1 2 3 4 5 6 7 8 9

ptrintermediaire = realloc( pointeur , nouvelleTaille ); if(ptrintermediaire == NULL){ free(pointeur); //Desallocation //Ne pas oublier de notifier l'erreur. } else{ pointeur = ptrintermediaire ; }

La variable 'ptrintermediaire' doit être du même type que pointeur.
Ainsi nous n'écraserons l'ancienne valeur de pointeur que si la nouvelle allocation s'est bien passée.

Retourner un espace alloué dynamiquement

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

int * fonctionAllocation(int nombreElements){
      int * ptr = malloc( nombreElements * sizeof(*ptr) );

      return ptr;
}

int main(void){
      int * ptr = fonctionAllocation(10);
      if(ptr == NULL)
           //........
      //.......
      return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

void fonctionAllocation(int **ptr , int nombreElements){
      *ptr = malloc( nombreElements * sizeof(**ptr) );
}

int main(void){
      int * ptr;
      fonctionAllocation(&ptr , 10);
      if(ptr == NULL)
           //........
      //.......
      return 0;
}

Déclaration

1

int t[taille1][taille2][taille3];

Utilisation

Initialisation

1

int tableau1[2][3] = {{1,8,9},{0,6,4}};

1
2
3

int tableau1[2][3][2] = {{ {1,8}   , {0,6} , {0,0} },
                         { {31,52} , {4,8} , {11,5}}
                        };

1

int tableau1[][3] = {{1,8,9},{0,6,4},{5,3,7},{2,2,2}};

1

int tableau1[][3] = {{1,9},{0,4},{5,3,7},{2,2,2}};

1

int tableau1[][3] = {{0},{0},{0},{0}};

1

int tableau1[][3] = {{0}};

1
2
3

int t[4][5] = {{1,[3]=5,6},
            [2]={[3]1},
               {2,4,[4]=10}};

1
2
3

int t[4][5] = {[3]={1,[3]=5,6},
               [0]={[3]=1},
                   {2,4,[4]=10}};

1
2
3
4
5

int t[][5] = { [1]={1,[3]=5,6},
               [2]={7,9,[1]=1,5},
                   {2,4,[4]=10},
                   {0,7,5,3,8,4,7},
                   {0}};

1

int t[][5] = {[5]={0}};

1

int t[][5] = {[1]=1,[3]=5,6,2,4,[4]=10,0,7,5,3,8,4,7,[18]=7,9,[23]=13};

Parcours

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

int tableau[taille1][taille2][taille3];
int i,j,k;

for(i=0 ; i < taille1 ; i++){               //Première dimension
      for(j=0 ; j < taille2 ; j++){         //Deuxième dimension
             for(k=0 ; k < taille3 ; k++){  //troisième dimension
                   tableau[i][j][k] = 0;
             }
      }
}

Les pointeurs sur tableaux

1

int (*ptrtableau)[4];

1

int * ptrtableau[4];

Utilité des pointeurs sur tableaux

1
2
3

int (*tableau)[4];

tableau = malloc(5 * sizeof(*tableau));

Libération de mémoire allouée

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

int (*tableau)[4];

//----Allocation-----
tableau = malloc(5 * sizeof(*tableau));
if(tableau == NULL){
    //Notifier l'erreur
    exit(EXIT_FAILURE);
}

//----Libération en cas d'allocation réussie-----
free(tableau);

Les tableaux de pointeurs

1

int * tableauDePtr[5];

1
2
3
4
5
6

int * tableauDePtr[5];
int i;

for(i=0 ; i < 5 ; i++){
       tableauDePtr[i] = malloc(4 * sizeof(tableau[0]));
}

Libération de mémoire allouée

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

int i;
int * tableauDePtr[5];

//---Allocation-----
for(i=0 ; i < 5 ; i++){
       tableauDePtr[i] = malloc(4 * sizeof(tableau[0]));
       if(tableauDePtr[i] == NULL){    //En cas d'erreur d'allocation
            //N'oubliez pas de notifier l'erreur
            for(i=i-1 ; i >= 0 ; i--)  //Libération de l'espace déjà alloué
                 free(tableauDePtr[i]);

            exit(EXIT_FAILURE);
       }
}

//---Libération en cas d'allocation réussie-----
for(i=0 ; i < 5 ; i++){
       free(tableauDePtr[i]);
}

1

free(tableauDePtr);

Allocation dynamique

1

int ***ptr;     //3 étoiles pour 3 dimensions

1

int **ptr;     //2 étoiles pour 2 dimensions

Tableaux bidimensionnels

• 1- Allocation de la première dimension (ptr) :
  
  Il s'agit du tableau de pointeurs qui contiendra plusieurs pointeurs qui à leur tour pointent sur des espaces alloués sous forme de tableaux.
  
  
  
  
  
  Code : C

  1 2 3 4 5

  int **ptr; ptr = malloc(taille1 * sizeof(*ptr)); //On alloue 'taille1' pointeurs. if(ptr == NULL) //Ne pas oublier de notifier l'erreur et de quitter le programme.

  
  
  
• 2- Allocation de la deuxième dimension (*ptr) :
  
  
  
  
  
  Il s'agit des différents tableaux appelés "tableaux de valeurs" sur l'image ci-dessus.
  
  Code : C

  1 2 3 4 5 6 7 8 9

  int i; for(i=0 ; i < taille1 ; i++){ ptr[i] = malloc(taille2 * sizeof(*(ptr[i]))); //On alloue des tableaux de 'taille2' variables. if(ptr[i] == NULL){ //Il faut libérer la mémoire déjà allouée //Ne pas oublier de notifier l'erreur et de quitter le programme. } }

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

int i , taille1 = 2 , taille2 = 3;
int **ptr;

ptr = malloc(taille1 * sizeof(*ptr));       //On alloue 'taille1' pointeurs.
if(ptr == NULL)
      //Ne pas oublier de notifier l'erreur et de quitter le programme.

for(i=0 ; i < taille1 ; i++){
     ptr[i] = malloc(taille2 * sizeof(**ptr) );       //On alloue des tableaux de 'taille2' variables.
     if(ptr[i] == NULL){                              //En cas d'erreur d'allocation
         //Il faut libérer la mémoire déjà allouée
         //Ne pas oublier de notifier l'erreur et de quitter le programme.
     }
}

//notre tableau ptr[2][3] est maintenant utilisable...

• 1- Libération de la deuxième dimension (*ptr) :
  
  En utilisant une boucle, on doit donc libérer les différents tableaux à une dimension qu'on a alloués :
  
  
  
  
  
  Code : C

  1 2 3 4 5

  int i; for(i=0 ; i < taille1 ; i++){ free(ptr[i]); }

  
  
  
• 2- Libération de la première dimension (ptr) :
  
  
  
  
  
  Code : C

  1	free(ptr);

  
  
  

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

int i;

//Après allocation....

//--------La libération---------
for(i=0 ; i < taille1 ; i++){
     free(ptr[i]);
}

free(ptr);
ptr = NULL;   //Ceci est par mesure de sécurité (ce n'est donc pas obligatoire).
//--------------------------------

• 1- Première dimension :
  
  Code : C

  1 2 3 4 5

  int **ptr; ptr = malloc(taille1 * sizeof(*ptr)); //On alloue 'taille1' pointeurs. if(ptr == NULL) //Pas de libération nécessaire à ce niveau, il suffirait donc de notifier l'erreur et de fermer le programme (par utilisation de exit(-1) par exemple).

  
  
  
• 2- Deuxième dimension :
  
  Code : C

  1 2 3 4 5 6 7 8 9 10 11 12

  int i; for(i=0 ; i < taille1 ; i++){ ptr[i] = malloc(taille2 * sizeof(*(ptr[i]))); //On alloue des tableaux de 'taille2' variables. if(ptr[i] == NULL){ for(i = i-1 ; i >= 0 ; i--) //On parcourt la boucle dans l'ordre inverse pour libérer ce qui a déjà été alloué free(ptr[i]); free(ptr); //On libère la première dimension. //Ne pas oublier de notifier l'erreur et de quitter le programme (en utilisant exit(-2) par exemple). } }

Tableaux tridimensionnels

• 1- Allocation de la première dimension, représentée par ptr : Par analogie aux tableaux automatiques, ce sera celle qui se trouve entre crochets ([]) à gauche.
  
  Code : C

  1 2 3

  int ***ptr; ptr = malloc(taille1 * sizeof(*ptr));

  
  
  
  
  
  
  
• 2- allocation de la deuxième dimension, représentée par *ptr : Par analogie aux tableaux automatiques, ce sera celle qui se trouve entre crochets ([]) au milieu.
  
  
  
  
  
  Code : C

  1 2 3

  for(i=0 ; i < taille1 ; i++){ ptr[i] = malloc(taille2 * sizeof(**ptr)); }

  
  
  
• 3- allocation de la troisième dimension, représentée par **ptr : Par analogie aux tableaux automatiques, ce sera celle qui se trouve entre crochets ([]) à droite.
  
  
  
  
  
  Code : C

  1 2 3 4 5

  for(i=0 ; i < taille1 ; i++){ for(j=0 ; j < taille2 ; j++){ ptr[i][j] = malloc(taille3 * sizeof(***ptr)); } }

  
  
  

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

int ***ptr;
int i,j;

ptr = malloc(taille1 * sizeof(*ptr));
if(ptr == NULL)          //Pas de libération de mémoire à ce niveau
     return -1;          //Exemple de code d'erreur

for(i=0 ; i < taille1 ; i++){
     ptr[i] = malloc(taille2 * sizeof(**ptr));
     if( ptr[i] == NULL) //Pensez à libérer la mémoire déjà allouée et fermer le programme.
          return -1;     //Exemple de code d'erreur
}
for(i=0 ; i < taille1 ; i++){
     for(j=0 ; j < taille2 ; j++){
           ptr[i][j] = malloc(taille3 * sizeof(***ptr));
           if(ptr[i][j] == NULL)   //Pensez à libérer correctement la mémoire déjà allouée
                return -1;           //Exemple de code d'erreur
     }
}

• 1- Libération de l'espace **ptr.
  
  Code : C

  1 2 3 4 5

  for(i=0 ; i < tailleDejaAllouee1 ; i++){ for(j=0 ; j < tailleDejaAllouee2 ; j++){ free(ptr[i][j]); } }

  
  
  
• 2- Libération de l'espace *ptr.
  
  Code : C

  1 2 3

  for(i=0 ; i < tailleDejaAllouee1 ; i++){ free(ptr[i]); }

  
  
  
• 3- Libération de l'espace ptr.
  
  Code : C

  1	free(ptr);

  
  
  

1
2
3
4
5
6
7

for(i=0 ; i < tailleDejaAllouee1 ; i++){
     for(j=0 ; j < tailleDejaAllouee2 ; j++){
           free(ptr[i][j]);
     }
     free(ptr[i]);
}
free(ptr);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

#include <stdlib.h>

void * my_free(int***,int,int);

void * my_free(int ***ptr,int tailleDejaAllouee1,int tailleDejaAllouee2){
    int i,j;

    for(i=0 ; i < tailleDejaAllouee1 ; i++){
         for(j=0 ; j < tailleDejaAllouee2 ; j++){
               free(ptr[i][j]);
         }
         free(ptr[i]);
    }
    free(ptr);

    return NULL;
}

int main(void)
{
    /*---------------------------------------------------*/
    int taille1 = 2, taille2 = 2, taille3 = 2;
    int ***ptr;
    int i,j;

    /*-----------------Allocation------------------------*/
    ptr = malloc(taille1 * sizeof(*ptr));
    if(ptr == NULL)
         return -1;

    for(i=0 ; i < taille1 ; i++){
         ptr[i] = malloc(taille2 * sizeof(**ptr));

         if( ptr[i] == NULL){         //Erreur d'allocation

              for(--i ; i>=0 ; i--)   //On libère l'espace déjà alloué
                  free(ptr[i]);

              free(ptr);

              return -1;              //Fin du programme
         }
    }

    for(i=0 ; i < taille1 ; i++){
         for(j=0 ; j < taille2 ; j++){
               ptr[i][j] = malloc(taille3 * sizeof(***ptr));

               if(ptr[i][j] == NULL){         //Erreur d'allocation

                   for(--j ; j >= 0 ; j--)    //On libère l'espace déjà alloué
                        free(ptr[i][j]);

                   free(ptr[i]);

                   my_free(ptr , i , taille2);
                   return -2;                 //Fin du programme
               }
         }
    }

    /*---------------Libération--------------------------*/
    ptr = my_free(ptr,taille1,taille2);       //On libère la mémoire et on met la valeur de ptr à NULL
    /*---------------------------------------------------*/
    return 0;
}

Attention :

On pourrait optimiser nos boucles d'allocation comme ceci :
Secret (cliquez pour afficher)

Code : C

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

int ***ptr; int i,j; ptr = malloc(taille1 * sizeof(*ptr)); if(ptr == NULL) //Pas de libération de mémoire à ce niveau return -1; //Exemple de code d'erreur for(i=0 ; i < taille1 ; i++){ ptr[i] = malloc(taille2 * sizeof(**ptr)); if( ptr[i] == NULL) //Pensez à libérer la mémoire déjà allouée et fermer le programme. return -1; //Exemple de code d'erreur for(j=0 ; j < taille2 ; j++){ ptr[i][j] = malloc(taille3 * sizeof(***ptr)); if(ptr[i][j] == NULL) //Pensez à libérer correctement la mémoire déjà allouée return -1; //Exemple de code d'erreur } }

Cependant le problème se posera dans la libération de mémoire déjà allouée qui sera beaucoup plus compliquée . Si vous n'êtes pas convaincu de la complexité que cela peut engendrer, essayer de le faire, et faîtes vous corrigé par une personne confirmée.

La méthode que je viens d'expliquer pour un tableau à trois dimensions, est valable pour un tableau à plus de dimensions, il suffirait de suivre la même logique à savoir allouer dimension par dimension en respectant l'ordre. Une fois à l'aise avec les allocations, vous pouvez bien entendu optimiser vos boucles d'allocations .

Fonctions : mettre un tableau en argument

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

void ma_fonction(int ** tableau2D){
      //....
      tableau2D[i][j] = 10;
}

int main(void){
      int tableau2D[10][5];

      ma_fonction(tableau2D);
      return 0;
}

Méthode classique

1
2
3

void ma_fonction(int tableau[taille1][taille2][taille3]){
      //Corps de la fonction...
}

1
2
3

void ma_fonction(int tableau[][][taille3]){
      //Corps de la fonction...
}

1
2
3

void ma_fonction(int tableau[][taille2][taille3]){
      //Corps de la fonction...
}

1
2
3

int tableau[taille1][taille2][taille3];  //La déclaration du tableau

ma_fonction(tableau);   //L'appel à la fonction avec passage d'un tableau en argument.

Utiliser un pointeur sur tableau

1
2
3
4

int fonction(int (*matrice)[3]){
        //......
        matrice[0][2] = 15;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

int fonction(int (*matrice)[3]){
        //......
        matrice[0][2] = 15;
}
int main(void){
        int matrice[4][3];  //Notez que la taille 3 correspond à celle spécifiée dans la déclaration de la fonction!

        fonction(matrice);
        return 0;
}

1
2
3

void fonction(int tab[][3]){
        sizeof tab;
}

1
2
3

void fonction(int tab[5][3]){
        sizeof tab;
}

1
2
3

void fonction(int (*tab)[3]){
        sizeof tab;
}

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

void fonction1(int matrice[][3], size_t Nlignes){
        sizeof matrice[0] * Nlignes;   //Ceci permet de récupérer la taille de toute la matrice.
        sizeof *matrice * Nlignes;     //équivalente à celle ci-dessus
}
void fonction2(int matrice[10][3], size_t Nlignes){ //La taille 10 ici sera ignorée, donc est inutile. Contrairement à la taille 3 qu'il faudra respecter!
        sizeof matrice[0] * Nlignes;   //Ceci permet de récupérer la taille de toute la matrice.
        sizeof *matrice * Nlignes;     //équivalente à celle ci-dessus
}
void fonction3(int (*matrice)[3], size_t Nlignes){
        sizeof matrice[0] * Nlignes;   //Ceci permet de récupérer la taille de toute la matrice.
        sizeof *matrice * Nlignes;     //équivalente à celle ci-dessus
}
int main (void){
        int matrice[4][3];
        fonction1(matrice,4);
        fonction2(matrice,4);
        fonction3(matrice,4);
}

Utilisation d'un double pointeur int **ptr

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

int fonction(int **mat)
{
        int i, j, *index[3];   //Index est le tableau de pointeurs qu'on utilisera sous forme de mémoire tampon.

        for (i = 0 ; i < 3 ; i++)  //On initialise notre tableau intermédiaire 'index'
                index[i] = (int *)mat + 3 * i; 

        for(i = 0 ; i < 3 ; i++)
        {
                printf("\n");
                for(j = 0 ; j < 3 ; j++)
                {
	                printf("%d", index[i][j]);
                }
        }
        printf("\n");

        return 0;
}

1
2
3
4
5
6
7

int matrice[3][3] = {{1,2,3},{4,5,6},{7,8,9}}; //La matrice
int **adresse_matrice = (int**)matrice;  //Ceci est pour simuler un passage d'une matrice à une fonction
int *adresse_1, *adresse_2, *adresse_3;

adresse_1 = (int*)adresse_matrice;
adresse_2 = (int*)adresse_matrice + 3;
adresse_3 = (int*)adresse_matrice + 6;

1
2
3
4
5
6
7

int matrice[3][3] = {{1,2,3},{4,5,6},{7,8,9}}; //La matrice
int **adresse_matrice = (int**)matrice;  //Ceci est pour simuler un passage d'une matrice à une fonction
int *adresse[3];                  //Les pointeurs intermédiaires

adresse[0] = (int*)adresse_matrice + (0*3);
adresse[1] = (int*)adresse_matrice + (1*3);
adresse[2] = (int*)adresse_matrice + (2*3);

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

int fonction(int **mat)
{
        int i, j, *index[3];   //Index est le tableau de pointeurs qu'on utilisera sous forme de mémoire tampon.

        for (i = 0 ; i < 3 ; i++)  //On initialise notre tableau intermédiaire 'index'
                index[i] = (int *)mat + 3 * i; 

        for(i = 0 ; i < 3 ; i++)
        {
                printf("\n");
                for(j = 0 ; j < 3 ; j++)
                {
	                printf("%d", index[i][j]);
                }
        }
        printf("\n");

        return 0;
}

Utilisation d'un typedef

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

typedef int tableau3x3x3[3][3][3];

void ma_fonction1(tableau3x3x3 tab){   //Déclaration d'un argument de type tableau tridimensionnel de 3x3x3
      //Corps de la fonction...
      printf("%zu\n",sizeof(tab[0][0]));//Pour un test
}

int main(void)
{
    tableau3x3x3 tableau;    //Déclaration du tableau 3D

    ma_fonction1(tableau);   //Appel de la fonction en lui passant notre tableau en paramètre
    return 0;
}

Fonctions : retourner un tableau

1
2
3
4
5

int (ma_fonction(void))[2][3][4]{
     int tableau[2][3][4];

     return tableau;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

int *** fonction_allocation(int taille1, int taille2, int taille3){
     int ***ptr;
     int i,j;

     ptr = malloc(taille1 * sizeof(*ptr));
     if(ptr == NULL)          //Pas de libération de mémoire à ce niveau
          return -1;          //Exemple de code d'erreur

     for(i=0 ; i < taille1 ; i++){
          ptr[i] = malloc(taille2 * sizeof(**ptr));
          if( ptr[i] == NULL) //Pensez à libérer la mémoire déjà allouée et fermer le programme.
               return -1;     //Exemple de code d'erreur
     }
     for(i=0 ; i < taille1 ; i++){
          for(j=0 ; j < taille2 ; j++){
                ptr[i][j] = malloc(taille3 * sizeof(***ptr));
                if(ptr[i][j] == NULL)     //Pensez à libérer correctement la mémoire déjà allouée
                     return -1;           //Exemple de code d'erreur
          }
     }
     return ptr;                          //retour du pointeur sur l'espace alloué
}

int main(void){
     int taille1 = 2, taille2 = 2, taille3 = 2;
     int *** ptr = fonction_allocation(taille1,taille2,taille3);
     //.....
     ptr = my_free(ptr,taille1,taille2);   //Cette fonction est décrite dans la partie allocation dynamique
     return 0;
}

Pointeurs

Exercice 1

• 1. Déclarer un pointeur sur int et l'initialiser par le pointeur NULL.
  
• 2. Déclarer un pointeur sur pointeur sur int.
  
• 3. Déclarer une variable de type int.
  
• 4. Initialiser le pointeur sur int par l'adresse de cette variable.
  
• 5. Initialiser le pointeur sur pointeur sur int par l'adresse du pointeur sur int.
  
• 6. Allouer dynamiquement un espace de mémoire suffisant pour contenir une variable de type int, et stocker son adresse dans le pointeur sur int.

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

//Q1 :
int * pointeur = NULL;
//Q2 :
int ** pointeurSurPointeur;
//Q3 :
int variable;
//Q4 :
pointeur = &variable;
//Q5 :
pointeurSurPointeur = &pointeur;
//Q6 :
pointeur = malloc(sizeof(int));
//Ou
pointeur = malloc(sizeof( *pointeur ));

Exercice 2

• 1. Déclarer deux pointeurs sur float .
• 2. Déclarer deux variables de type float .
• 3. Initialiser chacun des pointeurs avec les adresses des deux variables float .
• 4. Affecter la valeur 12.5 à la première variable en utilisant son pointeur.
• 5. Affecter la valeur 5.76 à la deuxième variable en utilisant son pointeur.
• 6. Échanger le contenu des deux variables en utilisant leurs pointeurs.

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

//Q1 :
float * ptr1 , * ptr2 ;
//Q2 :
float variable1 , variable2 ;
//Q3 :
ptr1 = &variable1;
ptr2 = &variable2;
//Q4 :
*ptr1 = 12.5;
//Q5 :
*ptr2 = 5.76;
//Q6 :
float variableIntermediaire;

variableIntermediaire = * ptr1;
*ptr1 = *ptr2;
*ptr2 = variableIntermediaire;

Exercice 3 (problème)

• Écrire une procédure "permute" qui permet de permuter les valeurs de deux variables entières et écrire un programme dans lequel on saisira deux nombres entiers avant de faire appel a cette procédure et d'afficher le contenue de ces variable afin de vérifier la permutation.

Exercice 4 (problème)

• Donner et expliquer le résultat de l'exécution du programme suivant :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include <stdio.h>
#define taille_max 5
 
void parcours(int *tab)
{
     int *q=tab;
     do
     {
         printf("%d:%d\n", q-tab, *q-*tab);
     }
     while (++q-tab < taille_max);
}
 
void bizarre(int **copie, int *source)
{
     *copie=source;
}
 
int main(void)
{
     int chose[taille_max] = {1,3,2,4,5}, *truc;
     printf("chose : \n");

     parcours(chose);

     bizarre(&truc, chose);

     printf("truc : \n");

     parcours(truc);
 
     return 0;
}

Tableaux unidimensionnels

Exercice 1

• Déclarer de façon automatique un tableau à 15 variables de type double . Et initialiser ce tableau avec des zéros.

Solution

1
2
3
4
5

double tab[15];
int i;

for(i=0 ; i< 15 ; i++)
    tab[i] = 0;