convertir integer en string

Pour en revenir au problème initial :

1) Nous sommes sur le forum C et non C++ .

2)

Citation:

---

Envoyé par stephl

Le & devant un nom de tableau n'est pas utilisé normalement, cependant ce n'est pas une erreur et &a signifie a si a est un tableau.

---

• sprintf attend un char *.
• Or le P.O a donné
  
  Code:

  ---

  1 2	extern char chaine_debug[70];

  ---

  donc chaine_debug est un char *
  
• &chaine_debug est un char **

CQFD..

PERDU!

chaine_debug est un tableau de 70 char, implicitement convertible en char*, mais reste un tableau.

Donc, &chaine_debug n'est pas un char**, mais un char (*)[70]

Edit, voir ci-dessous: 8O !! je suis surpris qu'Emmanuel se soit laissé aller à écrire cela...

Citation:

---

Envoyé par Emmanuel Delahaye

• a désigne un tableau de N éléments de type T. Il a pour valeur l'adresse du premier élément du tableau. Il a pour type T*.

---

Le type de a est T[N]. Meme s'il est converti implicitement dans la plupart des contextes en un T* qui est un pointeur vers le premier element.

Citation:

---

• &a est l'adresse du tableau. Il a certes la même valeur que a mais le type est différent : T(*)[N]. (EDIT)

---

La, nous sommes d'accord.

Citation:

---

Envoyé par Médinoc

PERDU!

chaine_debug est un tableau de 70 char, implicitement convertible en char*, mais reste un tableau.

Donc, &chaine_debug n'est pas un char**, mais un char (*)[70]

Edit, voir ci-dessous: 8O !!

---

Chouette, il y en a un qui a compris!

La difference entre le tableau implicitement convertible dans quasiment tous les contextes (exception sizeof et &) en un char* et un char* est faible et un char* qui se comporte de maniere bizarre pour sizeof et & est faible tant qu'on ne considere que les variables tableaux unidimentionnels, mais bloque la comprehension quand on fait intervenir les pointeurs et les tableaux multidimentionnels.

Citation:

---

je suis surpris qu'Emmanuel se soit laissé aller à écrire cela...

---

Je ne suis pas etonne. Ca fait combien de fois qu'on a cette discussion et qu'a chaque fois il refait l'erreur?

j'aimerais bien alors que vous m'expliquiez la différence entre :

Code:

---

1 2	char chaine_debug[70] ;

---

et

Code:

---

1 2 3 4

char *chaine_debug = NULL ;   chaine_debug = calloc ( 71, 1 );

---

:cfou:

Citation:

---

Envoyé par souviron34

j'aimerais bien alors que vous m'expliquiez la différence entre :

Code:

---

1 2	char chaine_debug[70] ;

---

et

Code:

---

1 2 3

char *chaine_debug = NULL ; chaine_debug = calloc ( 70, 1 );

---

---

Dans le premier cas, chaine_debug n'est pas une lvalue et sizeof chaine_debug donne 70; dans le second cas, chaine_debug est une lvalue et sizeof chaine_debug donne sizeof (char *).

Citation:

---

Envoyé par souviron34

j'aimerais bien alors que vous m'expliquiez la différence entre :

Code:

---

1 2	char chaine_debug1[70] ;

---

et

Code:

---

1 2 3 4

char *chaine_debug2 = NULL ;   chaine_debug2 = calloc ( 71, 1 );

---

:cfou:

---

chaine_debug1 est un tableau de 70 caracteres.

chaine_debug2 est un pointeur vers char initialise avec un pointeur vers le premier caractere d'un tableau de 71 caracteres alloue dynamiquement.

Oui, on peut dire que le C cherche a induire de la confusion (avec l'arithmetique sur les pointeurs, avec l'equivalence entre p[x] et *(p+x), avec le fait que p[] declare un pointeur dans les arguments des fonctions, ...)

char chaine_debug[70];

• chaine_debug est un tableau de taille statique connue à la compilation (l'appellation "tableau statique" est trompeuse, voir la suite.
• Une variable locale de ce type sera en mémoire automatique (sur la pile)). Une variable globale de ce type sera dans le segment de données.
• sizeof(chaine_debug) retournera 70.
• chaine_debug est de type char[70], implicitement convertible en char* et en char const*
• &chaine_debug est de type char (*)[70]

char *chaine_debug = calloc ( 71, 1 );

