Discussion :

[redouane7124]

Bonjour,
Je tente de rédiger un petit fascicule de TP sur le langage C pour débutant.
Je suis tombé sur un point que je n'arrive pas à expliquer.

Supposant que l'on désire écrire une procédure qui incrémente la valeur du paramètre en entrée.
Tout le monde serait d'accord à dire que le mode de passage du paramètre doit être par adresse (pointeur)
cela afin de modifier réellement le contenu de la variable du programme appelant et non sa copie. Ce qui donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
void incremente_val( int *v )
{
*v=*v+1;
}
 
 
 int main(void)
{
   int x ;
   x=3;
   incremente_val(&x);
 //x vaut maintenant 4   
   return 0;
}

Nous avons donc passé l'adresse de x en paramètre à la fonction incremente_val, et celle-ci incrémente le contenu de l'adresse pointée par le paramètre.
Jusqu'ici tout se passe bien.

Maintenant, supposons que l'on désire créer une procédure qui n'incrémente pas une valeur mais toutes les valeurs d'un tableau de 5 éléments.
Je pensais que l'on devait procéder de la même manière à la seule différence que la procédure devra prendre l'adresse du tableau et non pas d'une variable scalaire.
Cependant, j'ai constaté que si je ne précise pas que le mode de passage du paramètre tableau est par adresse, cela fonctionne quand même !
dans le code ci-dessous, le tableau a bien été modifié au niveau du main sans qu'il soit passé par adresse dans la procédure ?!

Dois-je en déduire que lorsqu'un paramètre de type tableau est passé en paramètre à une procédure, cette dernière considère explicitement le paramètre comme étant l'adresse du tableau?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#define X 4
 
void incremente_tab( int tab[X] )
{
   int i,j;
   for(i=0; i<X; i++)
   {
          tab[i]++;
      }
}
 
int main(void)
{
   int tab1[X];
      int i;
 
 
 
for(i=0; i<X; i++)
   {
          tab1[i] = 1;
      }
 
   incremente_tab(tab1);
//je constate ici que la tableau tab1 a bien été modifié alors que le passage ne s'est pas fait par adresse
 
 
   return 0;
}

[Matt_Houston]

Les tableaux sont la seule exception (si je ne dis pas de bêtise) du passage de paramètres en C : ils sont passés par référence et non par valeur comme le sont les autres types.

Cela permet notamment d'obtenir une équivalence entre la signature de ta fonction et void incremente_tab(int *tab) - ou plus exactement void incremente_tab(int *const tab) - où tab est dégénéré en pointeur.

Il est toutefois possible de passer un tableau par valeur en bidouillant un peu :

Code tab.c :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <stdio.h>
 
 
struct tab {
    int v[3];
};
 
 
void tab_print(const struct tab *t) {
    printf("[%d, %d, %d]\n", t->v[0], t->v[1], t->v[2]);
}
 
void ref_inc(struct tab *t) {
    ++(t->v[0]);
    ++(t->v[1]);
    ++(t->v[2]);
 
    printf("in ref_inc: ");
    tab_print(t);
}
 
void val_inc(struct tab t) {
    ++(t.v[0]);
    ++(t.v[1]);
    ++(t.v[2]);
 
    printf("in val_inc: ");
    tab_print(&t);
}
 
 
int main(int argc, char *argv[]) {
    struct tab t = { .v = { 42, 1, -2 } };
 
    tab_print(&t);
    ref_inc(&t);
    tab_print(&t);
    val_inc(t);
    tab_print(&t);
 
    return 0;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
$ gcc -std=c11 -pedantic -Wall -Wextra tab.c
$ ./a.out
[42, 1, -2]
in ref_inc: [43, 2, -1]
[43, 2, -1]
in val_inc: [44, 3, 0]
[43, 2, -1]

[ternel]

La raison en est que le nom d'un tableau est convertible en l'adresse de son premier élément.

Attention toute fois, la longueur du tableau n'est pas transmise avec.

[redouane7124]

Merci à vous deux pour vos explications.
C'est en effet plus plausible maintenant.