C++多态（一）

最新推荐文章于 2025-02-12 17:49:57 发布
最新推荐文章于 2025-02-12 17:49:57 发布
阅读量378 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/aaronlanni/article/details/78236876
本文介绍了C++中的多态概念，包括静态多态和动态多态，重点讲述了动态多态中的虚函数、纯虚函数和抽象类。还讨论了虚函数表在单继承、多继承和菱形继承中的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。
C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。
一、基本概念
1.定义：不同对象收到相同的消息时，从而产生不同的动作，即一个名字定义的不同的函数
2.对象类型：（1）静态类型：对象声明时的类型，是在编译时确定的
（2）动态类型：目前所指对象的类型，是在运行确定的
3.静态多态（早绑定）
包含：函数重载、泛型函数（模板）
概念：编译器在编译期间完成的，编译器根据函数实参的类型（可能会进行隐式类型转换），可推出要调用哪个函数，如果有对应的函数就调用，没有的话就编译错误。
有关函数重载：即在同一作用域内，函数名相同，参数列表不同，但函数的返回类型不作为判断函数是否重载的准则，函数重载避免了函数名的污染

int Sub(int a, int b)
{
      return a - b;
}
int Sub(char a, int b)
{
      return a - b;
}
int main()
{
      Sub(1, 2);
      Sub('1', 1);//形成函数重载，避免名字污染
      return 0;
}

4.动态多态（晚绑定）
包含：虚函数
概念：在程序执行（非编译期间）判断所引用对象的实际类型，根据其实际类型调用相应的方法
动态绑定的条件：1.必须是虚函数（在派生类中必须对基类的虚函数进行重写）。2.通过基类类型的引用或者指针调用虚函数。

#include<iostream>
using namespace std;
class Base
{
public:
      Base(int x, int y)
      {
            a = x;
            b = y;
      }
      void show()
      {
            cout << "Base:";
            cout << a << "  " << b << endl;
      }
private:
      int a;
      int b;
};
class Derived :public Base
{
public:
      Derived(int x, int y, int z)
            :Base(x, y)
      {
            c = z;
      }
      void show()
      {
            cout << "Derived:";
            cout << "c=" << c << endl;
      }
private:
      int c;
};
int main()
{
      Base mb(60, 60);//定义基类对象
      Base *pc;//定义基类对象的指针
      Derived mc(10, 20, 30);//定义派生类对象
      pc = &mb;//利用基类对象的指针指向基类对象
      pc->show();//调用基类对象的show函数
      pc = &mc;//让基类对象的指针指向派生类的对象
      pc->show();//这个指针在此调用的是基类中的show函数
      system("pause");
      return 0;
}
注：原因是：基类的对象指针可以指向他公有派生类的对象，但是当其指向公有派生类对象时，他只能访问派生类中从基类继承来的成员，而不能访问公有派生类中定义的成员（详细参考继承中的对象模型）
如若想要定义一个对象，也可以访问派生类中的成员，则需要用到虚函数，或者进行强转

二、虚函数
1.定义：虚函数定义是在基类中进行的，他是在基类中需要定义为虚函数的成员函数的声明中冠以关键字virtual，从而形成一种接口。
2.关键字：virtual
3.形式：

virtual 返回类型 函数名（参数列表）
{
    函数体
}

注：基类中的某个成员函数被声明为虚函数之后，此虚函数就可以在一个或多个派生类中被重新定义。虚函数在重新定义时，其函数原型（返回类型或者满足赋值兼容规则的指针、引用的返回，函数名，参数个数，参数类型的顺序），都必须与基类中的原型相同。
必须在基类中定义虚函数

只在基类中声明
class Base
{
public:
      Base(int x, int y)
      {
            a = x;
            b = y;
      }
      virtual void show()
      {
            cout << "Base:";
            cout << a << "  " << b << endl;
      }
private:
      int a;
      int b;
};
原因：虚函数，是实现动态绑定的，在函数运行时确定所要调用的函数，而此时pc指向派生类的对象，因此调用派生类的函数

这里写图片描述

4.在基类中声明虚函数，在派生类中，可以不再需要写虚函数关键字
5.只有通过基类指针访问虚函数时才能获得运行时的多态性
6.虚函数必须是类的成员函数，不能是友元函数与静态成员函数（ 虚函数调用要靠特定的对象来决定激活哪个函数）
7.内联函数不能是虚函数（）
8.构造函数不能是虚函数，但是析构函数可以是虚函数，而且通常说明为虚函数
在基类中用virtual声明成员函数为虚函数，在类外定义虚函数时，不必在加虚函数关键字