• chaine_debug est un pointeur, pointant vers une zone mémoire allouée de 71 octets minimum (en supposant que calloc() n'échoue pas).
• Une variable locale de ce type sera en mémoire automatique, mais les données allouées, elles, (les 71 char) seront sur le tas
• sizeof(chaine_debug) retournera sizeof(char*), soit 4 sur une machine 32 bits.
• chaine_debug est de type char*, implicitement convertible en char const*
• &chaine_debug est de type char **

Edit: Tiens, cette fois c'est moi qui me suis fait doublement griller (et pas qu'un peu)...

1) bien sûr pour la pile etc..
2) bien sûr pour le sizeof (bien que je ne l'utlise jamais comme ça)
3) cependant, d'après K&R :

Citation:

---

The correspondence between indexing and pointer arithmetic is very close. By definition, the value of a variable or expression of type array is the address of element zero of the array. Thus after the assignment
pa =
*
pa and a have identical values. Since the name of an array is a synonym for the location of the initial element, the assignment pa=&a[0] can also be written as
pa = a;

---

Citation:

---

There is one difference between an array name and a pointer that must be kept in mind. A pointer is a variable, so pa=a and pa++ are legal. But an array name is not a variable;

---

Citation:

---

5.3 Pointers and Arrays

are equivalent; we prefer the latter because it says more explicitly that the variable is a pointer.

---

Donc quand stephl dit :

Citation:

---

Le & devant un nom de tableau n'est pas utilisé normalement, cependant ce n'est pas une erreur et &a signifie a si a est un tableau.

---

ça ne correspond pas à ce que dit K&R ....

D'après la première citation :

pa = a = &a[0]

donc

&a = &(&a[0]) = &pa = char **

8O

Citation:

---

Envoyé par souviron34

Donc quand stephl dit ...
ça ne correspond pas à ce que dit K&R ....

---

Ce que je veux dire, c'est que si a est un tableau, alors a et &a ont la même valeur. K&R est aussi ma référence, et si j'ai bonne mémoire, ils ne s'amusent pas à coller un & devant un tableau pour savoir quel type est obtenu; ils précisent juste que ce n'est pas une erreur, mais que c'est inutile et illogique.

Toujours K&R2, Annexe A7.1 du manuel de référence:

Citation:

---

Envoyé par K&R2

Si une expression ou une sous-expression est de type "tableau de T", où T est un type donné, alors la valeur de cette expression est un pointeur sur le premier élément du tableau, et le type de l'expression se transforme en "pointeur sur T". Cette convertion n'a pas lieu si l'expression est l'opérande d'un des opérateurs unaires &, ++, --, ou sizeof, ou l'opérande de gauche d'un opérateur d'affectation ou de l'opérateur ".".

---

K&R2 est aussi aussi ma référence. Soit donc

Code:

---

T tableau[70];

---

L'idée de convertion implicite d'une expression de type tableau-sur-T y appraît de manière explicite, de même que la différence entre tableau et &tableau.

EDIT: Voir également §6.3.2.1 de la norme du langage qui donne les mêmes informations.

Thierry

Citation:

---

Envoyé par souviron34

1) bien sûr pour la pile etc..
2) bien sûr pour le sizeof (bien que je ne l'utlise jamais comme ça)
3) cependant, d'après K&R :

---

J'ai pas le temps de repondre en detail pour le moment. Je te suggere en attendant la lecture de A.7.1 en tenant compte de l'errata: http://www.cs.bell-labs.com/cm/cs/cbook/2ediffs.html. Tres rapidement il faut faire la difference entre le tableau a et le resultat de l'evaluation de l'expression a et tenir compte du fait qu'il s'agit d'une explication informelle. (EDIT: Thierry cite A.7.1 mais ne tient pas compte de l'errata).

Citation:

---

Donc quand stephl dit :

Citation:

---

Envoyé par stephl

Le & devant un nom de tableau n'est pas utilisé normalement, cependant ce n'est pas une erreur et &a signifie a si a est un tableau.

---

---

Je ne suis pas d'accord avec stephl ici. Les expressions a et &a n'ont pas le meme type meme si elles designent la meme adresse.

Citation:

---

pa = a = &a[0]

donc

&a = &(&a[0]) = &pa = char **

8O

---

Le type de &a est char (*)[N]. Essaie

Code:

---

1 2 3 4 5

void f() { char a[10]; char** p1 = &a; char (*p2)[10] = &a; }

