Voici un code qui passe un double pointeur dans une fonction. le double pointeur reçoit alors l'adresse d'un pointeur créé dans la fonction. Lorsque j'imprime l'adresse stockée dans le pointeur double, elle imprime NULL, qui est la valeur que j'ai initialement donnée au double pointeur avant de la passer dans la fonction.en passant un double pointeur dans une fonction et en lui assignant une adresse d'un pointeur local à une fonction
#include <stdio.h>
#include <stdlib.h>
struct node
{
int value;
};
void append(struct node **nodePtr);
int main()
{
struct node **nodePtr = NULL;
append(nodePtr);
printf("\nnodePtr = %p", nodePtr);
return 0;
}
void append(struct node **nodePtr)
{
// creating new node
struct node *currentNode = malloc(sizeof(struct node));
// assigning the address of currentNode to the double pointer NodePtr
nodePtr = ¤tNode;
printf("\n¤tNode = %p", ¤tNode);
}
This is the result I get when I run the code
Je sais que si vous passez un pointeur dans une fonction, il est passé par référence, ce qui signifie que toute modification apportée au pointeur dans la fonction ne disparaîtra pas lorsque vous accédez au pointeur à l'extérieur la fonction. Ma question est, pourquoi je ne peux pas accéder à l'adresse de currentNode à l'extérieur de la fonction. Je l'ai assigné à un double pointeur donc je devrais pouvoir y accéder en dehors de la fonction? droite?
Au-dessus a été déjà répondu
Merci pour votre réponse paul, il a parfaitement fonctionné. J'ai essayé de développer sur le code. Je voulais assigner nodePtr au pointeur struct appelé tête. Quand j'ai appelé la fonction, je voulais stocker l'adresse dans currentNode dans le pointeur de la tête. Au début, je pensais que changer le code à l'intérieur de la fonction affichée ci-dessous fonctionnerait.
*nodePtr = currentNode;
mais cela n'a pas fonctionné parce que je changeais simplement le contenu de nodePtr pas le contenu dans la tête.
J'ai ensuite essayé d'initialiser nodePtr à l'adresse de tête.
struct node *nodePtr = &head;
mais cela n'a pas fonctionné car ce n'est pas un double pointeur. Si je l'initialise comme un double pointeur, je viens de rencontrer le même problème que précédemment.
ci-dessous est tout mon code jusqu'à présent
#include <stdio.h>
#include <stdlib.h>
struct node
{
int value;
};
void append(struct node **nodePtr);
int main()
{
struct node *head = NULL;
struct node *nodePtr = head;
append(&nodePtr);
printf("%p", head);
return 0;
}
void append(struct node **nodePtr)
{
// creating new node
struct node *currentNode = malloc(sizeof(struct node));
// assigning the address of currentNode to the double pointer NodePtr
*nodePtr = currentNode;
}
Il n'y a pas de "double pointeur". Il n'y a que des pointeurs. Les pointeurs peuvent pointer vers n'importe quoi, y compris les pointeurs. Les pointeurs pointant vers des pointeurs ne sont toujours que des pointeurs, pas des "pointeurs doubles". Si vous gardez cela à l'esprit, beaucoup de confusion devrait disparaître. – gnasher729