c++ - ultimos - Miembros de la clase y asignación explícita de pila/pila

video question tags

Question

Digamos que tenemos 4 clases de la siguiente manera:

class A
{
public:
A(void) : m_B()
{
}
private:
B m_B;
}
class B
{
public:
B(void)
{
m_i = 1;
}
private:
int m_i;
}
class C
{
public:
C(void)
{
m_D = new D();
}
~C(void)
{
delete m_D;
}
private:
D *m_D;
}
class D
{
public:
D(void)
{
m_i = 1;
}
private:
int m_i;
}

Digamos que hay 4 casos:

caso 1: A asignado externamente en la pila, B asignado internamente en la pila

A myA1;

caso 2: A asignado externamente en el montón, B asignado internamente en la pila

A *myA2 = new A();

caso 3: C asignada externamente en la pila, D asignada internamente en el montón

C myC1;

caso 4: C asignada externamente en el montón, D asignada internamente en el montón

C *myC2 = new C();

¿Qué pasa en cada uno de estos casos? Por ejemplo, en el caso 2, entiendo que el puntero myA2 está asignado en la pila, el objeto A existe en el montón, pero ¿qué pasa con el atributo m_B? Asumo el espacio en el montón asignado para él también porque no tendría sentido que un objeto exista en el espacio del montón y luego su atributo queda fuera del alcance. Si esto es cierto, ¿significa que la asignación de pila externa reemplaza la asignación de pila interna?

¿Qué pasa con el caso 3, myC1 se asigna en la pila, sin embargo m_D se asigna en el montón. ¿Qué pasa aquí? ¿Las dos partes se dividen en la memoria? Si eliminara ''eliminar m_D'' del destructor y myC1 quedara fuera del alcance, ¿habría una pérdida de memoria para el espacio asignado en el montón para m_D?

Si hay algún tutorial / artículo que explique esto en detalle, me encantaría un enlace.

Answer 1

Caso 1: todo en la "pila" (almacenamiento automático). Los recursos se liberan al salir del alcance.

Caso 2: myA2 está en el "montón", por lo que es m_B , y solo tiene que preocuparse por liberar los recursos ocupados por myA2 . es m_B se destruirá automáticamente cuando myA2 es.

Caso 3: myC1 está en la pila, m_D apunta a una D en el montón, pero el C destructor se encarga de eliminarlo, por lo que myC1 queda fuera del alcance, todos los recursos asignados dinámicamente se borran.

Caso 4: myC2 asignado dinámicamente, debe eliminarse para liberar recursos tomados por él. Al eliminarlo, se llamará a su constructor, que a su vez se hará cargo de su m_D , como en el caso 3.

No estoy seguro acerca de los artículos, estoy seguro de que hay muchos alrededor. Pero sugiero leer algunos buenos libros de C ++

Answer 2

Creo que estás confundiendo "asignación de pila / pila" y "variable automática".

Las variables automáticas se destruyen automáticamente al salir de contexto.

La asignación de pila es el hecho de que la memoria está asignada en la pila de ejecución. Y las variables asignadas en la pila son variables automáticas.

Además, los miembros son variables automáticas cuyos destructores son llamados cuando su propietario es destruido. En el caso de los punteros, se destruyen pero no son el objeto subyacente, debe llamar explícitamente a eliminar. Para asegurarse de que el objeto subyacente se destruye, debe utilizar punteros inteligentes o únicos.

Para decirlo de otra manera: las variables / miembros a los que tiene que llamar eliminar, no son variables automáticas.

Por último, los miembros de una clase se asignan en el mismo segmento de memoria del propietario.

En tu código:

• A.m_B es una variable automática. Si A está en la pila, también lo está B y A está en el montón, así es B.
• B.m_i y D.m_i son variables automáticas y se asignarán en el mismo segmento de memoria de su propietario
• El puntero C.m_D es una variable automática, pero el objeto puntiagudo de tipo D no lo es, tiene que llamar explícitamente a eliminar el puntero para eliminar el objeto subyacente. Por lo tanto, el puntero C.m_D se asigna en el mismo segmento de memoria, pero no al objeto subyacente. Está claro asignado por nuevo y estará en el montón.

Asi que:

• Caso 1: Todo está en la pila y es automático (es decir, destruido automáticamente).
• Caso 2: myA2 está en el montón y no es automático (tiene que delete myA2 ). Su miembro m_B2 es una variable automática que se destruirá cuando se destruya myA2 . Además, como myA2 está en el montón, m_B , como cualquier miembro de una clase, también está en el mismo espacio de memoria que el montón.
• Caso 3: myC1 está en la pila y es una variable automática. El puntero a m_D está en la pila, pero no el objeto apuntado por m_D que se asigna por nuevo en el montón.
• Caso 4: igual que myC2 pero myC2 está en el montón y no es automático. Así que tienes que eliminar myC2 (que eliminará m_D ).

Answer 3

Tu objeto es un pedazo de memoria organizada. El objeto no asigna sus miembros en la pila, solo consiste en sus miembros.

Caso 2: todo el objeto existe en el montón, esto significa que todos sus miembros se encuentran en el montón.

Caso 3: todo el objeto existe en la pila. El truco es que no es la instancia de clase D quien es miembro de myC1 , pero el puntero a B es físicamente miembro de myC1 . Por lo tanto, el miembro de myC1 encuentra en la pila y apunta a una instancia D que se encuentra en el montón.