int main()
{
      Base *p;//定义基类对象的指针
      p = new Derived;//用运算符new为派生类的无名对象动态地分配了一个存储空间，并将地址赋给对象指针p
      delete p;
      system("pause");
      return 0;
}
注意：运行此函数，在调用析构函数时，采用的是静态连接的方式，因此只调用了基类的析构函数。因为p是基类的对象，就是为了防止动态开辟时

这里写图片描述

析构函数定义为虚函数的形式：

virtual ~ 类名
{
    函数体
}

三、纯虚函数与抽象类
（一）纯虚函数
1.作用：考虑到派生类的需要，在基类中预留一个函数名，具体功能留给派生类去实现，以便派生类根据需要对它进行重新定义，在基类中不需要实现
2.形式：

virtual 函数类型 函数名（参数表）=0；

3.举个例子

class A
{
public:
      void set(int x)
      {
            r = x;
      }
      virtual void show() = 0;//纯虚函数的定义
protected:
      int r;
};
class B
{
public:
      void show()
      {
            cout << "A is" << r;
      }
};
class C :public A
{
public:
      void show()
      {
            cout << "C is " << 2 * r << endl;
      }
};

（二）抽象类
1.定义：一个类中至少有一个虚函数，那么就称为该类为抽象类
2.几点规定：（1）由于抽象类中至少包含一个没有定义功能的纯虚函数。因此=，抽象类只能作为其他类的基类来使用，不能建立抽象类对象
（2）不允许从具体类派生出抽象类
（3）抽象类不能做函数的参数类型、函数的返回类型或显示转换类型
（4）可以声明指向抽象类的指针或引用，此指针可以指向他的派生类，进而实现多态
（5）如果派生类中没有定义纯虚函数的实现，而派生类只是继承基类的纯虚函数，则这个派生类仍然是一个抽象类。如果派生类中给出了基类纯虚函数的实现，则派生类就不再是抽象类了，他是一个可以建立对象的具体类了。

以下函数可以通过编译吗？编译的结果是什么？

#include<iostream>
using namespace std;
class Base
{
public:
      //在基类中对其声明为虚函数，在派生类中对这个函数进行了重写
      virtual void FunTest1(int i)
      {
            cout << "Base::FunTest1()" << endl;
      }
      //没有对其进行重写，因为没有在基类中将其声明为虚函数，即使在派生类中已是虚函数，也不进行重写
      void FunTest2(int i)
      {
            cout << "Base::FunTest2()" << endl;
      }
      //在基类中对其声明为虚函数，在派生类中对这个函数进行了重写
      virtual void FunTest3(int i)
      {
            cout << "Base::FunTest3()" << endl;
      }
      //即使在基类中对其声明为虚函数，但是在虚类中，两个函数的原型不同（参数列表的个数不一样）因此没有对其形成重写
      virtual void FunTest4(int i)
      {
            cout << "Base::FunTest4()" << endl;
      }
};
class Derived :public Base
{
public:
      virtual void FunTest1(int i)
      {
            cout << "Derived::FunTest1()" << endl;
      }
      virtual void FunTest2(int i)
      {
            cout << "Derived::FunTest2()" << endl;
      }
      void FunTest3(int i)
      {
            cout << "Derived::FunTest3()" << endl;
      }
      virtual void FunTest4(int i,int j)
      {
            cout << "Derived::FunTest4()" << endl;
      }
};
int main()
{
      Base b;//定义基类的对象
      Base*pb;//定义基类对象的指针
      Derived d;//定义派生类对象
      pb = &d;//利用派生类为基类赋值（赋值兼容规则）
      pb->FunTest1(0);//调用派生类函数
      pb->FunTest2(0);//调用基类函数
      pb->FunTest3(0);//调用派生类函数
      pb->FunTest4(0);//调用基类函数
      //pb->FunTest4(0, 0);//编译出错
      system("pause");
      return 0;
}

这里写图片描述