---

dans un compilateur. Moi j'ai

Citation:

---

Envoyé par http://www.comeaucomputing.com/tryitout/

"ComeauTest.c", line 3: error: a value of type "char (*)[10]" cannot be used to
initialize an entity of type "char **"
char **p1 = &a;

---

Citation:

---

Envoyé par souviron34

&a = &(&a[0]) = &pa = char **

---

La 1ère égalité ne joue pas, car, selon la citation de K&R2 que j'ai donné plus haut, l'expression a n'est pas convertie en (char *) lorsqu'elle est précédée de l'opérateur unaire &. Ainsi, l'expression &(&a[0]) est effectivement de type char**, mais l'expression &a est de type char (*)[].

Thierry

Merci pour ces précisions. Je ne voulais pas parler de l'annexe A qui est très claire et précise, mais des autres chapitres du livre, et notamment celui sur les pointeurs et tableaux (chapitre 5 de mémoire).
Cependant, à la lumière de votre citation de l'annexe A, il apparaît donc que si "a" est un tableau, alors "&a" est (comme vous l'avez spécifié précédemment) du type pointeur sur tableau puisque la conversion en char * n'a pas lieu.
Bref, mon but n'était pas de déclencher une polémique. Je ne m'étais jamais vraiment préoccupé de savoir quel était le type de "&a", comprenant que cette expression était assez illogique et que "a" était l'information voulue. L'objectif de mon tout premier post était simplement de préciser que l'erreur ne venait pas du fait qu'il y ait un '&' devant un nom de tableau.
En tout cas, merci d'avoir comblé mes lacunes sur le type de "&a" :D .

Citation:

---

Envoyé par Jean-Marc.Bourguet

Je ne suis pas d'accord avec stephl ici. Les expressions a et &a n'ont pas le meme type meme si elles designent la meme adresse.

---

Encore une fois, je voulais juste dire que a et &a ont la même valeur. Pardon si je me suis mal exprimé.
Quoi qu'il en soit, je préfère me dire qu'un tableau n'est pas une variable à part entière (en effet, ce n'est pas une lvalue) et donc que je n'ai pas à chercher à avoir son adresse. Pour moi, "&a" a la même valeur que "a" mais est illogique. De même, je n'apprécie guère les expressions du genre &(&a[0]). &a[0] est pour moi une valeur et une valeur n'a pas d'adresse.

Mais il me semble que a et &a[0] ne sont pas réellement équivalents: &a[0] doit être de type T*, contrairement à a qui est de type T[N] implicitement convertible en T*

Ce qui explique que a est un tableau et possède une adresse, alors que &a[0] n'est pas une lvalue...

Citation:

---

Envoyé par stephl

Encore une fois, je voulais juste dire que a et &a ont la même valeur.

---

Je n'en suis pas sur. On risque d'entrer dans un debat tres technique sur la notion de valeur dans la norme. Si j'ai bonne memoire

Code:

---

assert((void*)a == (void*)&a);

---

peut echouer.

Citation:

---

Pardon si je me suis mal exprimé.
Quoi qu'il en soit, je préfère me dire qu'un tableau n'est pas une variable à part entière (en effet, ce n'est pas une lvalue) et donc que je n'ai pas à chercher à avoir son adresse. Pour moi, "&a" a la même valeur que "a" mais est illogique.

---

Code:

---

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

void f(char (*ptr)[10], int cnt) { int i; for (i = 0; i < cnt; ++i) { int j; for (j = 0; j < 10; ++j) { (*ptr)[j] = 0; } ++ptr; } }   void g() { char a[10]; char b[5][10]; f(&a, 1); f(b, sizeof b/sizeof *b); }

---

Citation:

---

De même, je n'apprécie guère les expressions du genre &(&a[1]). &a[1] est pour moi une valeur et une valeur n'a pas d'adresse.

---

Ca, ca ne devrait pas passer a la compilation.

Citation:

---

Envoyé par Médinoc

Ce qui explique que a est un tableau et possède une adresse...

---

Si vous voulez, c'est sûrement dans la norme. Je préfère me dire que la valeur de "a" est l'adresse du premier élément (&a[0]) et ne jamais utiliser "&a".

Citation:

---

Envoyé par Jean-Marc.Bourguet

Ca, ca ne devrait pas passer a la compilation.

---

Je sais; c'est pourtant ce qui a été écrit dans certains messages précédents.

