C++学习笔记-多态

最新推荐文章于 2025-12-18 16:28:22 发布
原创 最新推荐文章于 2025-12-18 16:28:22 发布 · 392 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++

本文介绍了C++中的多态性，主要关注动态多态的实现，即通过虚函数来实现。讲解了虚函数的概念、声明与定义，以及为什么需要虚函数来实现多态。此外，还探讨了虚函数的访问方式，包括通过对象、指针和引用调用。同时，文章提到了虚析构函数的重要性，以及虚函数表在对象内存布局中的角色。最后，讨论了抽象类和纯虚函数的应用。

多态

概述

所谓多态，其实就是：一个接口，多种方法；或者换种说法：发出同样的消息（函数调用），被不同类型的对象接收时（不同的函数拥有者），有可能导致完全不同的行为。

我们前面说过的函数重载（当然也包括运算符重载），就是一种多态，一个函数名（接口），对应多种具体的实现，它属于静态的多态，下一章要讲的模板也是静态多态，一套接口（函数/类）对应不同的数据类型或者行为（因为算法本身也可以作为模板参数）；另外基于对象的编程也可以看成是静态多态，接口类里面是一些function，然后具体使用时，可以使用bind绑定不同的实现，类似于挂衣架，流水的衣服，铁打的挂衣架。

静态多态是指编译期就可以确定函数的入口地址，而本章要讲的是动态多态，它只有到运行期才能确定函数入口地址。动态多态在效率上要比静态多态差，因为有额外的运行时开销。

放到C++语言层面，多态其实就是指同一个操作作用于不同的对象会产生不同的响应。

多态的优点：多态使得我们可以以一致的观点对待同一基类的所有派生类，减轻了分别设计的负担，提高了代码重用度。

C++通过虚函数来实现动态多态以及简单的RTTI。

静态联编与动态联编：

静态联编：
程序调用函数时，具体应使用哪个代码块是由编译器决定的。以函数重载为例，C++编译器根据传递给函数的参数和函数名决定具体要使用哪一个函数，称为联编（binding）。

编译器可以在编译过程中完成这种联编，在编译过程中进行的联编叫静态联编（static binding）或早期联编（early binding）。

动态联编：
在一些场合下，编译器无法在编译过程中完成联编，必须在程序运行时完成选择，因此编译器必须提供这么一套称为“动态联编”（dynamic binding）的机制，也叫晚期联编（late binding），C++通过虚函数来实现动态联编。

虚函数

虚函数的定义和声明

将成员函数声明为虚函数，只需要在成员函数原型前加一个关键字virtual即可。

注：
1. 构造函数不能声明为虚函数
2. 虚函数不能声明为static函数

如果一个基类的成员函数定义为虚函数，那么，它在所有派生类中也保持为虚函数；即使在派生类中省略了virtual关键字，也仍然是虚函数。

派生类可根据需要对基类虚函数进行override，上一章说过，override的格式要求很严：

  • 与基类的虚函数有相同的参数个数；
  • 与基类的虚函数有相同的参数类型；
  • 与基类的虚函数有相同的返回类型。

说白了，就是要一模一样，并且是虚函数。

为什么多态需要虚函数：
#include <iostream>
using std::cout;
using std::endl;

class Base
{
public:
    virtual      // 加与不加大不相同
    void disp()
    {
        cout << "Base::disp" << endl;
    }
};

class Child1 : public Base
{
public:
    void disp() // 派生类child1中定义的disp函数将base类中定义的disp函数隐藏
    {
        cout << "Child1::disp" << endl;
    }
};

class Child2 : public Base
{
public:
    void disp() // 派生类child2中定义的disp函数同样会隐藏base类中定义的disp函数
    {
        cout << "Child2::disp" << endl;
    }
};

void Display(Base* pb) // 目的是实现同一接口（函数），处理不同类对象
{
    pb->disp();
}

int main()
{
    Base *pBase = NULL; 

    Base obj_base;
    Child1 obj_child1;
    Child2 obj_child2;

    pBase = &obj_child1;
    pBase->disp(); // no virtual: Base::disp | virtual: Child1::disp

    // 通过指针调用
    Display(&obj_base); // no virtual: Base::disp | virtual: Base::disp
    Display(&obj_child1); // no virtual: Base::disp | virtual: Child1::disp
    Display(&obj_child2); // no virtual: Base::disp | virtual: Child2::disp
    (*pBase).disp(); // no virtual: Base::disp | virtual: Child1::disp

    getchar();
    return 0;
}

从代码中可以看到，只有虚函数，才能实现一个接口（void Display(Base*)），多种行为（Display(&obj_base), Display(&obj_child1), Display(&obj_child2)具有不同行为）。至于虚函数时怎样实现多态的我们后面会分析。