3.有关函数重载，同名隐藏，函数重写（覆盖）的区别
函数重载：同一作用域，函数名字相同，参数列表不同，与返回值是否相同没有关系
同名隐藏：在继承体系中，如果基类和派生类有相同名称的成员。如果使用派生类对象调用基类和派生类中的同名函数或成员，优先调用派生类说的同名函数。
同名成员变量，和类型无关。同名函数，和原型是否相同没有关系
函数重写：继承体系中，函数原型相同（返回值，参数列表，函数名）协变除外以及析构函数除外，基类函数必须有virtual关键字，但是访问限定符可以不相同
协变：在基类与派生类中，函数的返回值不同（基类返回基类类型的引用或者指针，派生类返回派生类类型的引用或者指针）

4.总结：
1、派生类重写基类的虚函数实现多态，要求函数名、参数列表、返回值完全相同。(协变除外)——重写概念
2、基类中定义了虚函数，在派生类中该函数始终保持虚函数的特性。
3、只有类的非静态成员函数才能定义为虚函数，静态成员函数不能定义为虚函数。（需要利用this指针调用）
4、如果在类外定义虚函数，只能在声明函数时加virtual关键字，定义时不用加。
5、构造函数不能定义为虚函数，虽然可以将operator=定义为虚函数，但最好不要这么做，使用时容易混淆
6、不要在构造函数和析构函数中调用虚函数，在构造函数和析构函数中，对象是不完整的，可能会出现未定义的行为。
7、最好将基类的析构函数声明为虚函数。(析构函数比较特殊，因为派生类的析构函数跟基类的析构函数名称不一样，但是构成覆盖，这里编译器做了特殊处理)
8、虚表是所有类对象实例共用的

四、有关虚表
（一）单继承
（1）派生类中有对基类中的虚函数重写

#include<iostream>
using namespace std;
typedef void(*FuncPer)();
class Base
{
public:

      virtual void FunTest1()
      {
            cout << "Base::FunTest1()" << endl;
      }

      virtual void FunTest2()
      {
            cout << "Base::FunTest2()" << endl;
      }

      virtual void FunTest3()
      {
            cout << "Base::FunTest3()" << endl;
      }
      int _b;
};
class Derived :public Base
{
public:
      virtual void FunTest1()
      {
            cout << "Derived::FunTest1()" << endl;
      }
      virtual void FunTest2()
      {
            cout << "Derived::FunTest2()" << endl;
      }
      //新增的虚函数
      virtual void FunTest4()
      {
            cout << "Derived::FunTest4()" << endl;
      }
      int _d;
};
void PrintVF(Base& b)
{
      FuncPer*pFun = (FuncPer*)(*(int*)&b);//(*(int*)&b)相当于取出虚表的前四个字节中的内容，
                                                            //(FuncPer*)(*(int*)&b)取出这个虚表中保存的内容，即由虚表查询虚函数
      while (*pFun)
      {
            (*pFun)();
            pFun++;
      }
}
void Funtest(Base&b)
{
      PrintVF(b);
}
int main()
{
      Base b;//定义基类的对象 
      b._b = 0;
      cout << sizeof(b) << endl;
      Derived d;//定义派生类对象
      Funtest(b);
      Funtest(d);
      system("pause");
      return 0;
}

分析过程：
这里写图片描述

下面改变基类中虚函数的次序：
这里写图片描述

则发现虚函数的调用，与基类中的虚函数的次序有关
具体分析过程：
在基类中，定义虚函数，并在派生类中进行重写，可以发现在最后的结果中多了四个字节，通过分析可得，这个字节中保存的是一个地址，通过进一步的调用，发现这四个字节保存的是三个地址，从而的知，这三个地址保存的是基类虚函数中的地址，而在派生类中，对基类中的部分虚函数进行重写，从而用派生类中重写的虚函数，顶替相同偏移量中的基类虚函数，如若没有重写，则调用基类中的虚函数表，最后将派生类中新增的虚函数添加到虚表之后。
（2）派生类中没有对基类中的虚函数进行重写

#include<iostream>
using namespace std;
typedef void(*FuncPer)();
class Base
{
public:

      virtual void FunTest1()
      {
            cout << "Base::FunTest1()" << endl;
      }

      virtual void FunTest2()
      {
            cout << "Base::FunTest2()" << endl;
      }


