Discussion :

[Haze.]

Bonjour,

J'ai créé une fonction dédiée à la saisie de chaînes de caractères en console, mais il y a quelque chose que je ne comprends pas : le sizeof dans la fonction renvoie 8 alors que la chaîne est un tableau de 16 caractères.
Par conséquent, je ne peux pas saisir plus de 7 caractères, alors que cette limite devrait être de 15.

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
32
33
34
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
void lire_chaine(char[], char[]);
 
int main()
{
	char nom[16];
 
	do
	{
		lire_chaine(nom, "Votre nom : ");
		printf(">> %s\n", nom);
	} while (nom[0] != '*');
 
	return 0;
}
 
void lire_chaine(char chaine[], char prompt[])
{
	char *p_nl = NULL;
 
	printf("-> %ld\n", sizeof chaine); /* pourquoi le sizeof est de 8 ?! */
 
	printf(prompt);
	fgets(chaine, sizeof chaine, stdin);
 
	p_nl = strchr(chaine, '\n');
	if (p_nl == NULL)
		while (getchar() != '\n');
	else
		*p_nl = '\0';
}

J'ai alors modifié mon code de manière à passer le sizeof directement en paramètre, et maintenant la fonction a le comportement attendu :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void lire_chaine(char chaine[], size_t taille, char prompt[])
{
	char *p_nl = NULL;
 
	printf(prompt);
	fgets(chaine, taille, stdin);
 
	p_nl = strchr(chaine, '\n');
	if (p_nl == NULL)
		while (getchar() != '\n');
	else
		*p_nl = '\0';
}

Que j'appelle avec :
lire_chaine(nom, sizeof nom, "Votre nom : ");

Problème résolu, mais pourquoi mon premier essai ne marche pas ?
Que le sizeof se fasse dans le main ou dans lire_chaine, l'adresse de la chaîne nom est toujours la même, alors d'où vient ce 8 ?

Merci !

[granquet]

parce que tu n'as pas compris la différence entre un tableau et un pointeur:
un peu de lecture

[Haze.]

Désolé mais je ne comprends toujours pas.

Quand je déclare un tableau t de n cases, les n cases sont bien réservées en mémoire de façon contiguë à partir de l'adresse de t, non ?
Vu que mes deux utilisations de sizeof se font sur la même adresse (mais dans des fonctions différentes), je ne comprends pas pourquoi j'ai deux résultats différents !

[Emmanuel Delahaye]

parce que tu n'as pas compris la différence entre un tableau et un pointeur:
un peu de lecture

ou plutôt :

http://emmanuel-delahaye.developpez.....htm#param_tab

[Haze.]

J'ai beau relire ces documents (que j'ai déjà eu l'occasion de lire d'ailleurs, Emmanuel Delahaye ton site a déjà répondu à nombre de mes questions ), mais je ne vois pas le rapport avec mon problème.

J'ai sais que (*t + n) désigne la même valeur que t[n]... peut-être que je ne me suis pas exprimé clairement.
Après quelques tests, j'ai compris que le 8 correspond en réalité à la place occupée par un pointeur sur ma machine :

Code :

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

1
2
3
void *p = NULL;
 
printf("taille : %ld\n", sizeof p);

-> taille : 8
Donc je reformule ma question, en prenant pour exemple le code suivant :

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
#include <stdio.h>
 
void fonction(char[]);
 
int main()
{
	char chaine[50];
 
	printf("dans main : %ld\n", sizeof chaine); /* 50 */
	fonction(chaine);
	return 0;
}
 
 
void fonction(char chaine[])
{
	printf("dans fonction : %ld\n", sizeof chaine); /* 8 */
}

Comment se fait-il que dans le main, le "langage" est capable de dire que chaine est un tableau, alors que dans fonction, chaine est considérée comme un banal pointeur ?

[gangsoleil]

Bonjour,

Est-ce que la reformulation suivante de ton code t'aide à comprendre d'où vient la différence ?

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
#include <stdio.h>
 
void fonction(char[]);
 
int main()
{
	char la_chaine_du_main[50];
 
	printf("dans main : %ld\n", sizeof la_chaine_du_main); /* 50 */
	fonction(la_chaine_du_main);
	return 0;
}
 
 
void fonction(char la_chaine_de_l_appelant[])
{
	printf("dans fonction : %ld\n", sizeof la_chaine_de_l_appelant ); /* 8 */
}

[Médinoc]

Parce que la taille n'est pas spécifiée dans le prototype de fonction : Tableau de longueur inconnue --> pointeur.

[Thierry Chappuis]

Donc je reformule ma question, en prenant pour exemple le code suivant :

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
#include <stdio.h>
 
void fonction(char[]);
 
int main()
{
	char chaine[50];
 
	printf("dans main : %ld\n", sizeof chaine); /* 50 */
	fonction(chaine);
	return 0;
}
 
 
void fonction(char chaine[])
{
	printf("dans fonction : %ld\n", sizeof chaine); /* 8 */
}

Comment se fait-il que dans le main, le "langage" est capable de dire que chaine est un tableau, alors que dans fonction, chaine est considérée comme un banal pointeur ?

