Il fonctionne mais je ne comprends pas pourquoi il faut un pointeur
sur pointeur dans la fonction.
Pourquoi ne fait on pas : printf("Adresse du pointeur: %p\n",
varEntiere);
Qu'obtiens t'on en faisant cela ?
J'ai bien compris que pour modifier le contenu de la variable pointée
par le pointeur il fallait le deférencer par l'étoile.
Et que pour initialiser le pointeur il lui faut une adresse : malloc
retourne une adresse on aurait aussi pu faire :
varEntiere = &autreVariable
Ensuite je ne comprend pas pourquoi on lui passe l'adresse et pourquoi
on a un pointeur de pointeur, je pensais qu'il fallait juste changer
l'adresse qu'il contient, comme quand on fait précédemment.
printf("Adresse du pointeur: %p\n", varEntiere);
maFonction(varEntiere);
printf("Valeur récupérée: %p\n", varEntiere); // = 0x00
// il semblerait que la variable ne soit changer que localement
est-ce possible que le pointeur soit passer par valeur ?
}
Je pense que mon problème existenctiel sur les pointeurs vient de la,
alors si vous pouvez m'aider je serai ravi.
Je pense que tu t'es trompé de forum, et que tu voulais poster sur fr.comp.lang.c, non ?
Pour répondre à ta question, c'est assez simple (si tu as lu le thread "question sur const") : tu veux modifier un objet (de type "int*"), tu dois donc le passer soit par référence non-const, soit par pointeur non-const.
N'oublie pas qu'un pointeur a une double personnalité : parfois objet à part entière, parfois une autre façon de désigner une référence.
En passant, je note que tu as la manie d'ajouter des casts explicites. Comme l'a dit Alexandre, on n'utilise un cast explicite que quand on a une bonne raison pour.
Je peux me tromper (ça fait des années que je n'ai pas fait de C), mais le code C correct pour allouer 256 entiers est :
*varEntiere = malloc (256 * sizeof (int));
Et en C++ ça donne :
*varEntiere= new int [256];
... mais bien entendu, on préférera utiliser std::vector<int> dans du code de production.
-- ;-)
On 5 Aug 2004 14:20:34 -0700, thitou@bigfoot.com (thitou):
Je pense que tu t'es trompé de forum, et que tu voulais poster sur
fr.comp.lang.c, non ?
Pour répondre à ta question, c'est assez simple (si tu as lu le thread
"question sur const") : tu veux modifier un objet (de type "int*"), tu
dois donc le passer soit par référence non-const, soit par pointeur
non-const.
N'oublie pas qu'un pointeur a une double personnalité : parfois objet
à part entière, parfois une autre façon de désigner une référence.
En passant, je note que tu as la manie d'ajouter des casts explicites.
Comme l'a dit Alexandre, on n'utilise un cast explicite que quand on a
une bonne raison pour.
Je peux me tromper (ça fait des années que je n'ai pas fait de C),
mais le code C correct pour allouer 256 entiers est :
*varEntiere = malloc (256 * sizeof (int));
Et en C++ ça donne :
*varEntiere= new int [256];
... mais bien entendu, on préférera utiliser std::vector<int> dans du
code de production.
Je pense que tu t'es trompé de forum, et que tu voulais poster sur fr.comp.lang.c, non ?
Pour répondre à ta question, c'est assez simple (si tu as lu le thread "question sur const") : tu veux modifier un objet (de type "int*"), tu dois donc le passer soit par référence non-const, soit par pointeur non-const.
N'oublie pas qu'un pointeur a une double personnalité : parfois objet à part entière, parfois une autre façon de désigner une référence.
En passant, je note que tu as la manie d'ajouter des casts explicites. Comme l'a dit Alexandre, on n'utilise un cast explicite que quand on a une bonne raison pour.
Je peux me tromper (ça fait des années que je n'ai pas fait de C), mais le code C correct pour allouer 256 entiers est :
*varEntiere = malloc (256 * sizeof (int));
Et en C++ ça donne :
*varEntiere= new int [256];
... mais bien entendu, on préférera utiliser std::vector<int> dans du code de production.
-- ;-)
Alexandre Bacquart
Fabien LE LEZ wrote:
On 5 Aug 2004 14:20:34 -0700, (thitou):
Je peux me tromper (ça fait des années que je n'ai pas fait de C), mais le code C correct pour allouer 256 entiers est :
*varEntiere = malloc (256 * sizeof (int));
Oui, on préférera sizeof(**varEntiere) pour alléger la maintenance, mais c'est ça.
-- Tek
Fabien LE LEZ wrote:
On 5 Aug 2004 14:20:34 -0700, thitou@bigfoot.com (thitou):
Je peux me tromper (ça fait des années que je n'ai pas fait de C),
mais le code C correct pour allouer 256 entiers est :
*varEntiere = malloc (256 * sizeof (int));
Oui, on préférera sizeof(**varEntiere) pour alléger la maintenance, mais
c'est ça.