      int _b;
};
class Derived :public Base
{
public:
      virtual void FunTest3()
      {
            cout << "Derived::FunTest3()" << endl;
      }
      virtual void FunTest5()
      {
            cout << "Derived::FunTest5()" << endl;
      }
      //新增的虚函数
      virtual void FunTest4()
      {
            cout << "Derived::FunTest4()" << endl;
      }
      int _d;
};
void PrintVF(Base& b)
{
      FuncPer*pFun = (FuncPer*)(*(int*)&b);//(*(int*)&b)相当于取出虚表的前四个字节中的内容，
                                                            //(FuncPer*)(*(int*)&b)取出这个虚表中保存的内容，即由虚表查询虚函数
      while (*pFun)
      {
            (*pFun)();
            pFun++;
      }
}
void Funtest(Base&b)
{
      PrintVF(b);
}
int main()
{
      Base b;//定义基类的对象 
      b._b = 0;
      cout << sizeof(b) << endl;
      Derived d;//定义派生类对象
      Funtest(b);
      cout << sizeof(d) << endl;
      Funtest(d);
      system("pause");
      return 0;
}

这里写图片描述
总结：（派生类中虚表的构造）
1.基类中的虚表拷贝一份
2.检测派生类中是否对基类中的虚函数进行重写——>用派生类中重写的虚函数来替换相同偏移量位置的基类函数
3.在虚表之后添加派生类自己的虚函数

（二）多继承
由于在派生类中是否对基类中的虚函数的重写，只是替换相同偏移量的函数，则在多继承中不对在不进行重写的虚函数进行讨论

#include<iostream>
using namespace std;
typedef void(*FuncPer)();
class A
{
public:

      virtual void FunTest1()
      {
            cout << "A::FunTest1()" << endl;
      }

      virtual void FunTest2()
      {
            cout << "A::FunTest2()" << endl;
      }
      virtual void FunTest3()
      {
            cout << "A::FunTest3()" << endl;
      }



      int _a;
};
class B
{
public:
      virtual void FunTest1()
      {
            cout << "B::FunTest1()" << endl;
      }
      //新增的虚函数
      virtual void FunTest4()
      {
            cout << "B::FunTest4()" << endl;
      }
      virtual void FunTest5()
      {
            cout << "B::FunTest5()" << endl;
      }
      int _b;
};
class D :public A, public B
{
public:
      virtual void FunTest1()
      {
            cout << "D::FunTest1()" << endl;
      }
      virtual void FunTest2()
      {
            cout << "D::FunTest2()" << endl;
      }
      virtual void FunTest4()
      {
            cout << "D::FunTest4()" << endl;
      }
      virtual void FunTest6()
      {
            cout << "D::FunTest6()" << endl;
      }
      int _d;
};
void PrintVF(A& a)
{
      FuncPer*pFun = (FuncPer*)(*(int*)&a);//(*(int*)&b)相当于取出虚表的前四个字节中的内容，
                                                            //(FuncPer*)(*(int*)&b)取出这个虚表中保存的内容，即由虚表查询虚函数
      while (*pFun)
      {
            (*pFun)();
            pFun++;
      }
}
void PrintVF(B& b)
{
      FuncPer*pFun = (FuncPer*)(*(int*)&b);//(*(int*)&b)相当于取出虚表的前四个字节中的内容，
      //(FuncPer*)(*(int*)&b)取出这个虚表中保存的内容，即由虚表查询虚函数
      while (*pFun)
      {
            (*pFun)();
            pFun++;
      }
}
int main()
{
      //cout << sizeof(D) << endl;
      A a;//定义基类的对象

      B b;
      D d;//定义派生类对象
      d._a = 0;
      d._b = 1;
      d._d = 2;
      A&pa = d;
      B&pb = d;


      PrintVF(pa);
      PrintVF(pb);
      system("pause");
      return 0;
}

这里写图片描述

具体调用过程：先继承的基类的虚表在前，将派生类自己新增的虚表放在第一张的虚表之后（共有两张虚表，则两个基类各自一张）

（三）菱形继承
有关带虚函数的虚拟继承

