¿Puedes declarar un puntero en el montón?

Question

Este es el método para la creación de una variable en el montón en C++:

T *ptr = new T; 

ptr se refiere a un puntero a la nueva T, obviamente. Mi pregunta es, ¿puede hacer esto:

T *ptr = new T*; 

Eso parece que podría conducir a un código muy, muy peligroso. ¿Alguien sabe si esto es posible/cómo usarlo correctamente?

Answer 1

int** ppint = new int*; 
*ppint = new int; 

delete *ppint; 
delete ppint; 

Answer 2

Sí, puede declarar un puntero a un puntero ... y sí, el puntero estará en el montón.

Answer 3

new T* devuelve un puntero a un puntero a una T. Así que la declaración no es correcta, que debe ser:

T** ptr = new T*; 

Y residirá en el montón.

Answer 4

No se puede hacer

T *ptr = new T*; 

ya que el tipo de retorno de new foo es "puntero a foo" o foo *.

Usted puede hacer

T **ptr = new T*; 

Answer 5

Se mencionó como por qué es posible que tenga algo como esto. Lo que viene a la mente es una matriz dinámica. (La mayoría de las implementaciones de vectores utilizan esta realidad.)

// Create array of pointers to object 
int start = 10; 
SomeObject** dynamic = new SomeObject*[start]; 
// stuff happens and it gets filled 
// we need it to be bigger 
{ 
    SomeObject** tmp = new SomeObject*[start * 2]; 
    for (size_t x = 0; x < start; ++x) 
     tmp[x] = dynamic[x]; 
    delete [] dynamic; 
    dynamic = tmp; 
} 
// now our dynamic array is twice the size 

Como resultado de ello, copiamos un montón de punteros para aumentar nuestro arsenal, no los propios objetos.