Twitter iPhone pliant OnePlus 11 PS5 Disney+ Orange Livebox Windows 11

les pointeurs ou les emp

2 réponses
Avatar
heron maladroit
/*d'apr=C3=A8s K&R 2 : "there is one difference between an array name and a
pointer that must be kept in mind. A pointer is a variable , so pa =3D a
and pa++ are legal. But an array name is not a variable. constructions
like a=3Dpa and a++ are illegal. Je veux juste avoir une id=C3=A9e des
messages d'erreur relatifs aux pointeurs pour l'instant au niveau des
chaines de caract=C3=A8res. */

#include <stdio.h>
int main(void)
{
char Chaine[10] =3D "abc" ;
char *Chaine2[] =3D {"abc", "def" }; /* 2 pointeurs sur Char ... */

printf("\n%s", Chaine) ; /* A : OK */
printf("\n%s", *Chaine) ; /* B : warning: format =E2=80=98%s=E2=80=99 exp=
ects type
=E2=80=98char *=E2=80=99, but argument 2 has type =E2=80=98int=E2=80=99 .=
.. Segmentation fault :
*/
printf("\n%s", *(Chaine+0) ) ; /* C : warning: format =E2=80=98%s=E2=80=99=
expects
type =E2=80=98char *=E2=80=99, but argument 2 has type =E2=80=98int=E2=80=
=99 ... Segmentation
fault : */
printf("\n%c", *(Chaine+0) ) ; /* D: OK */
printf("\n%s", Chaine+0 ) ; /* E : OK */
printf("\n%s", Chaine+1 ) ; /* F : OK */
printf("\n%s", &Chaine ) ; /* G : warning: format =E2=80=98%s=E2=80=99 exp=
ects type
=E2=80=98char *=E2=80=99, but argument 2 has type =E2=80=98char (*)[10]=E2=
=80=99 ... OK */
printf("\n%s", &Chaine[0] ) ; /* H: OK */

/*CHAINE 2 */

printf("\n%s", &Chaine2) ; /* I : warning: format =E2=80=98%s=E2=80=99 exp=
ects type
=E2=80=98char *=E2=80=99, but argument 2 has type =E2=80=98char * (*)[2] ..=
. r=C3=A9sultat
ind=C3=A9termin=C3=A9*/
printf("\n%o", &Chaine2) ; /* J : warning: format =E2=80=98%o=E2=80=99 exp=
ects type
=E2=80=98unsigned int=E2=80=99, but argument 2 has type =E2=80=98char * (*)=
[2] ... r=C3=A9sultat :
27776137614 */
printf("\n%c", *Chaine2[1]) ; /* K : warning: format =E2=80=98%c=E2=80=99=
expects
type =E2=80=98int=E2=80=99, but argument 2 has type =E2=80=98char **=E2=80=
=99... r=C3=A9sultat : vide */
printf("\n%s", Chaine2[0]) ; /* L : OK */
printf("\n%s", Chaine2) ; /* M : warning: format =E2=80=98%s=E2=80=99 expe=
cts type
=E2=80=98char *=E2=80=99, but argument 2 has type =E2=80=98char **=E2=80=99=
...resultat : =EF=BF=BD=EF=BF=BD=EF=BF=BD=EF=BF=BDE#abc */

printf("\n\n") ;
return 0 ;
}