虚函数的访问

  1. 通过对象名访问：

    和普通函数一样，虚函数一样可以通过对象名来调用，此时编译器采用的是静态联编。

    通过对象名访问虚函数时, 调用哪个类的函数取决于定义对象名的类型。对象类型是基类时，就调用基类的函数；对象类型是子类时，就调用子类的函数。

  2. 通过指针访问：
    使用指针访问非虚函数时，编译器根据指针本身的类型决定要调用哪个函数，而不是根据指针指向的对象类型；

    使用指针访问虚函数时，编译器根据指针所指对象的类型决定要调用哪个函数(动态联编)，而与指针本身的类型无关。

  3. 通过引用访问
    使用引用访问虚函数，与使用指针访问虚函数类似；

    不同的是，引用一经声明后，引用变量本身无论如何改变，其调用的函数就不会再改变，始终指向其开始定义时的函数。

  4. 类成员函数中访问
    在类内的成员函数中访问该类层次中的虚函数，采用动态联编，要使用this指针。

  5. 通过构造函数或析构函数中访问：
    构造函数和析构函数是特殊的成员函数，在其中访问虚函数时，C++采用静态联编，即在构造函数或析构函数内，即使是使用“this->虚函数名”的形式来调用，编译器仍将其解释为静态联编的“本类名::虚函数名”。即它们所调用的虚函数是自己类中定义的函数，如果在自己的类中没有实现该函数，则调用的是基类中的虚函数。但绝不会调用任何在派生类中重定义的虚函数。

炎炎夏日，来个例子清爽一下：

#include <iostream>

class Base
{
public:
    void Show()
    {
        Disp(); // <=> this->Disp()
    }
    virtual void Disp()
    {
        std::cout << "Base::Disp()" << std::endl;
    }
};

class Child : public Base
{
public:
    //void Show()
    //{
    //  Disp();
    //}
    void Disp() override
    {
        std::cout << "Child::Disp()" << std::endl;
    }
};

int main(void)
{
    Base base;
    Child child;

    // 直接通过对象调用，与普通继承效果一样
    base.Disp();         // Base::Disp()
    child.Disp();        // Child::Disp()
    child.Child::Disp(); // Child::Disp()
    child.Base::Disp();  // Base::Disp()

    // 通过基类指针调用，触发多态
    Base *p = &child;
    p->Disp();           // Child::Disp()

    Base *p2 = &base;
    p2 = &child;
    p2->Disp();          // Child::Disp()

    // 通过引用调用，与指针类似，但由于引用的特性，必须定义同时初始化，再不可更改绑定
    // 即使改了，也不是改的引用，而是引用的对象，这与指针不同。
    Base &ref = child;
    ref.Disp();          // Child::Disp()

    Base &ref2 = base;

    ref2 = child; // 引用还是指向base，相当于base = child; 
                  // 没有多态，存在对象切割，现在base就是child'体内'的那个Base了。
    ref2.Disp();         // Base::Disp()

    // 通过成员函数调用
    p = &child;
    p->Show();           // Child::Disp()
    p = &base;
    p->Show();           // Base::Disp()

    return 0;
}
虚析构函数

虽然构造函数不能被定义成虚函数，但析构函数可以定义为虚函数，一般来说，如果类中定义了虚函数，析构函数也应被定义为虚析构函数，尤其是类内有申请的动态内存，需要清理和释放的时候。

只需要在基类的析构函数前面加virtual即可，派生类的析构函数会自动变为虚函数的。

如果一个类要作为多态基类，就应当使用虚析构函数。

如果一个类永远不会被派生类继承，就不要定义成虚函数，无端增加数据复杂性。

#include <iostream>
using std::cout;
using std::endl;

class Base
{
private:
    char* data;

public:
    Base()
    {
        data = new char[64];
        cout << "Base::Base()" << endl;
    };

    virtual ~Base() // 虚析构函数
    {
        delete[] data;
        cout << "Base::~Base()" << endl;
    };
};

class Child : public Base
{
private:
    char* m_data;

public:
    Child() :Base()
    {
        m_data = new char[64];
        cout << "Child::Child()" << endl;
    };

    ~Child() // 析构函数，继承虚拟virtual，不需要再加virtual
    {
        delete[] m_data;
        cout << "Child::~Child()" << endl;
    };
};

class GrandChild :public Child
{
private:
    char* mm_data;

public:
    GrandChild() :Child()
    {
        mm_data = new char[64];
        cout << "GrandChild::GrandChild()" << endl;
    };

    ~GrandChild() // 虚析构函数，virtual从继承结构中得来
    {
        delete[] mm_data;
        cout << "GrandChild::~GrandChild()" << endl;
    };
};

int main()
{
    Base *pB = new Child;
    delete pB; // 调用的是指针指向的实际对象(Child对象)的析构函数，而
               // Child::Child()又会调用Base::Base()，这样就没有内存泄漏。

    cout << "=============" << endl;

    Child* pC = new GrandChild; 
    delete pC; // 调用的是指针指向的实际对象(GrandChild对象)的析构函数，而
               // GrandChild::GrandChild()又会调用Child::Child()，这样
               // 就没有内存泄漏。

    cout << "======不推荐下面这种用法=======" << endl;

    GrandChild *pG = (GrandChild *)new Base;
    delete pG; // 调用的是指针指向的实际对象(Base对象)的析构函数

  // -> 如果去掉基类析构函数前的virtual, 执行到
               // delete[] mm_data时调用的将是GrandChild::~GrandChild()，
               // 会报内存错误, 因为mm_data, m_data根本就没有new


    return 0;
}
虚函数表

如果类中包含有虚成员函数，在用该类实例化对象时，对象的第一个成员（4/8个字节）将是一个指向虚函数表(vftable)的指针(vfptr)。虚函数表记录运行过程中实际应该调用的虚函数的入口地址。

更详细的可以参见陈皓的C++ 对象的内存布局。

单继承 + 虚函数：

#include <iostream>
#include <fstream>
using std::endl;

std::ofstream cout("C:/Users/StarrySky/Desktop/text.txt");
class Garbo
{
public:
    ~Garbo()
    {
        cout.close();
    }
};
Garbo garbo;