Citation:

---

Envoyé par stephl

Si vous voulez, c'est sûrement dans la norme. Je préfère me dire que la valeur de "a" est l'adresse du premier élément (&a[0]) et ne jamais utiliser "&a".

---

La valeur de la variable a est le tableau complet; seulement les tableaux ne sont pas des types bien traite en C ce qui fait que la valeur de l'expression a est bien la meme que celle que de l'expression &a[0] sauf si a est un argument de & ou de sizeof (comme le a de l'expression &a[0]).

On peut utiliser &a quand on veut un pointeur sur tableau.
Utile dans la déclaration d'une fonction pour s'assurer que le tableau a une taille donnée:

Code:

---

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

void EcritDansTableau(int (*pTab)[10]) { int *pVal = *pTab; /*conversion implicite int[10] -> int* */ size_t i; for(i=0 ; i<10 ; i++) pVal[i] = (int)(i*2); }   int main(void) { int tab1[8]; int tab2[10]; int tab3[12];   EcritDansTableau(&tab1); /* Echec, trop petit */ EcritDansTableau(&tab2); /* OK */ EcritDansTableau(&tab3); /* Echec, trop grand */   return 0; }

---

Edit: Bizarre, sous Visual 2005, je n'ai droit qu'à des warnings:

Citation:

---

1>c:\<snip>\testarrayc.c(132) : warning C4048: different array subscripts : 'int (*)[10]' and 'int (*__w64 )[8]'
1>c:\<snip>\testarrayc.c(134) : warning C4048: different array subscripts : 'int (*)[10]' and 'int (*__w64 )[12]'

---

Edit2: Jean-Marc : Parfait :king:

Citation:

---

Envoyé par http://www.comeaucomputing.com/tryitout

Code:

---

1 2 3 4 5 6 7 8 9

"ComeauTest.c", line 15: error: argument of type "int (*)[8]" is incompatible with parameter of type "int (*)[10]" EcritDansTableau(&tab1); /* Echec, trop petit */ ^   "ComeauTest.c", line 17: error: argument of type "int (*)[12]" is incompatible with parameter of type "int (*)[10]" EcritDansTableau(&tab3); /* Echec, trop grand */ ^

---

---

Citation:

---

Envoyé par Jean-Marc.Bourguet

La valeur de la variable a ... la valeur de l'expression a

---

Selon moi, c'est la même chose.

Citation:

---

Envoyé par stephl

Selon moi, c'est la même chose.

---

Libre à toi... Mais ce n'est pas le cas.

Thierry

Citation:

---

Envoyé par Jean-Marc.Bourguet

Je n'en suis pas sur. On risque d'entrer dans un debat tres technique sur la notion de valeur dans la norme. Si j'ai bonne memoire

Code:

---

assert((void*)a == (void*)&a);

---

peut echouer.

---

Là, je ne vois pas pourquoi, mais si tu trouve le temps de détailler un peu plus, ça m'intéresse. Merci pour ces remarques intéressantes.

Thierry

Citation:

---

Envoyé par mujigka

Libre à toi... Mais ce n'est pas le cas.

Thierry

---

Et quelle différence faites-vous entre valeur d'une variable et valeur d'une expression? C'est la première fois que j'entends cette distinction et je ne crois pas qu'elle figure dans le K&R.

Citation:

---

Envoyé par stephl

Et quelle différence faites-vous entre valeur d'une variable et valeur d'une expression? C'est la première fois que j'entends cette distinction et je ne crois pas qu'elle figure dans le K&R.

---

Le point est qu'il y a une conversion implicite qui entre en jeu. J'aurais pu ecrire de meme

Code:

---

1 2 3 4

double d= 5.1; f(int);   f(d)

---

La valeur de la variable d est 5.1 mais la valeur de l'expression d dans f(d) est de 5 mais ca semble moins naturel (peut-etre parce que la conversion implicite flottant->int n'est pas aussi souvent presente que la conversion T[] vers T*).

Citation:

---

Envoyé par stephl

Et quelle différence faites-vous entre valeur d'une variable et valeur d'une expression? C'est la première fois que j'entends cette distinction et je ne crois pas qu'elle figure dans le K&R.

---

Pour moi, la valeur est toujours associée à un type. Or c'est un fait qu'en C, et là K&R2 et la norme convergent, le type de a n'est pas le même que le type de l'expression a, car une convertion implicite a lieu dans ce dernier cas. C'est peut-être pédant, mais on est sur un forum technique, et il convient d'être précis.