/*
A :
Resultat : abc

Je comprends ici que Chaine est un tableau (ou une chaine constante
pour =C3=AAtre plus pr=C3=A9cis?).
Le paragraphe suivant l'extrait du K&R pr=C3=A9c=C3=A9dent dis que lorsqu'u=
n nom
de tableau est envoy=C3=A9 =C3=A0 une fonction, c'est l'emplacement du
1er =C3=A9l=C3=A9ment qui est envoy=C3=A9... et =C3=A0 l'int=C3=A9rieur de =
cette fonction, cet
argument est une variable locale

Je ne comprends pas que pour printf avec %s, * ou le contenu de Chaine
ne soit pas appel=C3=A9 mais ce qui me semble =C3=AAtre l'adresse en m=C3=
=A9moire de
Chaine comme lorsqu'on passe char *pointeur ; pointeur =3D Chaine ou
pointeur =3D &Chaine[0]. Le point H va dans ce sens

Ce premier cas est celui qui me fait toujours r=C3=A9fl=C3=A9chir et peut m=
e
donner une erreur . Surtout que dans ce cas scanf ajoute de l'insulte
=C3=A0 la blessure car : scanf("%s", Chaine) au lieu de scanf("%s",
&Chaine) comme on peut s'y attendre ;

char Chaine[10] ;
printf("\nEntrez une chaine : ") ;
scanf("%s", &Chaine[0]) OK MAIS scanf("%s", &Chaine) affiche
warning: format =E2=80=98%s=E2=80=99 expects type =E2=80=98char *=E2=80=99,=
but argument 2 has type
=E2=80=98char (*)[10]=E2=80=99 mais la saisie se fait quand m=C3=AAme

B :
Resultat : Segmentation fault

Le warning dit que le 2=C3=A8me argument est de type int.
Ce n'est pas la premi=C3=A8re fois que j'ai ce message. Est-ce que je dois
comprendre que dans printf, %s est le 1er argument, et *Chaine est le
second? Alors comme le pointeur *Chaine n'a pas =C3=A9t=C3=A9 d=C3=A9clar=
=C3=A9, *Chaine
est de type int par d=C3=A9faut ?
Ensuite, le K et R dis pour pa =3D a ...un tableau constant a[i] peut
aussi s'=C3=A9crire *(a+i) pourquoi pas *a (soit le contenu de a) avec %s
affiche une chaine?

C :
Resultat : Segmentation fault

Resultat identique si *(Chaine+1), *(Chaine+2), *(Chaine+3) etc...
*(Chaine+9)
L'argument %s semble ici bloquer le d=C3=A9roulement du programme. Ca
para=C3=AEt coh=C3=A9rent avec %c dans printf :

D :
Resultat : a

E:
Resultat : abc

F:
Resultat : bc

G :
Resultat : abc

1ere fois que je vois ce warning, je dois avouer que je n'avais pas
penser =C3=A0 appeler un tableau d'une chaine constante ou d'entier avec
l'adresse &. Le '&' est =C3=A0 mes yeux associ=C3=A9 aux pointeurs. A ma gr=
ande
surprise, le code fonctionne. En tant que d=C3=A9butant avec le langage C,
je trouve int=C3=A9ressant le warning: il montre bien qu'un tableau est un
pointeur vers le type de donn=C3=A9es dans lequel il a =C3=A9t=C3=A9 d=C3=
=A9finit/d=C3=A9clar=C3=A9
ici : char (*)[10], c=C3=A0d 10 pointeurs vers des donn=C3=A9es de type
caract=C3=A8res?

H:
Resultat : abc


I :
Resultat : des carr=C3=A9s s'affichent : =10=EF=BF=BD`=EF=BF=BD=04 et abc

Je suppose que c'est la repr=C3=A9sentation d'emplacements m=C3=A9moire (vo=
ir I)

J:
Resultat : 27776137614

Le message confirme que ce sont bien 2 pointeurs sur char
Je suppose que c'est l'adresse de *Chaine2 repr=C3=A9sent=C3=A9e sous la fo=
rme
d'un entier?

K :
Resultat : abc

Je ne comprends pas l'erreur "invalid initializer". Pourtant le code
fonctionne m=C3=AAme avec : *Chaine[0], *Chaine[20]...

L :
Resultat : abc

error: invalid initializer
error: expected expression before =E2=80=98]=E2=80=99 token
error: array subscript is not an integer
warning: format =E2=80=98%c=E2=80=99 expects type =E2=80=98int=E2=80=99, bu=
t argument 2 has type =E2=80=98char
*=E2=80=99

Et pourtant =C3=A7a fonctionne.
Invalid initializer est dans J alors je suppose que la r=C3=A9ponse
pr=C3=A9c=C3=A9dente satisfait la question pr=C3=A9sente.
expected expression ... : je comprends que je dois mettre un indice
entre [ ] . Dans J, les indices ne me semblent pas utiles et ici, ils
seraient utiles?
array subscript is not an integer : je ne comprends pas
warning : format %c expects type int ... : selon moi, %c attend un
caract=C3=A8re et non pas un int ...

M:
Resultat in=C3=A9dit : =EF=BF=BD=EF=BF=BD=EF=BF=BD=EF=BF=BDE#abc
warning: format =E2=80=98%s=E2=80=99 expects type =E2=80=98char *=E2=80=99,=
but argument 2 has type
=E2=80=98char **=E2=80=99
Je ne suis pas s=C3=BBre de comprendre.

-o-

Je vais arr=C3=AAter l=C3=A0 =C3=A9tant arriv=C3=A9 =C3=A0 la moiti=C3=A9 d=
e l'alphabet et les
besoins physiologiques se font pressant...surtout que le tableau
multidimensionnel chaine2 permet encore d'autres combinaisons...

*/

