指向指针 C++ 的指针

Question

I can't really understand what pointer to pointer is in C++. Let's say I have a class defined as follows:

class Vector3 
{
   public:
         float x,y,z;
         //some constructors and methods
}

Now what if I have something like

Vector3 **myVector3;

Is this SOMEHOW the C#'s equivalent of saying List<List<Vector3> myVector3 ? And anyway, how can I dynamically allocate this myVector3 object? Thanks.

Answer 1

Is this SOMEHOW the C#'s equivalent of saying List<List<Vector3> myVector3 ?

No.

And anyway, how can I dynamically allocate this myVector3 object?

I don't understand the question.

I can't really understand what pointer to pointer is in C++.

Go back to first principals. What is a variable? A variable is storage for a value of a particular type .

What operations are available on variables? They may be read from , written to , or their address may be taken .

What is the result of the address-taking operator, & ? A pointer to the variable.

What is a pointer? A value that represents a variable .

What operations are available on pointer values? A pointer may be dereferenced using * . Doing so produces a variable . (There are other operations available on pointers but let's not worry about those.)

So let's sum up.

Foo foo; is a variable of type Foo . It can contain a Foo .

&foo is a pointer. It is a value. When dereferenced it produces the variable foo :

Foo foo;
Foo *pfoo = &foo;
*pfoo = whatever; // same as foo = whatever

pfoo is a variable. A variable may have its address taken:

Foo **ppfoo = &pfoo;
*ppfoo = null;  // Same as pfoo = null.  Not the same as foo = null.

So there you go. ppfoo is a variable. It contains a value. Its value is a pointer. When that pointer is dereferenced it produces a variable. That variable contains a value. That value is a pointer. When it is dereferenced it produces a variable. That variable is of type Foo .

Make sure this is very clear in your mind. When you get confused, go back to first principles . Pointers are values, they may be dereferenced, doing so produces a variable. Everything flows from that.

Answer 2

The C++ equivalent of a List would be std::vector. Never mind that your class is called vector; this is a vector as in a dynamically expandable sequence of like-typed objects.

If you want a list of lists of Vector3 in C++, you want

std::vector<std::vector<Vector3> myVectorVectorVictor;

And that allocates one too. No pointers needed.

Answer 3

Vector3 **myVector3;

Is basically just a pointer pointing to another pointer. Dereferencing it gives you a pointer to a Vector3 .

example :

#include <iostream>

class Vector3
{
public:
    float x, y, z;
    //some constructors and methods
};

int main()
{
    Vector3 **myVector3 = new Vector3*[50]; // allocate 50 Vector3 pointers and set myVector3 to the first, these are only pointers, pointing to nothing.
    //myVector3[0]->x; myVector3[0] is a Vector3 pointer, currently pointing to nothing dereferencing this will result in Undefined Behaviour
    myVector3[0] = new Vector3; // allocate a Vector3 on the heap and let pointer 1 ( of the 50 ) point to this newly allocated object.
    myVector3[0]->x = 5;
    std::cout << "myVector3[0]->x : " << myVector3[0]->x; // prints "myVector3[0]->x : 5"
    std::cin.get();
}

Answer 4

You can do something like this:

Vector3 * pointer = new Vector3; // points to a instance of Vector3 on the heap
Vector3 * * pointerToPointer = & pointer; // points to pointer; we take the address of pointer