Pointer-to-pointer access

Question

Can somebody explain this to me:

(((((*(parent))->leaves))[7])->zone_id)

pointers to pointers are really confusing to me. This is the expression I got from the watch in debug mode. I am trying to access to the string zone_id inside the last element of tree (with 10 elements, each element for different number 0-9).

EDIT: this is the whole search function, hope it is enough to understand:

string Tree::search(string str, node** parent, int num) {

    int value;

    if (num < str.length()) {

        value = boost::lexical_cast<int> (str.substr(num, 1));

        if ((*parent)->leaves[value] != NULL  &&  num != str.length() -1) {

            search (str, &((*parent)->leaves[value]), num+1);


        } else if (num == str.length() -1) {

            if ( (*(parent)->leaves)[value]->zone_id.empty() )
                cout<<"Yep.";
            else
                return (string) "No_results.";

        }

    } 


}

and structure:

struct node {

    string zone_id;
    node* leaves [10];

};

Answer 1

Well let's get rid of some brackets to simplify it a bit:

(*parent)->leaves[7]->zone_id

Now it's much easier to understand. We are dereferencing parent ( *parent ) which gives us a pointer to some object that has an array member called leaves . So we access the element of that array with index 7, which gives us another pointer, this time pointing to an object that has a member called zone_id . We then access that zone_id member.

^{This is all assuming there's no operator overloading involved.}

Diagrammatically (an arrow is "points to"):

 ________     _________     ___________         ___________
| parent |-->| *parent |-->|  struct:  |   ,-->|  struct:  |
|________|   |_________|   | leaves[0] |   |   | zone_id   |
                           | leaves[1] |   |   | ...       |
                           | leaves[2] |   |
                           | leaves[3] |   |
                           | leaves[4] |   |
                           | leaves[5] |   |
                           | leaves[6] |   |
                           | leaves[7] | --'
                           | leaves[8] |
                           | ...       |

Answer 2

Removing the parenthesis makes it actually easier to read, in my mind: (*parent)->leaves[7]->zone_id

So, we have a pointer to a pointer of leaves. (*parent) makes a dereference to that pointer (so fetches what it the pointer points at). So now we have a pointer to leaves, which is an array of 10, so we use element 7, and the pointer here is used to fetch the zone_id.

It does get a bit complicated, but this is far from the most complicated structure I have seen. If it helps you, you could break it down:

Parent *this_parent = *parent;

Leave *leaf = this_parent->leaves[7];

... use leaf->zone_id;

Answer 3

(
  (
    (
      (
        (
          *(parent)
        )
        ->leaves
      )
    )
    [7]
  )
  ->zone_id
)

• dereference parent
• access the leaves member
• index the 7 th element
• access the zone_id member.