2 réponses

Avatar
-ed-
On 6 juin, 23:19, heron maladroit wrote:
        char Chaine[10] = "abc" ;
        char *Chaine2[] = {"abc", "def" }; /*  2 pointeurs su r Char ...  */



Les chaines étant par défaut, non modifiables en C, on préfère rest er
cohérent et portable comme ceci :

char const *Chaine2[] = {"abc", "def" }; /* 2 pointeurs sur
char ... */

D'autre part, il n'y a pas de type 'Char' en C standard. C'est 'char'.

        printf("n%s", Chaine) ; /* A : OK */



Le 'n' indique la fin de ligne, il se place donc ... en fin de
ligne !

printf ("%sn", Chaine); /* A : OK */

en effet, il force l'émission des caractères. Sinon, le caractères
placés après risquent de ne pas être émis ...

        printf("n%s", *Chaine) ; /* B :  warning: format ‘%s ’ expects type
‘char *’, but argument 2 has type ‘int’   ...   Segmentation fault :
*/



Ben oui, normal. *Chaine ou *(Chaine + 0) ou encore Chaine[0], désigne
un caractère (type char), qui est automatiquement converti en int. Cet
int n'a quasiment aucune chance d'être une adresse valide ("%s"
attends l'adresse d'une chaine de caractères). Tu veux peut être "%c"
pour voir le caractère ?


        printf("n%s", *(Chaine+0) ) ; /* C : warning: format ‘ %s’ expects
type ‘char *’, but argument 2 has type ‘int’ ...   Segmentation
fault : */



Même problème

        printf("n%c", *(Chaine+0) ) ; /* D: OK  */
        printf("n%s", Chaine+0 ) ; /* E : OK */
        printf("n%s", Chaine+1 ) ; /* F : OK */

        printf("n%s", &Chaine ) ; /* G : warning: format ‘%s ’ expects type
‘char *’, but argument 2 has type ‘char (*)[10]’ ... OK */



Non, pas OK. Le comportement est indéfini. On ne fait pas ça.

        printf("n%s", &Chaine[0] ) ;      /* H: OK */

        /*CHAINE 2 */

        printf("n%s", &Chaine2) ; /* I : warning: format ‘%s ’ expects type
‘char *’, but argument 2 has type ‘char * (*)[2] ... résultat
indéterminé*/



Oui, carrément n'importe quoi ...

        printf("n%o", &Chaine2) ; /* J : warning: format ‘%o ’ expects type
‘unsigned int’, but argument 2 has type ‘char * (*)[2] ... résult at :
27776137614 */



Pareil. Tu programmes au hasard ? Tu testes le compilateur ? Pourquoi
"%o" ? Tu trouves que l'octal est adapté ?

        printf("n%c", *Chaine2[1])  ; /* K : warning: format ‘%c’ expects
type ‘int’, but argument 2 has type ‘char **’... résultat : vid e */



Oui, portnawak ...

        printf("n%s", Chaine2[0]) ;  /* L : OK */

        printf("n%s", Chaine2) ; /* M : warning: format ‘%s’ expects type
‘char *’, but argument 2 has type ‘char **’ ...resultat : E#abc * /



Non, résultat indéfini, c'est tout ...

Il manque :

printf("%sn", Chaine2[1]) ; /* O : OK */



        printf("nn") ;



Pas très utile si on prends soin de mettre le 'n' à la fin de l
ligne, comme il se doit ...

        return 0 ;

}