class Parent {
public:
    Parent () : iparent (10) {}
    virtual void f() { cout << "Parent::f()"; }
    virtual void g() { cout << "Parent::g()"; }
    virtual void h() { cout << "Parent::h()"; }
public:
    int iparent;
};

class Child : public Parent {
public:
    Child() : ichild(100) {}
    virtual void f() { cout << "Child::f()"; }
    virtual void g_child() { cout << "Child::g_child()"; }
    virtual void h_child() { cout << "Child::h_child()"; }
public:
    int ichild;
};

class GrandChild : public Child{
public:
    GrandChild() : igrandchild(1000) {}
    virtual void f() { cout << "GrandChild::f()"; }
    virtual void g_child() { cout << "GrandChild::g_child()"; }
    virtual void h_grandchild() { cout << "GrandChild::h_grandchild()"; }
public:
    int igrandchild;
};

int main(void)
{
    typedef void(*Fun)(void);
    GrandChild gc;
    Fun pFun;
    int** pVtab = (int**)&gc;

    cout << "[0](" << pVtab << ") GrandChild::vfptr" << endl;
    for (int i=0; (Fun)pVtab[0][i]!=NULL; i++){
        pFun = (Fun)pVtab[0][i];
        cout << "    |-- ["<<i<<"](" << pVtab[0] + i << ") ";
        pFun();
        cout << endl;
    }
    cout << "[1](" << pVtab+1 << ") Parent::iparent = " << (int)pVtab[1] << endl;
    cout << "[2](" << pVtab+2 << ") Child::ichild = " << (int)pVtab[2] << endl;
    cout << "[3](" << pVtab+3 << ") GrandChild::igrandchild = " << (int)pVtab[3] << endl;

    return 0;
}

// [0](0018F82C) GrandChild::vfptr
//     |-- [0](001899B8) GrandChild::f() 
//     |-- [1](001899BC) Parent::g()
//     |-- [2](001899C0) Parent::h()
//     |-- [3](001899C4) GrandChild::g_child()
//     |-- [4](001899C8) Child::h_child()
//     |-- [5](001899CC) GrandChild::h_grandchild()
// [1](0018F830) Parent::iparent = 10
// [2](0018F834) Child::ichild = 100
// [3](0018F838) GrandChild::igrandchild = 1000

派生类override的虚函数，会覆盖虚函数表中基类的虚函数入口，多级继承，依次类推就是了。

多继承+虚函数：

#include <iostream>
#include <fstream>
using std::endl;

std::ofstream cout("C:/Users/StarrySky/Desktop/text.txt");
class Garbo {
public:
    ~Garbo()
    {
        cout.close();
    }
};
Garbo garbo;

class Base1 {
public:
    Base1 () : iBase1(10) {}
    virtual void f() { cout << "Base1::f()"; }
    virtual void g() { cout << "Base1::g()"; }
    virtual void h() { cout << "Base1::h()"; }
public:
    int iBase1;
};

class Base2 {
public:
    Base2() : iBase2(200) {}
    virtual void f() { cout << "Base2::f()"; }
    virtual void g() { cout << "Base2::g()"; }
    virtual void h() { cout << "Base2::h()"; }
public:
    int iBase2;
};

class Base3 {
public:
    Base3() : iBase3(300) {}
    virtual void f() { cout << "Base3::f()"; }
    virtual void g() { cout << "Base3::g()"; }
    virtual void h() { cout << "Base3::h()"; }
public:
    int iBase3;
};

class Derived : public Base1, public Base2, public Base3 {
public:
    Derived() : iDerived(1000) {}
    virtual void f() { cout << "Derived::f()"; }
    virtual void g_derived() { cout << "Derived::g_derived()"; }
public:
    int iDerived;
};

int main(void)
{
    typedef void(*Fun)(void);
    Fun pFun;
    Derived d;
    int** pVtab = (int**)&d;

    cout << "[0](" << pVtab << ") Base1::vfptr" << endl;
    pFun = (Fun)pVtab[0][0];
    cout << "    |-- [0] "; pFun(); cout << endl;

    pFun = (Fun)pVtab[0][1];
    cout << "    |-- [1] "; pFun(); cout << endl;

    pFun = (Fun)pVtab[0][2];
    cout << "    |-- [2] "; pFun(); cout << endl;

    pFun = (Fun)pVtab[0][3];
    cout << "    |-- [3] "; pFun(); cout << endl;

    pFun = (Fun)pVtab[0][4];
    cout << "    |-- [4] "; cout << pFun << endl;

    cout << "[1] Base1.ibase1 = " << (int)pVtab[1] << endl;

    int s = sizeof(Base1)/4;

    cout << "[" << s << "](" << pVtab + s << ") Base2::vfptr" << endl;
    pFun = (Fun)pVtab[s][0];
    cout << "    |-- [0] "; pFun(); cout << endl;

    pFun = (Fun)pVtab[s][1];
    cout << "    |-- [1] "; pFun(); cout << endl;

    pFun = (Fun)pVtab[s][2];
    cout << "    |-- [2] "; pFun(); cout << endl;

    pFun = (Fun)pVtab[s][3];
    cout << "    |-- [3] " << pFun << endl;

    cout << "["<< s+1 <<"] Base2.ibase2 = " << (int)pVtab[s+1] << endl;

    s = s + sizeof(Base2)/4;

    cout << "[" << s << "](" << pVtab + s << ") Base3::vfptr" << endl;
    pFun = (Fun)pVtab[s][0];
    cout << "    |-- [0] "; pFun(); cout << endl;

    pFun = (Fun)pVtab[s][1];
    cout << "    |-- [1] "; pFun(); cout << endl;

    pFun = (Fun)pVtab[s][2];
    cout << "    |-- [2] "; pFun(); cout << endl;

    pFun = (Fun)pVtab[s][3];
    cout << "    |-- [3] " << pFun << endl;

    s++;
    cout << "["<< s <<"](" << pVtab + s << ") Base3.ibase3 = " << (int)pVtab[s] << endl;
    s++;
    cout << "["<< s <<"](" << pVtab + s << ") Derive.iderive = " << (int)pVtab[s] << endl;

    return 0;
}

