Discussion :

[evoliptic]

bonjour à tous,
j'écris afin d'avoir des renseignements sur l'erreur suivante concernant les char**,char[] et char* :

synthéthiquement, voici ce que fait mon programme :

main.c

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#include "fonctions.h"
 
int main (int argc,char *argv[])
{
char tableau1[16],tableau2[16];
 
fonction1 (&tableau1[16],&tableau2[16]);
 
//blahblah...
 
fonction2(tableau1[16],tableau2[16]);
}

fonction.c

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
31
 
fonction1 (char *tableau1[16],char *tableau2[16])
{
memset (*tableau1,'\0',16);
memset (*tableau2,'\0',16);
 
while (la condition)
{
  *tableau1[i]=blahblah;
  i++;
}
while (la condition2)
{
  *tableau2[i]=blahblah2;
  i++;
}
}
 
//blahblah
 
fonction2(char tableau1[16],char tableau2[16])
{
if(strcmp(tableau1,"string1")==0)
{
//blahblah
}
if(strcmp(tableau2,"string2")==0)
{
//blahblah
}
}

fonction.h

Code :

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

1
2
fonction1(char *tableau1[16],char *tableau2[16]);
fonction2(char tableau1[16];char tableau2[16])

L'idée est donc que j'initialise un tableau de 16 caractères dans mon main, que je fais passer par un pointeur dans une fonction 1 qui va modifier ce tableau (je passe par un pointeur car il y a en réalité 9 tableaux). Enfin après diverses choses, je fais passer ce tableau sans pointeur dans une fonction2 car celle-ci se sert de ce tableau sans le modifier. En gros, j'ai suivi la partie "à l'assaut des pointeurs du tutoriel pour apprendre le C avec des tableau au lieu des int.

Au final, le compilo me dit :

fonction1: attention, on passe un argument d'un type de pointer incompatible (passing argument from incompatible pointer type)
attendu: 'char **' mais l'argument est de type 'char *'

fonction2 : attention, on passe un argument qui produit un entier à partir d'un pointer sans appel (passing argument makes integer from pointer without a cast)
attendu : 'char' mais l'argument est de type 'char *'

donc voilà, je vais être franc, je suis complètement perdu sans comprendre mon erreur. Donc si quelqu'un pouvait m'aider, ça serait sympa! les sources complètes sont en pièces jointes.

merci par avance!

[phi1981]

Code :

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

1
2
3
4
 
char tableau1[16],tableau2[16];
 
fonction1 (&tableau1[16],&tableau2[16]);

Là déjà c'est un peu spécial.
Décompose ton appel à fonction1() :
Tu demandes l'adresse (avec &) de l'élément 16 (avec [16]) du tableau 1.
Ton tableau contient 16 éléments, numérotés de 0 à 15 donc demander l'adresse de l'élément numéro 16, ça veut dire "donne moi la première adresse invalide après le tableau", ce qui est rarement ce qu'on veut faire.