/*
A :
Resultat : abc

Je comprends ici que Chaine est un tableau (ou une chaine constante
pour être plus précis?).



C'est un tableau de char initialisé modifiable. Sa valeur est
{'a','b','c',0,0,0,0,0,0,0}

Le paragraphe suivant l'extrait du K&R précédent dis que lorsqu'un no m
de tableau est envoyé à une fonction, c'est l'emplacement du
1er élément qui est envoyé...



Oui, c'est à dire une adresse. L'adresse du premier élément du tablea u
si c'est le nom seul (<nom> ou <nom> + 0)

et à l'intérieur de cette fonction, cet
argument est une variable locale



Oui, comme tous les arguments. Ici, c'est une variable locale de type
'adresse de char', dont un pointeur sur char (char *s, par exemple).

Je ne comprends pas que pour printf avec %s, * ou le contenu de


Chaine
ne soit pas appelé mais ce qui me semble être l'adresse en mémoire de
Chaine comme lorsqu'on passe char *pointeur ;  pointeur = Chaine ou
pointeur = &Chaine[0]. Le point H va dans ce sens



Comme expliqué précédemment, "%s" attend l'adresse d'un tableau de
char initialisé avec une chaine, donc terminée par un 0. Si on lui
passe autre chose (*Chaine, par exemple), le comportement est
indéfini.

Ce premier cas est celui qui me fait toujours réfléchir et peut me
donner une erreur .



Y'a pas trop à réfléchir. Une fois qu'on sait ce qu'attend é%s", to ut
est clair. Et c'est pareil avec scanf() (sauf que c'est la taille qui
importe et non le contenu).

Surtout que dans ce cas scanf ajoute de l'insulte
à la blessure car : scanf("%s", Chaine) au lieu de scanf("%s",
&Chaine) comme on peut s'y attendre ;



Pourquoi & ? On a expliqué en long en large et travers que quand on
passait le nom d'un tableau à une fonction, celui-ci était convertit
en adresse du premier élément. On peut donc mettre :

scanf("%s", Chaine)
ou
scanf("%s", Chaine + 0)
ou
scanf("%s", &Chaine[0])
si on aime la complication.

Attention, cette saisie est dangereuse et pas paratique, car elle
prend tout jusqu'au premier séparateur (espace, tab ou fin de ligne).


        char Chaine[10] ;
        printf("nEntrez une chaine : ") ;
        scanf("%s", &Chaine[0]) OK  MAIS scanf("%s", &Chaine) a ffiche
warning: format ‘%s’ expects type ‘char *’, but argument 2 has ty pe
‘char (*)[10]’ mais la saisie se fait quand même



A tes risques et périls. Le comportement est indéterminé. On a déj à
fort affaire avec les comportements normaux. Ne pas perdre de temps
avec les comportements non définis ... Enfin, tu as voulu faire du
C...

B :
Resultat : Segmentation fault

Le warning dit que le 2ème argument est de type int.
Ce n'est pas la première fois que j'ai ce message. Est-ce que je dois
comprendre que dans printf, %s est le 1er argument, et *Chaine est le
second?



Ben oui. C'est pas évident ?

Alors comme le pointeur *Chaine n'a pas été déclaré, *Chaine
est de type int par défaut ?



Attention. Le rôle de * change selon le contexte.

Il sert

- soit d'opérateur de multiplication quand il est placé entre 2
opérandes : a * 2, a * b etc.
- soit de déclarateur de pointeur dans une déclaration de variable :
int *p; char const *s="hello"
- soit d'opérateur de déréférencement quand il est appliqué à u n
pointeur : inc c = *s, f (*s) etc.

ici, c'est le 3 ème cas. *Chaine est *(Chaine + 0), c'est à dire
Chaine[0]. C'est donc un caractère qui n'a rien à voir avec une
adresse. Le type est int, parce que l'appel de fonction avec un
paramètre de type char est convertit en int.

Ensuite, le K et R dis pour pa = a ...un tableau constant a[i] peut
aussi s'écrire *(a+i) pourquoi pas *a (soit le contenu de a) avec %s
affiche une chaine?



Parce que dans ce cas, *a (valeur pointée par a) désigne un caractère
et non une adresse ...

C :
Resultat : Segmentation fault

Resultat identique si *(Chaine+1), *(Chaine+2), *(Chaine+3) etc...
*(Chaine+9)
L'argument %s semble ici bloquer le déroulement du programme. Ca
paraît cohérent avec %c dans printf :

D :
Resultat : a

E:
Resultat : abc

F:
Resultat : bc

G :
Resultat : abc



Bah oui, normal. "%c" attend un int qui représente la valeur d'un
caractère. Si on lui donne ce qu'il attend, tout va bien...

1ere fois que je vois ce warning, je dois avouer que je n'avais pas
penser à appeler un tableau d'une chaine constante ou d'entier avec
l'adresse &. Le '&' est à mes yeux associé aux pointeurs.



Peut importe. La réalité est que & est un opérateur qui retourne une
valeur et un type. La valeur est l'adresse d'un objet. Le type
retourné est 'pointeur sur le type de l'objet'. Appliqué à un tableau ,
ça retourne l'adresse du tableau (comme en C, le premier élément d'un
tableau se trouve en [0], la valeur est la même qu'avec le nom du
tableau), mais le type est différent. Ailiet de retourner le type
'pointeur sur un élément du tableau', on retourne 'pointeur sur le
tableau' ce qui est très différent, et peut avoir des conséquences
terribles si on utilise un offset : Chaine + 1 n'a pas du tout la même
valeur que &Chaine+1.

A ma grande
surprise, le code fonctionne.



Oui, la valeur est la même. "Ça tombe en marche" ... Mais c'est faux
pour les raisons déjà expliquées.

En tant que débutant avec le langage C,
je trouve intéressant le warning: il montre bien qu'un tableau est un
pointeur vers le type de données dans lequel il a été définit/d éclaré
ici : char (*)[10], càd 10 pointeurs vers des données de type
caractères?



Oui, les warnings essayent d'aider à comprendre les subtilités du C...
Mais pourquoi tu ne fais pas du Pascal ...

H:
Resultat : abc

I :
Resultat : des carrés s'affichent :   `  et abc

Je suppose que c'est la représentation d'emplacements mémoire (voir I )

J:
Resultat : 27776137614



Des comportements indéfinis ...

Le message confirme que ce sont bien 2 pointeurs sur char
Je suppose que c'est l'adresse de *Chaine2 représentée sous la forme
d'un entier?



Oui, en octal... Quelle idée. Le bon format pour une adresse est "%p"
et il faut forcer le paramètre 'adresse' en (void *)

K :
Resultat : abc

Je ne comprends pas l'erreur "invalid initializer". Pourtant le code
fonctionne même avec : *Chaine[0], *Chaine[20]...



certainement pas. C'est printf("n%c", *(Chaine2[1])) . Attention à la
préséance des opérateurs ...

L :
Resultat : abc

error: invalid initializer
error: expected expression before ‘]’ token
error: array subscript is not an integer
warning: format ‘%c’ expects type ‘int’, but argument 2 has type ‘char
*’

Et pourtant ça fonctionne.
Invalid initializer est dans J alors je suppose que la réponse
précédente satisfait la question présente.
expected expression ... : je comprends que je dois mettre un indice
entre [ ] . Dans J, les indices ne me semblent pas utiles et ici, ils
seraient utiles?
array subscript is not an integer : je ne comprends pas
warning : format %c expects type int ... : selon moi, %c attend un
caractère et non pas un int ...



Nan. "%c" attend un int représentant la valeur d'un caractère.


M:
Resultat inédit : E#abc
warning: format ‘%s’ expects type ‘char *’, but argument 2 has ty pe
‘char **’
Je ne suis pas sûr de comprendre.



Il n'y a rien de prévu nativement pour représenter un tableau de
pointeurs.
Avatar
Antoine Leca
heron maladroit écrivit :
char Chaine[10] = "abc" ;

printf("n%s", Chaine) ; /* A : OK */
Resultat : abc