// [0](0043FC68) Base1::vfptr
//     |-- [0] Derived::f()
//     |-- [1] Base1::g()
//     |-- [2] Base1::h()
//     |-- [3] Derived::g_derived()
//     |-- [4] 00000000
// [1] Base1.ibase1 = 10
// [2](0043FC70) Base2::vfptr
//     |-- [0] Derived::f()
//     |-- [1] Base2::g()
//     |-- [2] Base2::h()
//     |-- [3] 00000000
// [3] Base2.ibase2 = 200
// [4](0043FC78) Base3::vfptr
//     |-- [0] Derived::f()
//     |-- [1] Base3::g()
//     |-- [2] Base3::h()
//     |-- [3] 00000000
// [5](0043FC7C) Base3.ibase3 = 300
// [6](0043FC80) Derive.iderive = 1000
  1. 每个父类都有自己的虚表。
  2. 子类新增的的虚函数被添加到了第一个父类的虚表后面。
  3. 内存布局中，其父类布局依次按声明顺序排列。
  4. 每个父类的虚表中的f()函数都被override成了子类的f()。这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。

钻石型继承-单级 + 虚函数：

#include <iostream>
#include <fstream>
using std::endl;

std::ofstream cout("C:/Users/StarrySky/Desktop/text.txt");
class Garbo {
public:
    ~Garbo()
    {
        cout.close();
    }
};
Garbo garbo;


class B
{
public:
    B() : ib(0), cb('B') {}
    virtual void f() { cout << "B::f()" << endl; }
    virtual void Bf() { cout << "B::Bf()" << endl; }
public:
    int ib;
    char cb;
};
class B1 : virtual public B
{
public:
    B1() : ib1(11), cb1('1') {}
    virtual void f() { cout << "B1::f()" << endl; }
    virtual void f1() { cout << "B1::f1()" << endl; }
    virtual void Bf1() { cout << "B1::Bf1()" << endl; }
public:
    int ib1;
    char cb1;

};
class B2 : virtual public B
{
public:
    B2() : ib2(12), cb2('2') {}

    virtual void f() { cout << "B2::f()" << endl; }
    virtual void f2() { cout << "B2::f2()" << endl; }
    virtual void Bf2() { cout << "B2::Bf2()" << endl; }
public:
    int ib2;
    char cb2;
};

class D : public B1, public B2
{
public:
    D() : id(100), cd('D') {}
    virtual void f() { cout << "D::f()" << endl; }
    virtual void f1() { cout << "D::f1()" << endl; }
    virtual void f2() { cout << "D::f2()" << endl; }
    virtual void Df() { cout << "D::Df()" << endl; }
public:
    int id;
    char cd;
};

int main(void)
{
    typedef void(*Fun)(void);
    Fun pFun = NULL;
    B1 bb1;
    int** pVtab = (int**)&bb1;

    cout << "[0] B1::_vfptr->" << endl;
    pFun = (Fun)pVtab[0][0];
    cout << "     [0] "; pFun(); //B1::f1();
    cout << "     [1] ";
    pFun = (Fun)pVtab[0][1]; pFun(); //B1::bf1();
    cout << "     [2] " << pVtab[0][2] << endl;

    cout << "[1] B1::_vptr->" << endl;
    cout << "     [0] " << pVtab[1][0] << endl;
    cout << "     [1] " << pVtab[1][1] << endl;

    cout << "[2] B1::ib1 = ";
    cout << (int)*((int*)(&bb1) + 2) << endl; // B1::ib1
    cout << "[3] B1::cb1 = ";
    cout << (char)*((int*)(&bb1) + 3) << endl; // B1::cb1
    cout << "[3] 0x ";
    cout << (char)*((int*)(&bb1) + 4) << endl; // B1::cb1

    cout << "[5] B::_vfptr->" << endl;
    pFun = (Fun)pVtab[5][0];
    cout << "     [0] "; pFun(); // B1::f();
    pFun = (Fun)pVtab[5][1];
    cout << "     [1] "; pFun(); // B::Bf();
    cout << "     [2] " << "0x" << (Fun)pVtab[5][2] << endl;

    cout << "[6] B::ib = ";
    cout << (int)*((int*)(&bb1) + 6) << endl; // B::ib
    cout << "[7] B::cb = ";

    return 0;
}

// [0] B1::_vfptr->
//      [0] B1::f1()
//      [1] B1::Bf1()
//      [2] 0
// [1] B1::_vptr->
//      [0] -4
//      [1] 16
// [2] B1::ib1 = 11
// [3] B1::cb1 = 1
// [3] 0x 0
// [5] B1::_vfptr->
//     [0] B1::f()
//      [1] B::Bf()
//      [2] 0
// [6] B::ib = 0
// [7] B::cb = B

