C++之类继承的内存分析

 总结

1. 创建派生类对象，先调用基类的构造函数，再调用派生类的构造函数
2. 销毁派生类对象时，先调用派生类的析构函数，再调用基类的析构函数
3. 创建派生类对象时只会申请一次内存，派生类对象包含了基类的内存空间，this指针是相同的。
4. 创建派生类对象时，先初始化基类对象，再初始化派生类对象

重载new  delete关键字

void* operator new(size_t size)
{
    void* pt = malloc(size);
    cout << "申请到的内存的地址是：" << pt << endl;
    return pt;
}

void operator delete( void * pt)
{
    if (pt == nullptr) return;
    free(pt);
    cout << "释放内存。\n";
}

类继承（基类、派生类）

class A {
public:
    int a = 10;
protected:
    int b = 20;
private:
    int c = 30;
public:
    A() {
        cout << "A对象在内存中地址：" << this << endl;
        cout << "A中a在内存中地址：" << &a << endl;
        cout << "A中b在内存中地址：" << &b << endl;
        cout << "A中c在内存中地址：" << &c << endl;
    }
    void func()
    {
        cout << "c=" <<c<< endl;
    }
};

class B : public A
{
public:
    int  d = 40;
    B() {
        cout << "B对象在内存中地址：" << this << endl;
        cout << "B中a在内存中地址：" << &a << endl;
        cout << "B中b在内存中地址：" << &b << endl;
        cout << "B中d在内存中地址：" << &d << endl;
    }
};

main函数调用（业务逻辑）

注意：在C++中，不同继承方式的访问权限只是语法上的处理，实际上可直接操作内存进行访问和修改相应参数，如： *((int*)b + 2) = 1314;

int main()
{
    //继承的对象模型
    cout << "基类占用内存大小为：" << sizeof(A) << endl;
    cout << "派生类占用内存大小为：" << sizeof(B) << endl;

    B* b = new B;
    cout << "b指针指向的地址为：" << b << endl;
  
    b->func();//通过成员函数访问受保护的成员变量A.c
    //通过操作内存访问A->c
    *((int*)b + 2) = 1314;
    b->func();//通过成员函数访问受保护的成员变量A.c
    delete b;
}

运行结果：

---

继承的特殊关系

        派生类和基类有特殊关系，派生类对象包含了基类对象，内存模型是匹配的，用基类的方法来操作派生类对象是合法的，即基类指针可以在不进行显式转换的情况下指向派生类对象，但只能操作属于基类对象的成员变量和成员函数！

        其中B是派生类，A是基类。

B b;
A* a=&b;

---

虚继承可以解决菱形继承的二义性和数据冗余问题 

多继承--->菱形继承-------->虚继承，增加了复杂性。

用法：

class A
{
public:
        int a = 10;
};

class B: virtual  public A
{};

class C : virtual public A
{};

class D : public B, public C
{};

---

 虚函数

有了虚函数，基类指针指向基类对象时就是用基类的成员函数和数据，指向派生类时就是用派生类的成员函数和数据；否则，当出现基类和派生类出现同名函数时，该指针若指向派生类，访问的依然还是基类的成员函数和数据

class A
{
public:
    string  name="\0";
    virtual void show();//声明虚函数
    
};
 void A::show()
{
        cout << "class A的show():\t" << name << endl;
}

class B: public A
{
public:
   int  num = 0;
    void show()
    {
        cout << "class A的show():\t" << name<<", "<<num<<endl;
    }
};


int main()
{
    //虚函数
    A a; a.name = "gml";
    B b; b.name = "jhx"; b.num =1314;
    A* a1;
    a1= &a;
    a1->show();
    a1 = &b;
    a1->show();//这里只会调用派生类的show方法，因为在基类声明和定义了虚函数
}

运行结果：

---

多态的对象模型

使用多态时，若派生类没有重写基类中的虚函数方法，则会去调用基类中的原始虚函数方法

用基类指针指向派生类对象是多态的精髓。基类指针不能调用派生类的成员函数（除非多态）

delete 空指针是安全的，但是，delete野指针会造成程序的崩溃，故而，在delete 指针后，需要有将指针置空的操作，防止操作野指针！

---

纯虚函数

        纯虚函数是一种特殊的虚函数，具有纯虚函数的类成为抽象类（不能实例化对象，但可以创建指针和引用），派生类若不定义抽象类，则也属于抽象类，其中在基类中不能对虚函数给出有意义的实现，故而可以将其声明为纯虚函数（没有函数体，可以写上函数体，但实际上永远不会调用，逻辑上等于没有）

语法：

virtual 返回值类型 函数名 (参数列表)=0

//纯虚函数
    virtual  void  func()=0 { cout << "hello  world!" << endl; }

---

danamic_cast

danamic_cast只适用于多态场景（将基类指针转换为派生类指针，建议不要讲其应用于引用），示例如下：其中gbwz是派生类。

目的：调用派生类中的非虚函数方法，因为基类指针不能访问派生类中的非虚函数方法，故而，只能转换指针对象

  gbwz* pt1 = dynamic_cast<gbwz *> (pt);

---

 typeid运算符和type_Info类

type_info类的构造函数是private属性的，没有拷贝构造函数，不用实例化，由编译器在内部实例化

用name()成员函数可返回数据类型的字符串，进而判断，（在编译器转换类型的情况下不建议使用）

 typeid运算符在多态场景下，可用于在运行阶段识别对象的数据类型

 typeid运算符用于空指针时，将引发bad_typeid异常！！

Hero* pt =nullptr;
cout << "typeid(*pt)=" << typeid(*pt).name() << endl;