Je comprends ici que Chaine est un tableau (ou une chaine constante
pour être plus précis?).
Le paragraphe suivant l'extrait du K&R précédent dis que lorsqu'un nom
de tableau est envoyé à une fonction, c'est l'emplacement du
1er élément qui est envoyé... et à l'intérieur de cette fonction, cet
argument est une variable locale

Je ne comprends pas que pour printf avec %s, * ou le contenu de Chaine
ne soit pas appelé mais ce qui me semble être l'adresse en mémoire de
Chaine comme lorsqu'on passe char *pointeur ; pointeur = Chaine ou
pointeur = &Chaine[0].



Bin il va falloir que tu comprennes cela avant de pousser plus loin,
parce que tout en dépend...

Comme rappelé dans l'extrait du K&R, Chaine est un tableau ; il est donc
jugé trop gros pour être passé au sous-programme : pour passer un
paramètre il faut le copier dans un emplacement prédéfini avant l'appel,
puis au début de la fonction le recopier depuis la zone de passage
prédéfinie : cela s'appelle les conventions d'appel, et c'est très
semblable au circuit que font tes valises lorsque tu prends l'avion :
avant de monter dedans il te faut les enregistrer, puis elles sont mises
dans la soute, et te sont restituées à destination : comme c'est très
lourd, on préfère si possible utiliser les bagages de cabine, pardon les
paramètres passés par registre, qui évite le circuit compliqué.
Seulement les paramètres que l'on peut passer par registre sont limités
en taille ; et un tableau n'est pas acceptable: donc on préfère passer
un registre, en l'occurrence un pointeur vers la dite chaîne.