钻石型继承 + 虚函数：

#include <iostream>
#include <fstream>
using std::endl;

std::ofstream cout("C:/Users/StarrySky/Desktop/text.txt");
class Garbo {
public:
    ~Garbo()
    {
        cout.close();
    }
};
Garbo garbo;


class B
{
public:
    B() : ib(0), cb('B') {}
    virtual void f() { cout << "B::f()" << endl; }
    virtual void Bf() { cout << "B::Bf()" << endl; }
public:
    int ib;
    char cb;
};
class B1 : virtual public B
{
public:
    B1() : ib1(11), cb1('1') {}
    virtual void f() { cout << "B1::f()" << endl; }
    virtual void f1() { cout << "B1::f1()" << endl; }
    virtual void Bf1() { cout << "B1::Bf1()" << endl; }
public:
    int ib1;
    char cb1;

};
class B2 : virtual public B
{
public:
    B2() : ib2(12), cb2('2') {}

    virtual void f() { cout << "B2::f()" << endl; }
    virtual void f2() { cout << "B2::f2()" << endl; }
    virtual void Bf2() { cout << "B2::Bf2()" << endl; }
public:
    int ib2;
    char cb2;
};

class D : public B1, public B2
{
public:
    D() : id(100), cd('D') {}
    virtual void f() { cout << "D::f()" << endl; }
    virtual void f1() { cout << "D::f1()" << endl; }
    virtual void f2() { cout << "D::f2()" << endl; }
    virtual void Df() { cout << "D::Df()" << endl; }
public:
    int id;
    char cd;
};

int main(void)
{
    typedef void(*Fun)(void);
    Fun pFun = NULL;
    B1 bb1;
    int** pVtab = (int**)&bb1;

    cout << "[0] D::B1::_vptr->" << endl;
    pFun = (Fun)pVtab[0][0];
    cout << "     [0] ";    pFun(); //D::f1();
    pFun = (Fun)pVtab[0][1];
    cout << "     [1] ";    pFun(); //B1::Bf1();
    pFun = (Fun)pVtab[0][2];
    cout << "     [2] ";    pFun(); //D::Df();
    pFun = (Fun)pVtab[0][3];
    cout << "     [3] ";
    cout << pFun << endl;

    cout << "[1] B1::_vptr->" << endl;
    cout << "     [0] " << pVtab[1][0] << endl;
    cout << "     [1] " << pVtab[1][1] << endl;

    cout << "[2] B1::ib1 = ";
    cout << *((int*)(&dd) + 2) << endl; //B1::ib1
    cout << "[3] B1::cb1 = ";
    cout << (char)*((int*)(&dd) + 3) << endl; //B1::cb1

    //---------------------
    cout << "[4] D::B2::_vptr->" << endl;
    pFun = (Fun)pVtab[4][0];
    cout << "     [0] ";    pFun(); //D::f2();
    pFun = (Fun)pVtab[4][1];
    cout << "     [1] ";    pFun(); //B2::Bf2();
    pFun = (Fun)pVtab[4][2];
    cout << "     [2] ";
    cout << pFun << endl;

    cout << "[5] B1::_vptr->" << endl;
    cout << "     [0] " << pVtab[5][0] << endl;
    cout << "     [1] " << pVtab[5][1] << endl;

    cout << "[6] B2::ib2 = ";
    cout << (int)*((int*)(&dd) + 6) << endl; //B2::ib2
    cout << "[7] B2::cb2 = ";
    cout << (char)*((int*)(&dd) + 7) << endl; //B2::cb2

    cout << "[8] D::id = ";
    cout << *((int*)(&dd) + 8) << endl; //D::id
    cout << "[9] D::cd = ";
    cout << (char)*((int*)(&dd) + 9) << endl;//D::cd

    cout << "[10]  = 0x";
    cout << (int*)*((int*)(&dd) + 10) << endl;

    //---------------------
    cout << "[11] D::B::_vptr->" << endl;
    pFun = (Fun)pVtab[11][0];
    cout << "     [0] ";    pFun(); //D::f();
    pFun = (Fun)pVtab[11][1];
    cout << "     [1] ";    pFun(); //B::Bf();
    pFun = (Fun)pVtab[11][2];
    cout << "     [2] ";
    cout << pFun << endl;

    cout << "[12] B::ib = ";
    cout << *((int*)(&dd) + 12) << endl; //B::ib
    cout << "[13] B::cb = ";
    cout << (char)*((int*)(&dd) + 13) << endl;//B::cb

    return 0;
}

// [0] B1::_vfptr->
//   [0] D::f1()
//      [1] B1::Bf1()
//      [2] D::Df()
//      [3] 0
// [1] B1::_vptr->
//      [0] -4
//      [1] 44
// [2] B1::ib1 = 11
// [3] B1::cb1 = 1
// [4] B2::_vfptr->
//   [0] D::f2()
//   [1] B2::Bf2()
//   [2] 0
// [5] B2::_vptr->
//      [0] -4
//      [1] 28
// [6] B1::ib1 = 12
// [7] B1::cb1 = 2
// [8] D::id = 100
// [9] D::cd = D
// [10] 0x0
// [11] B::_vfptr->
//   [0] D::f()
//   [1] B::Bf()
//   [2] 0
// [12] B::ib = 0
// [13] B::cd = B
  1. 先是B1，然后是B2，接着是D，而B这个超类的实例都放在最后的位置。
  2. 有一个NULL分隔符把B和B1和B2的布局分开。。