C'est une question de type. La variable chaine locale à main est de type est de type tableau de 50 char:

Code :

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

1
2
/* Dans main() */
printf("%u == %u\n", (unsigned) sizeof chaine, (unsigned) sizeof (char [50]));

En ce qui concerne le paramètre chaine, son type est pointeur sur char (char chaine[] est un sucre syntaxique qui a la même signification que char *chaine dans le contexte de la déclaration des arguments d'une fonction):

Code :

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

1
2
/* Dans ta fonction */
printf("%u == %u\n", (unsigned) sizeof chaine, (unsigned) sizeof (char *));

Lorsque tu utilises l'identificateur d'un tableau dans une expression (comme un appel de fonction), il a conversion implicite du type de ce tableau vers un pointeur sur le premier élément du tableau. Ainsi, lorsque tu écris:

Code :

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

1
2
3
4
5
6
char t[50] = "Hello";
*(t + 2) = 'L';
 
/* ou */
 
fonction(t);

t est converti implicitement en un pointeur sur char dont la valeur est l'adresse du premier élément de t. Ensuite l'arithmétique des pointeurs s'applique (vu que t est maintenant un pointeur).

Ainsi, un tableau est différent d'un pointeur et, dans une expression, t et &t ne sont pas interchageables (comme on le voit parfois). La différence est une nouvelle fois dans le type. t est implicitement converti en un pointeur sur char contenant l'adresse du premier élément du tableau, et &t est un pointeur sur un tableau de 50 chars ( char (*)[50] ) contenant l'adresse du tableau.

Ainsi, il est possibled de faire:

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
#include <stdio.h>
 
void fonction(char (*)[50]);
 
int main(void)
{
	char chaine[50];
 
	printf("dans main : %u\n", (unsigned) sizeof chaine); /* 50 */
	fonction(&chaine);
	return 0;
}
 
 
void fonction(char (*chaine)[50])
{
	printf("dans fonction : %u\n", (unsigned) sizeof *chaine); /* 50 */
}

On préfère toutefois passer la taille du tableau en paramètre de la fonction et travailler avec un pointeur sur le premier élément du tableau. Cette stratégie a deux avantages:

• allége la syntaxe
• donne plus de fexibilité à la fonction qui peut être utiliés avec des tableaux de taille quelconque (l'usage d'un pointeur sur un tableau de 50 chars impose une taille de tableau fixe).

Thierry

[Jean-Marc.Bourguet]

Comment se fait-il que dans le main, le "langage" est capable de dire que chaine est un tableau, alors que dans fonction, chaine est considérée comme un banal pointeur ?

Parce qu'il n'est pas possible de passer un tableau a une fonction, et que quand on essaie de dire qu'un parametre est un tableau, le C l'interprete comme etant un pointeur, meme si la taille est specifiee.

(On peut passer une structure contenant un tableau ou un pointeur vers un tableau).

[Emmanuel Delahaye]

Comment se fait-il que dans le main, le "langage" est capable de dire que chaine est un tableau, alors que dans fonction, chaine est considérée comme un banal pointeur ?

Parce que c'est une des règles de base du langage C. Lorsqu'on appelle une fonction avec un nom de tableau en paramètre, le nom du tableau est automatiquement converti en l'adresse de son premier élément. La notion de taille n'est pas transmise (elle peut l'être séparément par un paramètre supplémentaire de type size_t, comme avec fgets()).

La raison est liée à l'efficacité du code. Plutôt que de recopier intégralement les éléments du tableau (qui peut être énorme !), le choix des concepteurs du langage C ont préféré passer une simple adresse, et éventuellement, une taille, si nécessaire.

[Médinoc]

La raison est liée à l'efficacité du code. Plutôt que de recopier intégralement les éléments du tableau (qui peut être énorme !), le choix des concepteurs du langage C ont préféré passer une simple adresse, et éventuellement, une taille, si nécessaire.

D'après ce que j'ai lu pas plus tard qu'hier sur l'historique du C, ça viendrait plutôt de la façon dont c'était géré avant que les structures ne soient ajoutées au C: À l'origine, tableau était systématiquement un pointeur sur un bloc, et c'est avec l'ajout des structures qu'ils sont devenus les blocs eux-mêmes: La transmission par pointeur est alors restée (pour des raisons sur lesquelles je ne m'avancerait pas mais qui peuvent inclure la performance).

[Haze.]

Bonjour,

Je vous remercie pour vos interventions, j'ai enfin compris d'où venait ma confusion : j'étais loin de penser qu'il y avait une conversion du type lors du passage à la fonction.
Je ne savais pas que lors de la définition d'un tableau, sa taille est vraiment inhérente à son type (je croyais à tord que le type char* <=> char[] <=>char[n], c'est à dire qu'un tableau était juste un pointeur avec de l'espace mémoire réservé derrière). Mais en fait c'est tout à fait logique, il faut bien que le "langage" mémorise la taille de cet espace réservé, d'où la différence avec un banal pointeur.

Thierry Chappuis tes explications sont très claires
Encore merci à tous.