//菱形继承+虚继承+虚函数
#include<iostream>
using namespace std;
typedef void(*FuncPer)();
class A
{
public:
      virtual void FunTest1()
      {
            cout << "A::FunTest1()" << endl;
      }
      virtual void FunTest2()
      {
            cout << "A::FunTest2()" << endl;
      }
      int _a;
};
class C1 :virtual public A
{
public:
      virtual void FunTest1()
      {
            cout << "C1::FunTest1()" << endl;
      }
      virtual void FunTest3()
      {
            cout << "C1::FunTest3()" << endl;
      }
      int _c1;
};
class C2 :virtual public A
{
public:
      virtual void FunTest1()
      {
            cout << "C2::FunTest1()" << endl;
      }
      virtual void FunTest4()
      {
            cout << "C2::FunTest4()" << endl;
      }
      int _c2;
};
class D :public C1, public C2
{
public:
      virtual void FunTest1()
      {
            cout << "D::FunTest1()" << endl;
      }
      virtual void FunTest3()
      {
            cout << "D::FunTest3()" << endl;
      }
      virtual void FunTest4()
      {
            cout << "D::FunTest4()" << endl;
      }
      virtual void FunTest5()
      {
            cout << "D::FunTest5()" << endl;
      }
      int _d;
};
void PrintVF(A& a)
{
      FuncPer*pFun = (FuncPer*)(*(int*)&a);//(*(int*)&b)相当于取出虚表的前四个字节中的内容，
      //(FuncPer*)(*(int*)&b)取出这个虚表中保存的内容，即由虚表查询
      while (*pFun)
      {
            (*pFun)();
            pFun++;
      }
}
void PrintVF(C1& c1)
{
      FuncPer*pFun = (FuncPer*)(*(int*)&c1);//(*(int*)&b)相当于取出虚表的前四个字节中的内容，
      //(FuncPer*)(*(int*)&b)取出这个虚表中保存的内容，即由虚表查询
      while (*pFun)
      {
            (*pFun)();
            pFun++;
      }
}
void PrintVF(C2& c2)
{
      FuncPer*pFun = (FuncPer*)(*(int*)&c2);//(*(int*)&b)相当于取出虚表的前四个字节中的内容，
      //(FuncPer*)(*(int*)&b)取出这个虚表中保存的内容，即由虚表查询虚函数
      while (*pFun)
      {
            (*pFun)();
            pFun++;
      }
}
int main()
{
      cout << sizeof(A) << endl;
      cout << sizeof(C1) << endl;
      cout << sizeof(C2) << endl;
      cout << sizeof(D) << endl;
      A a;//定义基类的对象
      C1 c1;
      C2 c2;
      D d;
      d._a = 0;
      d._c1 = 1;
      d._c2 = 2;
      d._d = 3;
      A&pa = d;
      C1&pc1 = d;
      C2&pc2 = d;
      PrintVF(pa);
      PrintVF(pc1);
      PrintVF(pc2);
      system("pause");
      return 0;
}

这里写图片描述

总结：在菱形继承+虚函数继承中，在派生类中，最底层只有一个对最底层基类中虚函数的重写（A），在C1与C2中，里面分别有自己的偏移量表格与虚函数，在派生中，如果有对其里面的重写了，则在打印虚函数表示，将其替换即可。