纯虚函数与抽象类

当在基类中无法为虚函数提供任何有实际意义的定义时，可以将该虚函数声明为纯虚函数，它的实现留给该基类的派生类去做。

class 类名 
{ 
    //...
    virtual 类型 函数名 (参数表)=0; // 纯虚函数
    //...
};

一个类可以包含多个纯虚函数。只要类中含有一个纯虚函数，该类便为抽象类。一个抽象类只能作为基类来派生新类，不能创建抽象类的对象。

和普通的虚函数不同，在派生类中一般要对基类中纯虚函数进行重定义，或者在派生类中再次将该虚函数声明为纯虚函数。这说明，抽象类的派生类也可以是抽象类，只有在派生类中给出了基类中所有纯虚函数的实现时，该派生类便不再是抽象类。抽象类只起到提供统一接口的作用。

对一个类来说，如果只定义了protected型（不能是private的）的构造函数而没有提供public构造函数，无论是在外部还是在派生类中作为其对象成员都不能创建该类的对象，但可以由其派生出新的类，这种能派生新类，却不能创建自己对象的类是另一种形式的抽象类

工厂类-动态创建对象

Dynbase.h：

#ifndef DYNBASE_H_
#define DYNBASE_H_

#include <string>
#include <iostream>
using std::cout;
using std::endl;
using std::string;
#include <map>
using std::map;

typedef void* (*CREATE_FUNC)();

// 工厂类->动态创建对象
// 新增类型后工厂类代码不需要做任何改动，比上一节用if-else好。
// 都是静态的，进入main之前就初始化好了。
class DynObjectFactory
{
public:
    static void* CreateObject(const string& name)
    {
        map<string,CREATE_FUNC>::const_iterator it;
        it = map_cls_.find(name);
        if (it == map_cls_.end()) { // 没找到
            return NULL;
        } else {
            return it->second();
        }
    }

    static void Register(const string& name, CREATE_FUNC func)
    {
        map_cls_[name] = func;
    }
private:
    static map<string, CREATE_FUNC> map_cls_;
};

// gcc __attribute((weak))  
__declspec(selectany) map<string, CREATE_FUNC> DynObjectFactory::map_cls_; // 这里不需要再加static

//
//#define REGISTER_CLASS(class_name) \
//static void* class_name##NewInstance() { \
//  return new class_name;\
//}\
//DynObjectFactory::Register(#class_name, class_name##NewInstance)

// 全局作用于不能调用除了main之外的函数,但是利用静态对象先于main构造+构造函数,就能实现全局调
// 用函数[静态对象的构造函数].
//class Register
//{
//public:
//  Register(const string& name, CREATE_FUNC func)
//  {
//        cout << "Register ..." << endl;
//      DynObjectFactory::Register(name, func);
//  }
//};

//#define REGISTER_CLASS(class_name) \
//class class_name##Register \
//{ \
//public: \
//  static void* NewInstance() \
//  { \
//      return new class_name; \
//  } \
//private: \
//  static Register reg_; \
//}; \
//Register class_name##Register::reg_(#class_name, class_name##Register::NewInstance)


template<typename T>
class DelegatingClass
{
public:
    DelegatingClass(const string name)
    {
        DynObjectFactory::Register(name, NewInstance);
    }

    static void* NewInstance()
    {
        return new T;
    }
};

#define REGISTER_CLASS(class_name) \
static DelegatingClass<class_name> class_name##Register(#class_name)

#endif // DYNBASE_H_

Shape.cpp：

#include "Shape.h"
#include "DynBase.h"
//#include <iostream>
using std::cout;
using std::endl;

Shape::~Shape() 
{
    cout << "~Shape ..." << endl;
}

void Circle::Draw()
{
    cout << "Circle::Draw() ..." << endl;
}

Circle::~Circle()
{
    cout << "~Circle ..." << endl;
}

void Square::Draw()
{
    cout << "Square::Draw() ..." << endl;
}

Square::~Square()
{
    cout << "~Square ..." << endl;
}

void Rectangle::Draw()
{
    cout << "Rectangle::Draw() ..." << endl;
}

Rectangle::~Rectangle()
{
    cout << "~Rectangle ..." << endl;
}

REGISTER_CLASS(Circle);
REGISTER_CLASS(Square);
REGISTER_CLASS(Rectangle);

用法：

// 可以把这些东西放到配置文件中去，新增了类这里的代码也不需要改动。
vector<Shape*> v;
Shape* ps;

ps = static_cast<Shape*>(DynObjectFactory::CreateObject("Circle"));
v.push_back(ps);

ps = static_cast<Shape*>(DynObjectFactory::CreateObject("Square"));
v.push_back(ps);

ps = static_cast<Shape*>(DynObjectFactory::CreateObject("Rectangle"));
v.push_back(ps);

RTTI

#include <iostream>
#include <typeinfo>
using std::cout;
using std::endl;

class Shape {
public:
    virtual void Draw() = 0;
    virtual ~Shape() {}
};

class Circle : public Shape {
public:
    void Draw() {
        cout << "Circle ..." << endl;
    }
};

class Square : public Shape {
public:
    void Draw() {
        cout << "Square ..." << endl;
    }
};

