Discussion :

[Erast]

Bonsoir

J'ai fait quelques tests avec une fonction et je ne comprends pas du tout la logique qu'il y a derrière, le résultat à l'aire même d'être paradoxale.

Code :

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

1
2
3
4
5
6
7
8
9
int* fct(int n,char c[], int* p){
  //je fais pointer p la où il le faut
 
}
 
void fct(int n,char c[], int* p){
  //je fais pointer p la où il le faut
 
}

Execution donne bien ce quil faut mais uniquement si le main est écrit comme ça:

Code :

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

1
2
3
4
int main(){
 
   int* p = fct(1, "test teste", p);
}

ou sinon ça plante

Normalement on initialise le pointeur sur NULL
et ensuite on le fait pointer,non?

[snowpy]

double déclaration de fct, je suis surpris que ton compilo te jete pas au début quoique il considère que le void est un int peut être ^^
Les pointeurs sont fait pour être passé dans le tube donc je vois pas l'interet d'utiliser un pointeur si c'est pour faire un return derrière.

[Erast]

Une fois avec le void et l'autre fois avec int*, ce sont deux variantes.

Normalement dans le main pour recupérer le pointeur

on initialise

Code :

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

int* p = NULL;

puis on lui affecte ladresse via fct

Code :

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

fct(1,"balabla",p);

Suivre ces regles fait crasher le programme alors que faire ça:

Code :

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

int *p = fct(1,"blabla",p);

fonctionne parfaitement.

Y a un bug dans la matrice?

Ou dans ma cervelle?


Edit: désolé Melem je sais pas mettre le code en format code.

[bloomenthal]

Hello,

Confusion "classique"
Passer un pointeur en parmètre ne veut pas dire que modifier le pointeur à l'intérieur de la fonction modifie le pointeur correspondant à l'extérieur.

Exemple :

Code :

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

1
2
3
4
5
6
7
8
9
void fct(int a) {
    a = 5;
}
 
int main(void) {
    int x = 1;
    fct(x);
    // que vaut x ici ?
}

La réponse à la question est 1 : l'appel à la fonction n'a pas changé la valeur de x.
Que ce soit un int, ou un int*, c'est pareil !

Si tu veux changer la valeur de p à l'extérieur, il faut que ta fonction propose non pas un pointeur int*, mais un pointeur int**. Ensuite, dans ta fonction, tu ne modifieras plus p, mais *p

[EDIT] Ou alors, comme tu l'as trouvé toi même, tu peux aussi retourner l'adresse comme valeur de retour.

[bloomenthal]

Et pour tenter d'être un peu plus clair, en C, les paramètres dans une fonction, sont toujours des copies des données initiales.

Dans ton cas, le pointeur est donc recopié (mais pas la zone pointée !), et dans ta fonction tu modifies donc une copie du pointeur, qui n'existe plus une fois que ta fonction se termine.

En C++ il y a une solution qui est le passage par référence, en C on se débrouille avec des pointeurs : pour un int, on met un int*; pour un int*, on met un int** (ce qui est ton cas)

[jeroman]

J'ai du mal à comprendre ta question.

Code :

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

1
2
int* p = NULL;
fct(1,"balabla",p);

Est-ce que tu veux que le pointeur p soit modifié par la fonction fct ?
Si c'est le cas, c'est normal que ça ne marche pas. Tu passes à la fonction seulement sa valeur. Cela veut dire que seul le contenu de la mémoire pointé par ce pointeur pourra être modifié et non pas la valeur elle-même du pointeur. Dans la fonction fct, tu crées une variable locale (un pointeur), nommé p aussi, qui est immédiatement détruit une fois que la fonction prend fin. Le pointeur p de la fonction appelante ne peut donc pas être modifié ainsi.

Si tu veux modifier la valeur d'un pointeur par la fonction appelée, il faut lui envoyer son adresse (i.e. l'adresse à laquelle sa valeur est stockée), puis la fonction appelée doit prendre en argument un pointeur de pointeur.
En déréférençant (avec une étoile) le pointeur, on accède ainsi à la valeur du pointeur de la fonction appelante.

Tu as un résultat de ce style :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void fct(int n,char c[], int** p) /* **p -> pointeur de pointeur */
{
  /*
  'p' a pour valeur l'adresse où est stocké le pointeur 'p' de 'fonction()'
  '*p' a pour valeur la valeur du pointeur 'p' de 'fonction()'
  '**p' correspond à l'entier stocké à l'adresse pointée par le pointeur 'p' de 'fonction()'
  */
}
void fonction ( void )
{
  int* p = NULL;
  fct(1,"balabla", &p); /* passage de l'ADRESSE du pointeur */
}

EDIT : mince... multigrillé...

[Erast]

Merci à vous, tout est clair a présent.