Any Uses For A Pointer To A Pointer?

I never really messed with learning much about pointers to pointers or their uses....nor did I really ever see a use for pointers to function addresses either.

Pointers/memory management are the hardest concepts of C and C++, hands down. There are so many different uses and syntax for them. I never really saw a need to have a pointer to a pointer....what's the use? I assume it's useful to produce a tree effect with your pointers, and the **p would be like a root node....or I could be wrong. I also heard that **p is useful in keeping collections of const char *strings.

At any rate, pointers never were my strong point, but I'd like to master them so I can put the worst of C/C++ behind me. A lot of code for advanced applications or in APIs is very pointer-intensive. Not that I don't understand that particular code....but I'm just not yet a master of everything pointer.

I had a problem the other day, one of the solutions involves using a pointer to a pointer.
Problem with Dynamically Increasing Array of Integers

You can use a pointer to a pointer to allocate two dimensional arrays.

Code:

---

int **buf, rows = 10, cols = 10;
buf = new int*[rows];
for(int i = 0; i < rows; i++)
        buf[rows] = new int[cols];

---

You can use a pointer to a pointer if you need to pass a pointer by reference. (Alternately, you could just use a reference, but C doesn't have that.)

Code:

---

void func(int **a) //double pointer, valid C code
{
        *a = (int*)1;
}

void func(int *&a) //reference to a pointer, invalid C code
{
        a = (int*)2;
}

int main()
{
        int *a = NULL;
        func(&a); //pass the address of the pointer
        if(a == (int*)1)
                std::cout << "1" << std::endl;
        func(a); //pass the pointer
        if(a == (int*)2)
                std::cout << "2" << std::endl;
        return 0;
}

---

Just like any tool, they have their occasional uses. I prefer to use STL to take care of that memory management stuff.

>I had a problem the other day, one of the solutions involves using a pointer to a pointer.
And you can also use a reference to a pointer.

>I assume it's useful to produce a tree effect with your pointers, and the **p would be like a root node....

For a binary tree, you could have something like:

Code:

---

struct Node
{
  int data;
  Node *left;
  Node *right;
};

Node *root;

---

When updating the tree, you again could pass a reference to a node:

Code:

---

void addNode(Node *&root)

---

Or even:

Code:

---

void addNode(Node &root)

---

though that isn't as efficient.

In C, since there are no references, you would need the double pointer:

Code:

---

void addNode(Node **root)

---

Or I guess you could return the root:

Code:

---

Node *addNode(Node *root)

---

About the double pointer as a reference thing...I suppose I get it...I'm not really sure if I'd ever need to pass a pointer to a function to manipulate its contents...but I get it....if you have a pointer as a parameter, it expects to receive an address, ya?

I'm still not so great with const char *Strings. Maybe I just really suck at strings. Would there ever be a time when you'd want to use a double char pointer?

These confuse me the most:

Code:

---

#include <iostream>
using namespace std;

int main(){
    char *S = "Hello sir.";
    cout << S << endl;      //Shouldn't this print an address?
    cout << *S << endl;    //Why does this only display the first slot of the array?
    cin.get();
    return 0;
}

---

Quote:

---

Originally Posted by Krak

About the double pointer as a reference thing...I suppose I get it...I'm not really sure if I'd ever need to pass a pointer to a function to manipulate its contents...but I get it....if you have a pointer as a parameter, it expects to receive an address, ya?

I'm still not so great with const char *Strings. Maybe I just really suck at strings. Would there ever be a time when you'd want to use a double char pointer?

These confuse me the most:

Code:

---

#include <iostream>
using namespace std;

int main(){
    char *S = "Hello sir.";
    cout << S << endl;      //Shouldn't this print an address?
    cout << *S << endl;    //Why does this only display the first slot of the array?
    cin.get();
    return 0;
}

---

---

After this
char *S = "Hello sir.";
S will contain a pointer, which is a memory adress of string "Hello sir". ostream has an overloaded operator for const char* and char*, which assumes that that's a C style string.
the ' * ' unary operator in *S is to dereference the pointer, or in other words, since you have a pointer to something, * gets that something. In your case *S will give you the first char pointer by S, which is a simple char. ostream presents that single char.

Code:

---

cout << "enter the number of strings you want to save" << endl;
int x;
cout << "enter the maximum number of letters per string you want to allow" << endl;
int y;
char ** strings; //pointer to pointer to type char
strings = new char*[x]; //declare number of arrays to use using user input
for(int i = 0; i < x; ++i) 
  strings[i] = new char[y + 1]; //declare max length of each string
for(int i = 0; i < x; ++i)
{
  cout << "enter a string with less than " << y << letters << endl;
  cin >> strings[i];
}

---

an example of an array of C style strings allowing user to specify number of strings and size of maximum length of string. Code is not supposed to be optimal code, but meant for demonstration purposes only.

Or how about a guessing game where player tries to remember where certain letters are located and if they can pair them up then they gain a point and the player with the most points when all letters have been paired wins. If you wanted to let user decide the number of cells used in the game, then you could could use a dynamically declared 2D array of char, not even strings, to represent the playing board, etc.

Hi,

It sounds like Java or C# would be the perfect language for you: no pointers, no deleting, no worrying about memory leaks.

The Win32 SDK uses pointers to pointers quite a bit (called handles). The explanation for their use in that situation is that when the computer is dealing with lots of Window-esque objects, it often needs to move their data around in memory. If you were just using a pointer to this data and it was moving constantly (i.e. the value of the pointer was changing constantly) you'd very quickly run into problems. If you have a constant pointer to that changing pointer, it's a lot easier to manage.

Is that what a handle is----a pointer to pointer to type. Whaddya know.

Unless I grossly misunderstood Folger's tutorial - then yes.

It makes sense. It gives you a handle to hold on to and keep track of the other little pointer while he runs around, ya?

>Is that what a handle is----a pointer to pointer to type.
Well, technically a pointer is a handle. A pointer to a pointer is also a handle because a pointer (even though it's a handle) is also valid content.

>I never really messed with learning much about pointers to pointers or their uses
In C++ their use is limited because of references. I rarely use a pointer to a pointer in C++ where in C I found myself using three or four levels of indirection occasionally.

>nor did I really ever see a use for pointers to function addresses either
Once again, their use is limited thanks to function objects.

Stroustrup defines a handle much like a smart pointer. Probably a lot of variant meaning. The winapi handles are an opaque type. I think they're just unsigned integers into some internal winapi datastructure. They behave like pointers, but are not really pointers.