Thierry

La valeur de l'expression "d" est indépendante de l'expression (plus large) dans laquelle elle intervient. La valeur de l'expression "d" est toujours 5.1; le cast implicite intervient seulement après. Je crois que je ne saisis pas la différence que vous faites entre valeur de variable et valeur d'expression. C'est trop abstrait pour moi.

Citation:

---

Envoyé par mujigka

Là, je ne vois pas pourquoi, mais si tu trouve le temps de détailler un peu plus, ça m'intéresse. Merci pour ces remarques intéressantes.

---

C'est le meme genre de raisonnement qui fait que

Code:

---

1 2 3 4 5

char a[10][65536]; char* ptr=&a[5][65535]; ++ptr; *ptr='x';

---

est du comportement indefini parce qu'on accede a l'element qui suit le dernier dans un tableau (donc avec une architecture segmentee et des segments de tailles 65536, le compilateur peut supposer tout en etant conforme que l'incrementation ne peut pas changer de segment).

Les pointeurs en C sont en fait des paires objet tableau de quelque chose, indice dans un tel objet. a a pour valeur le tableau a (de type char[10]), indice 0; &a a pour valeur le table de type char[1][10] dont le premier element est a, indice 0.

Citation:

---

Envoyé par mujigka

Pour moi, la valeur est toujours associée à un type. Or c'est un fait qu'en C, et là K&R2 et la norme convergent, le type de a n'est pas le même que le type de l'expression a, car une convertion implicite a lieu dans ce dernier cas. C'est peut-être pédant, mais on est sur un forum technique, et il convient d'être précis.

Thierry

---

D'accord pour le type, j'ai bien compris avec vos différentes explications, mais ici il s'agit de la valeur: valeur de variable et valeur d'expression.

Citation:

---

Envoyé par stephl

La valeur de l'expression "d" est indépendante de l'expression (plus large) dans laquelle elle intervient. La valeur de l'expression "d" est toujours 5.1; le cast implicite intervient seulement après. Je crois que je ne saisis pas la différence que vous faites entre valeur de variable et valeur d'expression.

---

Comme je l'ai ecrit, pour d ca passe plus difficilement. On peut sans probleme -- c'est meme plus rigoureux -- considerer que la valeur de a n'est jamais le pointeur vers son premier element. C'est toujours le tableau complet.

Citation:

---

C'est trop abstrait pour moi.

---

Ce n'est pas de l'abstraction, c'est une concession a la pratique observee.

Citation:

---

Envoyé par mujigka

Pour moi, la valeur est toujours associée à un type.

---

La valeur de 0 et la valeur de 0.0 est bien la meme, meme si les types sont differents, meme si les representations sont differentes.

La valeur de (void*)&x et de &x sont bien les memes, meme si les types sont differents, meme si les representations sont differentes.

Sans parler du fait que les valeurs ayant plusieurs types, c'est la definition meme du polymorphismes d'inclusion qui une des composantes indispensables de l'OO.

Citation:

---

Envoyé par Jean-Marc.Bourguet

Le type de &a est char (*)[N]. Essaie

Code:

---

1 2 3 4 5

void f() { char a[10]; char** p1 = &a; char (*p2)[10] = &a; }

---

dans un compilateur. Moi j'ai

---

Code:

---

1 2	main.c: In function `main': main.c:4: warning: initialization from incompatible pointer type

---

Citation:

---

Envoyé par Jean-Marc.Bourguet

C'est le meme genre de raisonnement qui fait que

Code:

---

1 2 3 4 5

char a[10][65536]; char* ptr=&a[5][65535]; ++ptr; *ptr='x';

---

est du comportement indefini parce qu'on accede a l'element qui suit le dernier dans un tableau (donc avec une architecture segmentee et des segments de tailles 65536, le compilateur peut supposer tout en etant conforme que l'incrementation ne peut pas changer de segment).

Les pointeurs en C sont en fait des paires objet tableau de quelque chose, indice dans un tel objet. a a pour valeur le tableau a (de type char[10]), indice 0; &a a pour valeur le table de type char[1][10] dont le premier element est a, indice 0.

---

Merci! C'est vrai que là, c'est un peu trop technique pour moi et j'ai du mal à saisir le mécanisme que tu décris.

Thierry

Citation:

---

Envoyé par Emmanuel Delahaye

Code:

---

1 2	main.c: In function `main': main.c:4: warning: initialization from incompatible pointer type

---

---

Ajoute -pedantic-errors a tes options de gcc.

Citation:

---

Envoyé par Médinoc

Mais il me semble que a et &a[0] ne sont pas réellement équivalents: &a[0] doit être de type T*, contrairement à a qui est de type T[N] implicitement convertible en T*

Ce qui explique que a est un tableau et possède une adresse, alors que &a[0] n'est pas une lvalue...

---

Bon, ben voilà, cette fois je crois j'ai compris...

Merci.

Merci pour toutes ces explications. J'aurai au moins appris que l'on peut utiliser & devant un nom de tableau, même si je continuerai à éviter de le faire (chacun ses goûts).

Citation:

---

Envoyé par Médinoc

Code:

---

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

void EcritDansTableau(int (*pTab)[10]) { int *pVal = *pTab; /*conversion implicite int[10] -> int* */ size_t i; for(i=0 ; i<10 ; i++) pVal[i] = (int)(i*2); }   int main(void) { int tab1[8]; int tab2[10]; int tab3[12];   EcritDansTableau(&tab1); /* Echec, trop petit */ EcritDansTableau(&tab2); /* OK */ EcritDansTableau(&tab3); /* Echec, trop grand */   return 0; }

---

---

Code:

---

1 2 3 4

main.c: In function `main': main.c:17: warning: passing arg 1 of `EcritDansTableau' from incompatible pointer type main.c:19: warning: passing arg 1 of `EcritDansTableau' from incompatible pointer type

---

Je n'aurait pas osé ne faire

Code:

---

int *pVal = *pTab; /*conversion implicite int[10] -> int* */

---

mais c'est correct et logique.

Au fait, on peut utiliser es propriétés du type tableau pour déterminer la taille de l'objet pointé :

Code:

---

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

#include <stdio.h>   void EcritDansTableau (int (*pTab)[10]) { int *pVal = *pTab; /*conversion implicite int[10] -> int* */ size_t i; for (i = 0; i < sizeof *pTab / sizeof **pTab; i++) pVal[i] = (int) (i * 2); }   void AfficherTableau (int const (*pTab)[10]) { int const *pVal = *pTab; /*conversion implicite int[10] -> int* */ size_t i; for (i = 0; i < sizeof *pTab / sizeof **pTab; i++) printf ("%4d", pVal[i]); printf ("\n"); }   int main (void) { int tab2[10];   EcritDansTableau (&tab2); AfficherTableau (&tab2);   return 0; }

---

Par contre j'ai un problème avec le const. Il doit être mal placé...

Code:

---

1 2 3

main.c: In function `main': main.c:25: warning: passing arg 1 of `AfficherTableau' from incompatible pointer type

---

et la maintenance est cauchemardesque, à moins d'utiliser un type tableau...

Code:

---

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

#include <stdio.h>   typedef int int_a [10];   void EcritDansTableau (int_a *pTab) { int *pVal = *pTab; /*conversion implicite int[10] -> int* */ size_t i; for (i = 0; i < sizeof *pTab / sizeof **pTab; i++) pVal[i] = (int) (i * 2); }   void AfficherTableau (int_a const *pTab) { int const *pVal = *pTab; /*conversion implicite int[10] -> int* */ size_t i; for (i = 0; i < sizeof *pTab / sizeof **pTab; i++) printf ("%4d", pVal[i]); printf ("\n"); }   int main (void) { int tab2[10];   EcritDansTableau (&tab2); AfficherTableau (&tab2);   return 0; }

---

mais j'ai le même problème de constantness...

Citation:

---

Envoyé par mujigka

Merci! C'est vrai que là, c'est un peu trop technique pour moi et j'ai du mal à saisir le mécanisme que tu décris.

---

Comme je l'ai ecrit, je ne suis pas sur a 100% de moi sur ca.

Dans le meme genre de chose (mais la je suis beaucoup plus sur)

Code:

---

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

struct a { char c; }; struct b {char c; char d; }; union u { struct a a; struct b b }; char getCFromA(struct a) { return a.c; }   char getCFromU(union u) { return u.a.c; } union uu; ... uu.b.c = 'a';

---

Alors getCFromA(uu.a) n'est pas conforme tandis que getCFromU(uu) l'est.