Aprendizaje de C ++ (c ++ 17) -parente de clase y constructor, destructor

Recientemente, el plato principal es bastante pesado, además de la base de revisar la clase y el objeto, no hay mucha necesidad de volver a estudiar, por lo que no hay mucho que recordar sobre el blog. Hoy vi el uso de la clase para padres, siento que esta pieza siempre ha sido vaga, todavía tengo que recordar.

---

---

Blog de LeoRanbom

Dirección de publicación original : https://www.cnblogs.com/ranbom/

Blogger LeoRanbom

Solo publicado en el blog de la dirección de publicación original, se rastrean todos los demás lugares.

Si crees que es bueno, espero que te guste.

---

Clase principal y constructor

Al crear un objeto, la clase padre y los objetos contenidos en él se crean al mismo tiempo.

El orden de ejecución es aproximadamente el siguiente:

1. Primero ejecute el constructor de clase padre
2. Luego ejecute el constructor del objeto miembro de datos
3. Finalmente, se ejecuta el constructor de la clase misma.

Pero si tienes un conocimiento real en la práctica, aún es un poco más profundo.

#include<iostream>
#include<vector>
#include<algorithm>
#include<random>
#include<chrono>
using namespace std;

class Something{
public:
    Something() { cout << 2; }
};

class Based {
public:
    Based() {
        cout << 1;
    }
};
class Derived : public Based {
public:
    Derived() { cout << 3; }
private:
    Something mSomething;
};
int main() {
    Derived derived;
}

El resultado es la salida 123. Conformarse.

Si el constructor de la clase principal tiene parámetros, puede usar el inicializador junto al constructor de la clase secundaria para vincular el constructor.

Al ver mi cabecita aquí, tengo una gran duda: ¿no se ejecuta primero el constructor de la clase principal? ¿Es útil que el constructor de la subclase pase al inicializador de la clase principal? Nada está escrito en el libro, solo tóquelo.

class Something{
public:
    Something() { cout << 2; }
};

class Based {
public:
    Based(int i) {
        cout << i;
    }
};
class Derived : public Based {
public:
    Derived():Based(7){ cout << 3; }
private:
    Something mSomething;
};
int main() {
    Derived derived;
}

Como anteriormente, cambié el constructor del padre basado en el constructor parametrizado, y luego usé el inicializador en el constructor de la clase hija derivada para pasar parámetros al padre basado. La salida es 723. Bien, probablemente entiendo cómo es una ley de salida.

Métodos de llamadas de clase principal anulados por subclases

Hay nuevas dudas, pruébalo.

Reescritura ordinaria y métodos virtuales

class Something{
public:
    Something() { cout << 2; }
};

class Based {
public:
    Based() {
        pushout();
    }
    void pushout() { cout << 'a'; }
};
class Derived : public Based {
public:
    Derived() { pushout(); }
    void pushout() { cout << 'b'; }
private:
    Something mSomething;
};
int main() {
    Derived derived;//Based* ptr = new Derived同样的效果，输出a2b
}

Salida a2b, es decir, se llamará al constructor de la clase primaria cuando se cree el objeto de subclase, y el método de la clase primaria se ejecutará en el constructor.

¿Qué tal cambiar a un método virtual?

Probado y también salida a2b. Es decir, ya sea una reescritura de método ordinario o una reescritura de método virtual, llamará al método de la clase padre.

Si la subclase no se anula, se emite el método de la clase principal. a2a

Probé el constructor virtual por un tiempo, y el compilador informó que el constructor solo permitía tipos en línea.

Clase padre y destructor

Primer orden de lanzamiento:

1. Destructor de esta clase
2. Destruya los datos, entonces el siguiente es el destructor del miembro de datos
3. Destructor principal

Contrariamente al orden del constructor, fácil de recordar.

Al contrario del constructor que no puede ser virtual, ¡se recomienda el destructor! Sugerir! Lo mejor! Más virtual.

class Something{
public:
    Something() { cout << 2; }
    ~Something() { cout << 2; }
};

class Based {
public:
     Based() {
         cout << 1;
    }
     ~Based() { cout << 1; }
};
class Derived : public Based {
public:
    Derived() { cout << 3; }
    ~Derived() { cout << 3; }
private:
    Something mSomething;
};

int main() {
    Based* ptr = new Derived;
    delete ptr;
}

Este destructor de código no agrega virtual, y finalmente genera 1231, es decir, el destructor de la subclase y el miembro de datos no se llama, lo cual es un error grave.

Y después de agregar, generará 123321.

Llame al método original de la clase padre en el método de reescritura de subclase

No hay forma de ejecutar el código directamente. Lo comprobé porque las reglas de resolución de nombres de C ++ analizan primero el alcance local, luego el alcance de la clase. Entonces la subclase se llamará a sí misma sin parar, formando una recursión infinita. Si desea llamar a este método de la clase padre, debe llamarlo con Based :: pushout ().

Se encontró que la palabra clave __super es compatible con Visual C ++ (2 barras inferiores)

Puede usar el nombre del método __super :: para referirse al método padre. (Parece que esto también es cierto para Java?)