<LEÇON_SUIVANTE>
SAUF QU'en faisant cela, on ne transporte plus réellement la valise,
pardon, le tableau n'est pas réellement copié dans le sous-programme, on
travaille non pas sur une copie locale mais sur le vrai tableau, seul et
unique : cela est la cause profonde des « problèmes de pointeurs » en C:
il faut constamment veiller à ne pas écraser les tableaux que l'on nous
a passé en paramètres : d'où l'intérêt du mot-clé const, qui permet au
compilateur de renforcer notre attention.
</LEÇON_SUIVANTE>


Donc pour en revenir à printf(), il y a une différence fondamentale
entre %i/%o/%c/%p d'un côté, qui imprime la valeur des paramètres passés
comme variables locales pour printf, et %s de l'autre côté, qui imprime
la valeur du tableau global, externe à printf et donc seulement connu de
cette fonction par l'adresse à laquelle il commence.


Le point H va dans ce sens
printf("n%s", &Chaine[0] ) ; /* H: OK */



Mmmm. Il faut dire que dans la plupart des cas, Chaine est équivalent à
&Chaine[0] (les cas où ce n'est pas équivalent sont: derrière sizeof,
derrière &, à gauche de = ou dans l'initialisation d'un objet).


Surtout que dans ce cas scanf ajoute de l'insulte
à la blessure car : scanf("%s", Chaine) au lieu de scanf("%s", &Chaine)
comme on peut s'y attendre ;



scanf() est une fonction différente de printf(), et soumise à d'autre
contraintes : en particulier, pour que scanf("%i",???) fonctionne on ne
peut plus se contenter de la valeur d'une variable _avant_ l'appel à
scanf() dont on se moque éperdument : il faut que scanf() puisse
_modifier_ la variable, et pour cela il est nécessaire de passer son
adresse, autrement dit un pointeur vers sa position, à la fonction scanf
scanf("%i", &i);

Seulement, comme expliqué ci-dessus, avec les chaînes on a déjà passé ce
fameux pointeur, donc pour économiser on utilise directement le pointeur
scanf("%s", &Chaine[0]);
ou, ce qui est équivalent
scanf("%s", Chaine);



scanf("%s", &Chaine) affiche
warning: format ‘%s’ expects type ‘char *’, but argument 2 has type
‘char (*)[10]’



J'espère que tu vois pourquoi maintenant.

mais la saisie se fait quand même



Je ne pense pas. Au mieux, la saisie va s'effectuer en écrasant des
données inutiles sur la pile de main(), et il n'y aura pas de
conséquences graves (mais la chaîne entrée au clavier ne sera pas dans
Chaine) ; au pire, tu vas avoir droit à un SIGSEGV pour avoir écraser
tes propres variables...


printf("n%s", *Chaine) ; /* B : warning: format ‘%s’ expects type
‘char *’, but argument 2 has type ‘int’ ... Segmentation fault : */
Resultat : Segmentation fault



Si tu as bien suivi, c'est la même chose dans l'autre sens : cette
fois-ci tu n'essaye pas d'écrire dans ta pile, mais tu fais croire à
printf() que le caractère 'a' est l'adresse où se trouve la chaîne à
écrire...

Le warning dit que le 2ème argument est de type int.
Ce n'est pas la première fois que j'ai ce message. Est-ce que je dois
comprendre que dans printf, %s est le 1er argument, et *Chaine est le
second?



Oui.


Alors comme le pointeur *Chaine n'a pas été déclaré,



Bin si (sauf que ce n'est pas un pointeur) : l'objet Chaine est déclaré
comme tableau de char, donc lorsqu'on utilise l'opérateur * qui en
extrait le premier élément, on obtient le premier élément du tableau, et
le type du résultat est char.
Au niveau des conventions d'appel, char est trop petit, donc on
l'agrandit en int, ce qui explique le message ci-dessus

Là aussi, on est dans les choses de base concernant les pointeurs (en
l'occurrence, ne pas confondre l'opérateur * avec l'utilisation de *
pour déclarer des pointeurs), il faut absolument que tu maîtrises cela
avant de prétendre aller plus loin.


Antoine
Tribune libre
Tribune en direct