CODEWITHSUNDEEP
c++pointerstree
user1657039
user1657039

Reputation:

Pointer-to-pointer access

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];

};

Upvotes: 0

Views: 128

Answers (3)

Joseph Mansfield
Joseph Mansfield

Reputation: 110658

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] |
                           | ...       |

Upvotes: 5

Brandon
Brandon

Reputation: 752

(
  (
    (
      (
        (
          *(parent)
        )
        ->leaves
      )
    )
    [7]
  )
  ->zone_id
)
  • dereference parent
  • access the leaves member
  • index the 7th element
  • access the zone_id member.

Upvotes: 0

Mats Petersson
Mats Petersson

Reputation: 129314

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;

Upvotes: 0

Related Questions