int main(void)
{
    Shape *p;
    Circle c;

    p = &c;
    p->Draw();

    cout << "================= dynamic_cast ========================" << endl;
    // 类型安全的向下转型，只有基类指针确实指向该类时，向该类转型才会成功。
    // 这种运行时类型识别，比用虚函数的开销大。基类需要有虚函数才能利用dynamic_cast
    // C++的多态机制中，保存了RTTI信息，位于虚表之前，C++的dynamic_cast通过查询该
    // 内存段的信息，可以获知运行时信息。
    if (dynamic_cast<Circle*>(p)) {
        cout << "p is Circle object" << endl;
    } else if (dynamic_cast<Square*>(p)) {
        cout << "p is Square object" << endl;
    } else {
        cout << "p is Other object" << endl;
    }

    cout << "================= typeid ========================" << endl;
    // 返回一个type_info类对象
    // 效率也没直接虚函数效率高
    cout << typeid(*p).name() << endl;
    cout << typeid(Circle).name() << endl;
    if (typeid(*p).name() == typeid(Circle).name()) {
        cout << "p is point to a Circle object" << endl;
        ((Circle*)p)->Draw();
    } else if (typeid(*p).name() == typeid(Square).name()) {
        cout << "p is point to a Square object" << endl;
        ((Square *) p)->Draw();
    }

    getchar();
    return 0;
}
黑马程序员c++学习笔记----c++核心编程
qq_36421001的博客
02-28 7943
c++核心编程 本阶段主要针对cpp面向对象编程技术做详细讲解，探讨cpp中的核心和精髓。 1 内存分区模型 cpp程序在执行时，将内存大方向划分为4个区域 代码区：存放函数体的二进制代码，由操作系统进行管理的 全局区：存放全局变量和静态变量以及常量 栈区：由编译器自动分配释放, 存放函数的参数值,局部变量等 堆区：由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收 内存四区意义： 不同区域存放的数据，赋予不同的生命周期, 给我们更大的灵活编程 1.1 程序运行前 ​ 在程序编译后，生成了ex
C#学习笔记21-多态之抽象类
weixin_44985601的博客
02-29 432
C#学习笔记21-多态之抽象类抽象类抽象类特点抽象类实例 抽象类 在前一篇博客C#学习笔记20-多态之虚方法中，我们提到实现多态存在有三种方法，前一篇讲解了虚方法，这一篇继续复习抽象类。当父类中的方法不知道如何去实现时，可以将父类写成抽象类，方法写成抽象类，比如小明打球，小平打球，但是他们如何打球未知，此时就可以写成抽象类来描述 抽象类，顾名思义就是一个抽象的，没有实体（没有具体实现）的类，即抽象...
Java多态学习笔记
weixin_34283445的博客
03-04 244
面向对象三大特性：封装，继承和多态。其中，封装，继承都比较通俗易懂，唯有多态令我甚是头疼。经过仔细研究之后，终于搞懂了一点，特来做一个分享。独乐乐不如众乐乐。 何为多态？多态的本质是：一个程序中同名的不同方法。在面向对象的程序设计中，多态主要有以下三种方式来实现。 （1）、通过子类对父类方法的覆盖来实现多态。 （2）、通过一个类中...
（笔记）多态：向上转型，局部变量实现多态
weixin_42325507的博客
08-01 339
主要体现在，调用时通过：父类名  实例名=new 子类名（形参）；           将父类实例化为子类（本身还是父类实例），再使用这个父类实例去调用父类中的方法（或属性）；           此时实际上发生作用的是子类中重写的方法（或属性）。 以下是例题： 以下类都在同一包中： package ch13.day0801.zy.zy02; public class Test ...
笔记_多态
Java123456_的博客
11-02 310
1. 多态的概述 1.1 多态的概述 同一种事物表现出来的多种形态则称为多态。 "俊杰" ==> 班长 "俊杰" ==> 儿子 "俊杰" ==> 父亲 "俊杰" ==> 路人甲 1.2 多态的前提 必须有子父类关系或类实现接口关系 必须有方法重写 必须有父类引用指向子类对象或接口引用指向实现类对象 1.3 多态的格式 父类类名 变量名 = ne...
JAVA多态的笔记
qq_45148387的博客
08-14 235
1、面向对象的三大特征：封装性，继承性、多态性。 2、extents继承和implements实现，是多态性的前提。 3、一个对象的多种形态就是：对象的多态性！ 代码当中体现多态性，其实就是一句话：父类引用指向子类对象。 格式： 父类名称 对象名 = new 子类名称（）；【左父右子】 或者： 接口名称 对象名= new 实现类名称（）； //调用类 public class Demo01Multi { public static void main(String[] args) {
多态学习笔记
weixin_52769303的博客
05-18 169
多态学习笔记 概念 多态是一个事物在不同时刻体现的不同形态（内存中的变化） 前提条件 1.必须存在继承关系 2.必须有方法重写 3必须存在父类引用 指向子类对象（向上转型） 格式 class Fu{} class Zi extends Fu{} Fu fu=new Zi(); 多态中成员访问 成员变量，编译看左，运行看左， 内存中：引用父类创建对象，在堆内存中创建对象的同时，堆内存中会传入父类的成员变量； 非静态成员方法，编译看左，运行看右， 内存中：创建对象时，子类方法函数会
C++学习笔记- 面向对象 .md
11-13
C++学习笔记，博主个人向。内容是C++面对对象的，目录大致来源于菜鸟文档的C++面向对象，笔记是参考各种文章以及菜鸟文档改编的，内容包含C++类和对象（类定义和对象定义，类成员函数，类访问修饰符，友元函数，内联...
C++：类和对象-多态练习题3-三台电脑组装
11-22
在C++编程语言中，面向对象编程（OOP）是核心概念之一，其中类和对象、继承、多态是OOP的三大特征。本练习题主要围绕“多态”这一核心概念进行展开，以“三台电脑组装”作为实际应用背景，加深学习者对多态性质的...
精选资源
我的笔记-qt-c++-c#-后面持续更新.7z
12-06
这个压缩包显然包含了作者在这些主题上的学习笔记，可能是教程、代码示例、问题解决方案或者个人心得。 【描述】"只要是我的一些笔记，关于qt,c#,C++的，用来做个备份，防止本地不小心删掉了" 说明了这些笔记的主要...
多态的学习笔记
performance
08-29 519
多态：不同的对象可以执行相同的动作，但是是使用它们自己实现的方法来完成； 可以理解为：父类和子类都实现了一个相同的方法 当将一个子类当做父类来使用的时候：注意：子类以父类的身份出现，此时它的类型是父类；子类在工作的时候使用自己的方法而不是父类的方法(即使它已经被当做父类了)；子类此时已经'是'父类了，子类特有的属性和方法(即父类没有的属性和方法)不能使用：例：C++函数调用中对一个参数要求为父
c++多态的案例分析
疯子阳1991
08-09 1818
最近在研究c++中多态的应用 ，其中遇到些许的疑问与问题，但是最终的结果是不容置疑的，下面记录下我的学习过程，以纪念本个知识点。 首先，是从一个案例开始的，题目大意是这样的： 设定一个多边形的公共类，然后再设定多个图形的各个派生类，最后通过基类，根据多态的应用通过基类，求出所求图形的面积 于是根据自己所学的知识，开始大致的勾画原始的雏形如下： #include using
在C++中，要实现动态联编，必须使用（基类指针）调用虚函
热门推荐
LAKE521的专栏
12-15 1万+
面向对象编程的感想
welkint的专栏
02-05 1091
面向对象（oop）是基于“对象”方法学理论为基础的。对象是由数据和允许的操作组成的装封客体。主要特性在于继承，多态，封装。。。继承：一种代码重用的技术，使子类继承的父类的所有特性被能添加自己的本质属性。其中最重要的是纯虚函数(pure virtual functions)和纯虚类(pure virtual class)。如果一个类的成员函数至少有一个是纯虚函数，那么这个类是纯虚类，也叫抽象类(ab
QtWeatherApp - 简单天气预报软件(C++ Qt6)(附源码)
sweetikelike的博客
12-18 572
摘要：QtWeatherApp 是一个基于 Qt 6 和 C++ 开发的桌面天气预报应用。该软件通过 OpenWeatherMap Geocoding API 获取城市经纬度，再调用 Open-Meteo 免费天气 API 查询当前天气和7天预报。核心功能包括：支持中英文城市查询、显示温度及天气描述、纯 C++ 实现 Qt 网络请求和 JSON 解析。项目采用模块化设计，包含网络请求、数据处理和 UI 交互组件，可作为学习 Qt 开发的参考案例。软件跨平台支持 Windows/macOS/Linux，源码已
传值还是传引用？c++，python对比
最新发布
ULTRAmanTAROACE的博客
12-18 354
操作PythonJavaC++传参（基本/不可变）引用（表现如值）值（primitive） / 引用副本（对象）值（拷贝）传参（容器/可变）引用（共享对象）引用副本（可修改内容）值（拷贝整个容器，除非用返回值返回对象引用primitive：值；对象：引用返回值（通常移动或 RVO 优化）赋值 a = ba 绑定到 b 所指对象primitive：值拷贝；对象：引用拷贝深拷贝（调用 operator=）push 到容器存储对象引用存储对象引用拷贝或移动元素（值语义）
如何快速在 VS2026 上使用 C++ 模块 — 完整上手指南
charlie114514191的博客
12-15 824
本文介绍了在VS2026中使用C++20模块特性的完整指南。文章首先阐述了模块的优势，如增量编译和更健壮的导出机制。接着提供了使用前提条件，包括VS2026的安装和C++标准设置。通过一个包含模块接口单元(math.ixx)和主程序(main.cpp)的最小示例，详细说明了模块的创建和使用方法。最后，文章指导读者在VS2026 IDE中配置项目、添加模块文件并设置语言标准，以顺利构建运行模块化程序。文末还提供了微软官方的相关参考资料。
【C++】--AVL树的认识和实现
2302_81083101的博客
12-14 878
前面我们学习了二叉搜索树，其在一般情况下，对数据的查找的效率为O(logN)，但是在极端的情况下，其时间复杂度会达到O(n)。如下：右边的单支或者接近单支的情况就会导致查找的效率变得很低。所以后来又发明了AVL树，AVL树是两个前苏联科学家在1962年发表的。其概念如下：AVL树最先发明自平衡二叉查找树，其是一棵空树，或者具有以下性质的二叉树，它的左右子树也都是AVL树，然后左右子树的高度差不能超过1。AVL树是一棵高度平衡二叉树，其通过控制高度差去控制平衡。
C++学习笔记与算法精要总结
本学习笔记标题为《C++学习笔记，经典总结》，其描述指出这是一份“给你学习C++提供无线的帮助”的资料，说明该笔记涵盖了C++语言的核心概念、常用技巧以及实践心得，适合初学者系统学习或中高级开发者复习巩固。...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值