C++多态
kjl167的博客
08-13 1218
时，我们本意根据指针(引用)指向的对象类型来选择对应的析构函数，但结果是根据指针(引用)的类型的来选择对应的析构函数，导致对象没有正确的析构，存在资源泄漏。基类析构函数与派生类析构函数名明显不相同，编译器为了支持析构函数能为虚函数，对析构函数名做了特殊处理，编译后析构函数的名统一处理成destructor。使用基类的指针或引用调用同一方法时，产生不同的行为，这是一种动态多态，大多数C++编译器通过虚函数实现。前文中提到析构函数是可以为虚函数的，尤其是存在继承关系的时候，建议将基类析构函数定义为虚函数。
C++ 多态（1）
weixin_52374493的博客
08-24 142
多态 什么是多态？ 多态性（ polymorphism ）是面向对象设计语言的基本特征之一。 多态性可以简单地概括为“一个接口，多种方法”。 通俗的说是指对于同一个消息、同一种调用，在不同的场合，不同的情况下，执行不同的行为 。 多态的两种形式 C++支持两种多态性：编译时多态和运行时多态。 编译时多态：也称为静态多态，像函数重载、运算符重载就是采用的静态多态，C++编译器根据传递给函数的参数和函数名决定具体要使用哪一个函数，又称为先期联编（early binding）。 运行时多态：在一些场合下，编译器无
C++多态1 动多态 虚函数 虚析构函数
lisaaaaaas0405的博客
05-14 289
一、多态 1、定义：相同的对象收到不同的消息或者不同的对象收到相同的消息时，产生的不同的动作。 2、静多态（早绑定）：在编译之前就知道要用哪个函数 3、动多态（晚绑定）：是利用虚函数实现了运行时的多态，也就是说在系统编译的时候并不知道程序将要调用哪一个函数，只有在运行到这里的时候才能确定接下来会跳转到哪一个函数的栈帧。 动多态的前提：以封装和继承为基础，至少两个类（父、子） 面向对象三大...
c++备考期末必看知识点（一篇就够了）
qq_39838607的博客
04-20 2607
一.关于C++的常用注释的三种方法 简要： 第一种方法：（两个斜杆）/ / 第二种方法：（）/ * * / 第三种方法：使用预处理形式 #if 0 #endif 详细可以参考该篇 添加链接描述 二.c++中的作用域 四类（函数原型作用域，局部作用域，类作用域，命名空间作用域） 简要： 1.函数原型作用域： 此作用域为c++程序中最小的作用域，生存周期最短。 （即函数形参，在函数的原型声明时的括号里面的形参的作用域就是函数原型作用域。）切记是在函数声明中不是定义 例：int func（int i）
C++多态详解
zjxuec的博客
09-17 1444
1.必须基类指针或者引⽤调⽤虚函数 2.被调⽤的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。这两个条件缺一不可，缺少了任何一个都不能实现多态，如果不是基类的指针或引用调用虚函数，那便指向不了派生类，而派生类没有重写基类的虚函数，派生类就没有不同的函数，多态的不同形态效果就达不到，也就无法实现多态。如上图所示，Student类的虚函数重写了基类Person的虚函数，且调用虚函数的都是基类的引用或指针，那么这就构成了多态，指向哪个对象，就调用哪个对象的虚函数。结果:我们在上面提到了虚函数，接下来我们来
【C++】一文看懂 C++ 多态：动态与静态多态的全面剖析
2403_86785171的博客
08-27 1773
多态来源于希腊语，意为“多种形态”。在编程中，多态性指的是在相同的接口下，不同的数据类型可以表现出不同的行为。编译时多态和运行时多态。编译时多态通过函数重载和运算符重载实现，允许在编译阶段确定具体的函数调用。运行时多态通过虚函数和继承实现，允许在运行时根据对象的实际类型确定具体的函数调用。多态性极大地提高了代码的灵活性和可维护性，是面向对象编程中不可或缺的组成部分。
C++多态：静态多态vs动态多态
最新发布
ye_yumo的博客
02-12 933
多态（Polymorphism）作为面向对象编程的三大核心特性之一，是构建灵活、可扩展软件系统的关键所在。在C++中，多态的实现主要分为静态多态（Static Polymorphism）和动态多态（Dynamic Polymorphism）两种形式，它们以不同的方式实现了"一个接口，多种实现"的核心思想。在这一篇博客里我有详细介绍（
C++多态Demo
05-01
总结起来，这个"C++多态Demo"展示了如何利用C++的面向对象特性，特别是继承和多态，来构建一个灵活的几何形状类层次结构。通过这个例子，我们可以学习到如何定义和使用抽象类，如何覆盖父类方法，以及如何在实践中...
C++：抽象类、虚表、绑定
qq_45481606的博客
08-23 1231
抽象类 纯虚函数： 在虚函数的后面写上 =0 virtual void test()=0 抽象类（也叫接口类）： 包含纯虚函数的类 抽象类特点 抽象类不能创建对象，不被继承就没有意义； 抽象类可以创建指针，让这个父类的指针指向子类对象 因为抽象类是类型，指针用于存储地址 抽象类被子类继承后，该子类也不能实例化出对象，只有重写全部的纯虚函数，子类才能创建对象； 纯虚函数规范了派生类必须重写，更体现出了接口继承 普通函数的继承是一种实现继承，子类继承了父类的具体函数，可以使用函数，继承的
C++抽象编程——指针（1）——什么是指针？
redAnt的博客
05-20 1182
指针（Pointers）C ++设计背后的原则之一是程序员应该尽可能多地访问由底层硬件提供的工具。因此，C ++使得内存位置具有程序员可见的地址。其值为内存中的地址的数据项称为指针（A data item whose value is an address in memory is called a pointer） 在许多高级编程语言中，指针被通常谨慎使用，因为这些语言提供了消除对指针的大量需求的
C++的抽象类详解
周杰伦
05-21 8743
在介绍抽象类之前，我们先介绍一下纯虚函数。 1.纯虚函数 在基类中仅仅给出声明，不对虚函数实现定义，而是在派生类中实现。这个虚函数称为纯虚函数。普通函数如果仅仅给出它的声明而没有实现它的函数体，这是编译不过的。纯虚函数没有函数体。 纯虚函数需要在声明之后加个=0； class <基类名> { virtual <类型><函数名>(<参数表>)=0; ...... }; 2.抽象类 含有纯虚函数的类被称为抽象类。抽象类只能作为派生类的基类，.
c++ 抽象类
tianyexing2008的博客
08-21 811
只要包含了纯虚函数的类都是抽象类，因为是抽象的类所以是不能直接定义对象，但可以定义此类的指针或引用。假如直接定义此类的对象，会出现如下的编译错误： 同时，如果有类继承于抽象类，只要有纯虚函数未实现，也是不能定义抽象类的指针或引用的，会得到一个“undefined reference to xxx”的错误，所以，我们可以得出，抽象类的特性：其纯虚函数，必须被任何“继承了它们”的派生类重新声明且定义，声明和定义时，函数形式与基类中要完全一样。 抽象类一般的使用形式 1，作为参数使用 这种使用方式，.
C++中定义抽象类指针的作用
xcksj666的博客
12-19 417
我们还定义了一个指向 Animal 类的指针 animalPtr，它可以指向任何派生类对象。在 main() 函数中，我们将 animalPtr 指向 Cat 对象和 Dog 对象，并调用它们的 makeSound() 函数。在 C++ 中，抽象类可以定义类指针。类指针是指向类对象的指针，它可以指向任何派生类对象，包括抽象类的派生类对象。因此，抽象类可以定义类指针，并且这些指针可以指向任何派生类对象，无论这些派生类是否是抽象类。// 输出 "Meow!// 输出 "Woof!
c++抽象类和抽象类指针笔记
Alask_的博客
06-20 3196
抽象类： 不能用来定义对象而只作为一种基本类型用作继承的类，称为抽象类，由于它常用作基类，通常称为抽象基类。凡是包含纯虚函数的类都是抽象基类。因为纯虚函数是不能够被调用的，包含纯虚函数的类是无法建立对象的。 虽然抽象类不能定义对象，但是可以定义指向抽象类数据的指针变量。 ...
C++如何使指针指向泛型的对象
李兆龙的博客
01-29 1048
引言 这是一次在代码中遇到的一个小问题,在网上没有找到解答,遂在解决后分享出来,帮助有同样问题的朋友 直入主题 我们来看一段简单的代码来引入我们的问题 template<typename Type> struct wrapper_type{ Type fun; ... }; 首先这是一个简单泛型对象的声明,假如现在有一个需求,就...
C++ 抽象类
热门推荐
03-05 3万+
抽象类是为了抽象和设计的目的而建立的，处于继承层次结构的上层。 具体类是能够建立对象的类。 抽象类的规定 （1）抽象类只能用作其他类的基类，不能建立抽象类对象。 （2）抽象类不能用作参数类型、函数返回类型或显式转换的类型。 （3）可以定义指向抽象类的指针和引用，此指针可以指向它的派生类，进而实现多态性。 #include using namespace std; const doub
再聊C++抽象类
KingOfMyHeart的博客
05-08 883
什么是抽象类 含有纯虚函数的类就叫做抽象类。抽象类不能定义对象，但是可以定义指针和引用。 class Occupation { public: Occupation(){ std::cout << "Occupation()" << std::endl; }; //纯虚函数 基类给派生类预留的统一的接口，派生类必须实现 virtual void work() = 0; }; 再派生类中，纯虚函数必须实现，否则派生类还是一个抽象类： class Student : pub
c++之多态
1024350154--lj博客
08-08 263
（一）多态的定义： 接口多种不同的实现方式，称为多态 基类指针指向基类对象时，就是使用基类的成员变量和函数 基类指针指向派生类对象时，就是使用派生类的成员变量 这样，基类指针可以按照多种形式来表现，这就叫做多态 （二）指针与引用 1）在多态的情况下，引用不如指针方便 2）引用只能指定固定的对象，不能修改，而指针可以指向任意的方向 （三）多态形成的三个必要条件
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值