Se puede declarar un puntero en el montón?
-
16-09-2019 - |
Pregunta
Este es el método para crear 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*;
Esto parece que podría dar lugar a un código muy, muy peligroso. ¿Alguien sabe si esto es posible / cómo utilizarlo correctamente?
Solución
int** ppint = new int*;
*ppint = new int;
delete *ppint;
delete ppint;
Otros consejos
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 se ubicará en el montón.
Sí, puede declarar un puntero a un puntero ... y sí, el puntero se encontrará en el montón.
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.
No se puede hacer
T *ptr = new T*;
ya que el tipo de retorno de new foo
es "puntero a foo" o foo *
.
Puede hacer
T **ptr = new T*;