En C, quand on veut obtenir l'adresse d'un tableau (plus exactement, l'adresse de son premier élément), donner son nom suffit. Ton appel devient donc:

Code :

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

1
2
 
fonction1 (tableau1, tableau2);

Il faut comprendre que c'est totalement équivalent à ça :

Code :

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

1
2
 
fonction1 (&tableau1[0], &tableau2[0]);

Puisque, comme je l'ai dit plus haut, et comme le dit le Kernighan & Ritchie, l'adresse d'un tableau correspond à l'adresse de son premier élément.
Mais on préfère la première notation, qui est plus claire.

Bon maintenant y a la déclaration de fonction1() qui est bizarre :

Code :

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

1
2
 
fonction1 (char *tableau1[16],char *tableau2[16])

On fait pas ça en C. Une fonction qui reçoit un tableau en paramètre prend l'adresse du premier élément, comme ceci:

Code :

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

1
2
 
fonction1 (char *tableau1, char *tableau2)

Typiquement, on va aussi passer la taille du tableau en paramètre, pour que fonction1() sache combien de données elle doit traiter. Son prototype devient donc:

Code :

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

1
2
 
fonction1 (char *tableau1, int size_tableau1, char *tableau2, int size_tableau2);

[ternel]

Je ne m'occupe que de fonction1, le problème est du même acabit pour l'autre.

ton problème vient directement de ta lecture des types, et de ton appel.
voici ton code, une fois l'include remplacé par son contenu

Code :

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

1
2
3
4
5
6
7
8
9
//note 1
int fonction1(char *tableau1[16],char *tableau2[16]);
 
int main (int argc,char *argv[]) {
char tableau1[16],tableau2[16];
 
fonction1 (&tableau1[16],&tableau2[16]);
return 0;//note 2
}

Premièrement, laisse moi hurler: ON DOIT DÉFINIR UN TYPE DE RETOUR!
bon d'accord, c'était peut-être juste un oubli dans ton code minimaliste
Une vieille norme autorisait de ne pas le définir, et supposait int par défaut. C'est (quasiment) interdit par les normes "récentes" (1989)
Que tu l'ai écrit prouve que tu ne compile pas avec des warnings suffisant, ou avec un compilateur plus que périmé.

en note 2, j'ai rajouté un return 0, parce que même si beaucoup de compilateurs le rajoute automatiquement à main, c'est préférable de l'écrire pour ne pas imaginer qu'il en soit de même dans les autres fonctions.

Merci pour ton attention, passons à l'explication de ton problème.

ligne 2 (fonction1)
Cette instruction est de la forme type nom; c'est une déclaration.
ici, la déclaration d'une fonction retournant un int, et prenant deux arguments. Pour être précis, fonction1 est le nom d'un int(char*[/*16*/], char*[/*16*/]).
le premier est un [] de * de char, nommé (le temps de cette déclaration) tableau1, c'est à dire un tableau de pointeur de caractères.
le second aussi.
Leur type avec la notation compilateur est char*[];

Remarque gratuite:
Personnellement, pour éviter des problèmes de compréhension sur les pointeurs, je le formule un peu autrement: *tableau1[] et *tableau2[] sont de type char.
Ainsi, le code int * a, b devient correctement compréhensible:
"*a et b sont de type int" ce qui correspond bien au C: a sera un pointeur, mais pas b.


Deux remarques immédiates:

1. les noms des arguments dans une déclaration de fonction ne sont pas nécessaire, et n'ont pas d'autre portée que cette déclaration. Ils pourront être changé dans la définition de la fonction.
   Ainsi, int fonction1(char *a[], char *b[]) {return 0;} est bien la définition de cette fonction.
2. La taille du tableau n'a aucune existence dans les arguments d'une fonction. elle n'est ni vérifiée ni compilée. Tu aurais pu mettre un commentaire, ou même rien, comme dans l'exemple juste ci-dessus

ligne 5 (char tableau1[16],tableau2[16];)
Cette instruction déclare deux [16] de char, c'est à dire deux tableaux de 16 char.
Avec mon vocabulaire ca donne tableau1[] et tableau2[] sont des char

ligne 7 (fonction1 (&tableau1[16],&tableau2[16]);)
ceci n'est pas une déclaration, mais l'appel à fonction1. Ca tombe bien, c'est ce que tu veux faire.
Il s'agit d'une instruction-expression, vu la syntaxe de la forme expression;Le compilateur la voit ainsi:
parenthèse appliquée sur fonction1, avec pour arguments les expressions &tableau1[16] et &tableau2[16].

Ces deux expressions se lisent de la même manière, du fait des priorités des opérateurs: & appliqué à ([] appliqué à tableau1/2 avec pour argument l'expression entière 16)
C'est à dire: l'adresse de (l'élément au décallage 16 de tableau1/2)

Comme tu as déclaré que tableau1[] est un char, le type de cette expression est: adresse de (un char), c'est à dire pointeur de char: char*.
Ca tombe mal, parce que fonction1 s'attend à se que ses arguments soit des char*[], (équivalents pour les appels de fonctions à char**)

Ce que tu voulais faire, c'est donner tableau1 et tableau2 en arguments modifiables à fonction1.
La bonne syntaxe, c'est de comprendre que le nom du tableau est le tableau.

Il reste un gros détail à expliquer:
le nom d'un tableau est convertible à la compilation en pointeur sur son premier élément.
tableau1 est automatiquement convertible en &tableau1[0].

Normalement, j'ai donné assez d'explication, à toi nous dire quelle est ta réponse.

Question bonus, pourquoi ton programme aurait provoqué des erreurs de segmentation, si le type de la fonction était bon?

[ternel]

En réaction à phil1981, je dirai que le prototype supposable serait plutot:

Code :

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

1
2
//cette fonction accepte deux tableaux de la meme taille.
int fonction1(unsigned int taille, char tableau1[], char tableau2[]);

Oui, avec le commentaire. C'est important à mes yeux.
Je me permet de suggérer unsigned int, voire même size_t, mais il faut inclure je ne sais plus quel en-tête pour avoir ce type (qui est souvent unsigned int)

Et le K&R est un vieux livre, qui n'est pas à jour avec les normes C99 et C11.

[phi1981]

Woaaa le carton, j'avais même pas vu qu'il manquait un type de retour à la fonction ! Merci leternel d'être plus réveillé que moi

Oui, ton exemple est nettement meilleur, avec un commentaire clair qui explique ce que cette fonction reçoit et avec un paramètre unsigned pour la taille du tableau.

Et le K&R est un vieux livre, qui n'est pas à jour avec les normes C99 et C11.

C'est vrai qu'il est vieux maintenant (pfff ... ça nous rajeunit pas ...) ... Question un peu hors-sujet : mais alors c'est quoi qu'on lit de nos jours quand on apprend le C ? J'ai toujours adoré ce livre, j'imagine mal un autre livre arriver à donner des explications aussi claires sur des sujets aussi peu intuitifs que les pointeurs, les tableaux de pointeurs, et pointeurs de tableaux.

[ternel]

Personnellement, je n'ai lu que "le C précis et concis" d'une centaine de pages, chez O'Reilly, écrit dans les 90.
Et surtout tout ce que developpez.com propose, ainsi que une bonne référence sur le langage.

Et comme je le recommande, j'ai surtout commencé par apprendre à lire le langage comme le ferait un compilateur.
C'est la raison de ma manière un peu bizarre de traduire les expressions.

Au fond de mon petit cœur, je considère qu'on peut compiler le C (et le C++, d'ailleurs) non pas en binaire, mais en français.
Je crois qu'un jour, j'écrirai ce compilateur... mais dans longtemps.

C'est même ma méthode préférée de débug: si le français n'ai pas compréhensible, le code est mauvais.

Dans l'absolu, je pourrais même définir un sous-ensemble du français qui se compilerait en C, mais c'est trop de travail pour un usage globalement nul.

[evoliptic]

rebonjour,

merci pour vos réponses; voici ce que j'ai à répondre :

-concernant les types de retour, ceux-ci sont tous déjà présents (en l’occurrence les deux fonctions ont un type de retour void), et j'ai également un return dans le main. Il est vrai que je ne les ai pas indiqué ici, afin d'éviter de trop charger le post, et en sachant que l'erreur ne venait pas de là, mais si l'on regarde les sources, on peut voir qu'ils y sont bien

-en fait, je pensais qu'en passant fonction (&tableau[16]), je passais l'adresse d'un tableau de taille 16...

-du coup, si j'ai bien compris, dans un autre contexte, je dois passer argv[3][0] comme argument à une fonction si je veux obtenir le premier caractère de ma troisième option lors de l'exécution du programme?

[ternel]

C'est bien ca, en effet.

Et donc comme tu l'as vu, la bonne syntaxe est:

Code main.c :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#include "fonctions.h"
 
int main (int argc,char *argv[])
{
char tableau1[16],tableau2[16];
 
fonction1 (&tableau1, &tableau2);
 
//blahblah...
 
fonction2(tableau1, tableau2);
}

Pour éviter de nombreux problèmes, essaie d'utiliser les fonctions "taillées", qui limite leur zone d'effet.
strncmp, strncpy

Dans le cas contraire, tu ouvres potentiellement des failles de sécurités, et au minimum, tu risques la segfault.
(et loi de Murphy oblige, tu vas t'en manger)

[Sve@r]

-en fait, je pensais qu'en passant fonction (&tableau[16]), je passais l'adresse d'un tableau de taille 16...

Bonjour

Il ne faut pas confondre "ce que l'on passe" et "ce que la fonction s'attend à recevoir". Toutefois il faut que les deux correspondent

Si tu écris

Code c :

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

void fonction(char tab[16]);

Cela signifie qu'effectivement la fonction doit recevoir un tableau qui doit avoir au-moins une taille de 16 caractères puisque la déclaration indique que la fonction risque de taper dans les éléments de 0 à 15.
Ensuite, quand tu l'appelleras, tu devras alors lui passer un tableau.

Code c :

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

1
2
3
4
5
6
7
8
9
10
int main()
{
    char tab[100];
 
    fonction(tab);
    fonction(&tab[0]);
    fonction(&tab[10]);
    fonction(tab + 10);
    fonction(&tab[83]);
}

Dans chacun de ces appels, la fonction ne reçoit qu'une adresse. Le nom qui correspond à l'adresse du premier élément, puis de nouveau l'adresse du premier élément mais écrite de façon explicite, puis l'adresse du 11°, puis l'adresse du premier à laquelle on lui ajoute de 10 ce qui revient encore à l'adresse du 11°, puis l'adresse du 84° qui autorise encore la fonction à taper dans ce 84° (qui sera pour elle tab[0]) et monter jusqu'au 100° (qui sera pour elle tab[15]).
Comme le C te garantit que les éléments d'un tableau se suivent toujours en mémoire, si t'as l'adresse d'un élément, tu peux alors sans souci passer à l'élément suivant et etc. De plus, le chiffre 16 n'est qu'un indicateur mais non une obligation. Si le tableau reçu est assez grand, rien n'interdit à la fonction à taper dans tab[20], tab[30], etc. (cela ne posera de soucis que dans le cas du dernier appel).

Etant donné que l'adresse d'un caractère c'est un char*, t'as alors le droit de remplacer ta déclaration par celle-ci: void fonction(char *tab);, le reste ne changeant pas.

-du coup, si j'ai bien compris, dans un autre contexte, je dois passer argv[3][0] comme argument à une fonction si je veux obtenir le premier caractère de ma troisième option lors de l'exécution du programme?

Rectifions les termes erronés: argv[x] (si on parle bien de main(int argc, char *argv[])) ne contient pas une option mais un argument (un mot). Que ce mot soit une option ne dépend que des conventions passées entre programmeurs et utilisateurs (sous Unix une option commence par un tiret, ou deux tirets, sous Windows par un slashe).
Donc argv[3] contient effectivement le 3° mot passé au programme et argv[3][0] est bien le premier caractère de ce 3° mot. Mais si tu le passes à une fonction, il faut alors que la fonction soit prévue pour recevoir un caractère !!!

[ternel]

Ca m'amène à rappeler une chose qui peut sembler évidente quand on la dit:
Quand on déclare, on manipule des types.
Quand on utilise, on manipule des valeurs.

void f(char t[16]); est une déclaration, il n'y a que des types.
Le type de f est un "fonction prenant un char[] et ne retournant rien"
char t[16] est bien ici l'expression un type: char[]à l'opposé f(&tableau[16]); est une expression (enfin, une instruction, du fait du ';')
f est le nom d'une fonction qui est appelée, en vertu de l'opérateur () qui est utilisé dessus.
&tableau[16] y est une expression. Sa valeur est utile, et s'analyse comme on l'a dit, en l'adresse de l'élément au 16 décallage, donc le 17° du tableau.