0

I'm trying to write a program to play "Pangolin" (like this guy - it asks yes/no questions, walking down a binary tree until it gets to a leaf node. It then "guesses", and if the user says the answer was wrong, asks the user what they were thinking of and for a question that distinguishes that from the incorrect gues. It then adds the new data to the tree).

This is the my struct for a tree node. NodeType is QUESTION_NODE for nodes containing a question or OBJECT_NODE for nodes containing an "object" - that is the thing the program deduces the user to be thinking of. Question nodes have pointers to child nodes - one for yes and one for no.

typedef struct _TreeNode {
  NodeType type;
  union {
    char* question;
    char* objectName;
  } nodeString; 
  //children for yes and no answers: will be invalid when type is OBJECT_NODE
  struct _TreeNode* yes;
  struct _TreeNode* no;
} TreeNode;

As this is a learning exercise, I'm trying to do it with double pointers. Here is the function that is supposed to add a question node to the tree:

void addData(TreeNode** replace, char* wrongGuess) {
  //create a new object node for what the user was thinking of
  // ... (code to get user input and build the new object node struct) ... //

  //create a new question node so we don't suck at pangolin so much
  // ... (code to get a question from the user and put it in a question node struct) ... //

  //link the question node up to its yes and no
  printf("What is the answer for %s?\n", newObjectName);
  if (userSaysYes()) {
    newQuestionNodePtr->yes = newObjectNodePtr;
    newQuestionNodePtr->no = *replace;
  }
  else {
    newQuestionNodePtr->no = newObjectNodePtr;
    newQuestionNodePtr->yes = *replace;
  }

  //redirect the arc that brought us to lose to the new question
  *replace = newQuestionNodePtr;
}

The addData function is then called thus:

void ask(node) {
  //(... ask the question contained by "node" ...)//

  //get a pointer to the pointer that points to the yes/no member pointer
  TreeNode** answerP2p;
  answerP2p = userSaysYes() ? &(node.yes) : &(node.no);

     //(... the user reports that the answer we guessed was wrong ...)//

      puts("I am defeated!");
      //if wrong, pass the pointer to pointer
      addData(answerP2p, answerNode.nodeString.objectName);

My (presumably wrong) understanding is this:

In "ask()", I am passing addData a pointer which points to "node"'s member "yes" (or no). That member is in turn a pointer. When, in addData, I assign to "*replace", this should modify the struct, redirecting its "yes" (or no) member pointer to point to the new question node I have created.

I have debugged and found that the newQuestionNode and newObjectNode are created successfully. newQuestionNode's children are correctly assigned. However the new question node is not inserted into the tree. The "*replace = newQuestionNodePtr" line does not have the effect I would expect, and the node referred to by "node" in the "ask" scope does not have its child pointer redirected.

Can anyone see what is wrong in my understanding? Or perhaps a way in which I haven't expressed it right in my code? Sorry this question is so long.

Brendan
  • 1,995
  • 1
  • 20
  • 35

2 Answers2

1

You should not declare the pointer you pass to the function as a double pointer. Instead pass the address of a single pointer to the function:

TreeNode* answerP2p;
answerP2p = userSaysYes() ? node.yes : node.no;

addData(&answerP2p, answerNode.nodeString.objectName);
Some programmer dude
  • 400,186
  • 35
  • 402
  • 621
  • Hmmm... as I understand it, "T** a; a = &(b); f(a);" is equivalent to "T* a; a = b; f(&a);" in as far as what f() recieves? I have tried what you suggest but have exactly the same behaviour. – Brendan Dec 06 '12 at 12:30
  • @user1582407 No, they are not the same. In the first case (`T** a = &b; f(a);`) it's the pointer `b` that is updated by `f`, in the second case it's the pointer `a`. – Some programmer dude Dec 06 '12 at 12:42
  • I'm sorry, I don't understand. In my example `b` is the value I'm trying to update. In both cases `f()` receives a pointer to `b`. In the second case the use of the `&` operator is simply deferred to the `f()` call. Can you see what I'm missing? – Brendan Dec 07 '12 at 12:04
  • @user1582407 The address-of operator `&` returns the address of the variable it's used on, so in the second case where you use `f(&a)` it passes the address of `a` to the function `f`, and when `f` changes the argument it's `a` that is changed. So in the second case before you call `f` then `a == b`, but after the call `a != b`. – Some programmer dude Dec 07 '12 at 12:10
  • Again, I'm really sorry but I still don't understand. In my question I pass a pointer (`answerP2p`) to a pointer (`node.yes`) to `addData`. In `addData`, when I assign to `*replace` (where `answerP2p` was passed as the `replace` argument), why does that not update `node.yes`? I have tried passing `&node.yes`, and got the same behaviour - and as I understand it, this is expected, since `answerP2p == &node.yes` (I have verified this!). – Brendan Dec 10 '12 at 15:57
0

Unfortunately I don't quite understan'd Joachim Pileborg's answer above, but I eventually sussed my problem and I guess it's a fairly common mistake for new C-farers[1], so I'll post it here in my own terms.

In my hasty transition from Java to C I had told myself "OK, structs are just objects without methods". Assessing the validity of this simplification is left as an exercise to the reader. I also extended this assumption to "when an argument is of a struct type, it is automatically passed by reference". That's obviously false, but I hadn't even thought about it. Stupid.

So the real problem here is that I was passing ask() a variable of type TreeNode for its node argument. This entire struct was being passed by value (of course). When I passed answerP2p to addData(), it was actually working correctly, but it was modifying ask()'s local copy of the TreeNode. I changed ask() to take a TreeNode* and lo, there was a tree.

  1. C what I did there[1]?
Brendan
  • 1,995
  • 1
  • 20
  • 35