2017-10-21 6 views
1

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 = &currentNode; 

    printf("\n&currentNode = %p", &currentNode); 
} 

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; 
} 
+0

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

Répondre

0

Votre principal devrait être:

int main() 
{ 
    struct node *nodePtr = NULL; 

    append(&nodePtr); 
    printf("\nnodePtr = %p", nodePtr); 

    return 0; 
} 

Alors vous passez l'adresse du nodePtr du principal.

En append, vous devez maintenant déréférencer ce pointeur:

// assigning the newly allocated currentNode to the double pointer NodePtr 
    *nodePtr = currentNode; 

(Donc, n'asssign pas l'adresse de la variable locale currentNode parce que la variable locale cessera d'exister après le retour de la fonction que vous attribuez la. pointeur retourné par malloc.)

Je vous suggère d'utiliser un stylo et du papier pour dessiner la mémoire de main et append et d'en tirer les pointeurs pour voir ce qui se passe et ce qui est stocké où.

0

Vous devez passer un pointeur triple dans la fonction, si vous insistez sur l'utilisation d'un double pointeur.

Dans votre code, les modifications sont effectuées à l'intérieur de la fonction, mais elles ne persistent pas après sa fin.

Cependant, vous n'avez pas vraiment besoin d'utiliser un double pointeur dans votre main(), utilisez simplement un seul pointeur et laissez la fonction telle quelle.