question about second pointers - c++

Question

i am using c++ and i have some trouble about pointers
i know that if we declare some variable
int t=7;
int *p=&t;
*p gives adress of variable t but in c++ here also definition of **s why it is used ?i have read it but i have some misunderstanding please can anybody give me example how use?let take about given example

Answer 1

Its a pointer to a pointer.
For example, if your operation was in a function:
void make_p(int **p, int *t) {
*p = t;
}
int main() {
int *p;
int t;
make_p(&p, &t);
}

Answer 2

For example, you can use this for creating an object in a function:
void create( Type** result )
{
*result = new Type();
}
//somewhere else in code
Type* object;
create( &object );
this doesn't make much sence for void functions creating a single object, but in case the function needs some predefined return type or needs to create more than one object that will make sence. A classic example is IUnknown::QueryInterface() that must return HRESULT:
HRESULT CYourClass::QueryInterface( IID& iid, void** result )
{
//inside you need to decide whether you know the iid passed, copy a pointer
// into *ppv and then return apropriate HRESULT
}

Answer 3

First of all *p will give you the value of variable t and not the address of t. Only 'p' will give you the address of t.
Essentially every address is just an integer number. If you are compiling for 32-bit architecture then it will be 32-bit long number and if you are compiling for 64-bit then it will be 64-bit long. This means that you can use a simple integer variable to store any variable's address irrespective of what type the variable is but it is better to use a proper type of pointer to store the variable's address. This way we can dereference the pointer and we dont have have to type cast it whenever we want to use the variable which is being pointed to.
To create a pointer to some variable, we declare a variable of the same type but put a '*' in front of the variable's name. For example you can declare an integer as follows
int a;
To create a pointer to 'a', create a new variable with the same type as a and just put a '*' in front of it. So the declaration of pointer to the above variable 'a' will look like
int *p;
Notice that other than an additional '*', its the same declaration. Now 'p' is a pointer to an integer variable.
Now consider that you want another pointer to point to this variable 'p'. Again you declare a variable similar to 'p' and just put a '*' in front of it. So a declaration of pointer to the above variable will look some thing like
int **pp;
Again notice that other than an extra '*' this declaration is very same to the declaration of 'p'. So the variable 'pp' is a pointer to a pointer to an integer
You can declare a pointer to 'pp' in the same way and the cycle will continue. This is also true for non simple types i.e pointers to variables of class or structure types are created the same way.

Answer 4

It's so we can change where other pointers are pointing to. Pointer to a pointer. Consider the following:
int *p1 = &j; // j is a int.
int *p2 = &k; // k is an int.
int **p;
p = &p1; //p points at p1.
*p = p2; //p1 now points to j because p2 is pointing to j.
//Also we can do this through just plain old variables.
int l;
*p = &l; //p1 is now pointing at l

Answer 5

Just as int *p; defines a pointer to an int, int **s; defines a pointer to (a pointer to an int). This comes up usually in two cases:
First, if you want an array that holds pointers to an int, you would do something like: int **arr = malloc(sizeof(int*) * arr_size);
Second, when a function needs to return more than one value, it's common to have the extra values returned by reference. I.e.:
/* Return x, y and error code. */
int getVals(int *px, int *py) {
*px = x;
*py = y;
return 0;
}
/* Return new object and error code. */
int newFoo(struct Foo **out_foo) {
struct Foo *f = malloc(sizeof(struct Foo));
f->value = 0;
*out_foo = f;
return 0;
}