C++ 多态

最新推荐文章于 2021-04-01 08:33:46 发布
最新推荐文章于 2021-04-01 08:33:46 发布
阅读量392 收藏 2
点赞数 2
分类专栏： C++ tmp 文章标签： C++ 多态
世上没有白读的书，每一页都算数。
本文链接：https://blog.csdn.net/chengyq116/article/details/105349510
版权

C++ 多态

当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。

基类 Shape 被派生为两个类。

//============================================================================
// Name        : polymorphism
// Author      : Yongqiang Cheng
// Version     : Version 1.0.0
// Copyright   : Copyright (c) 2019 Yongqiang Cheng
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
using namespace std;

class Shape
{
protected:
    int width, height;
public:
    Shape(int a = 0, int b = 0)
    {
        width = a;
        height = b;
    }

    int area()
    {
        cout << "Parent class area :" << endl;
        return 0;
    }
};

class Rectangle: public Shape
{
public:
    Rectangle(int a = 0, int b = 0) :Shape(a, b)
    {
    }

    int area()
    {
        cout << "Rectangle class area :" << endl;
        return (width * height);
    }
};

class Triangle: public Shape
{
public:
    Triangle(int a = 0, int b = 0) :Shape(a, b)
    {
    }

    int area()
    {
        cout << "Triangle class area :" << endl;
        return (width * height / 2);
    }
};

int main()
{
    Shape *shape;
    Rectangle rec(10, 7);
    Triangle tri(10, 5);

    shape = &rec;
    shape->area();

    shape = &tri;
    shape->area();

    return 0;
}


Parent class area :
Parent class area :

调用函数 area() 被编译器设置为基类中的版本，这是静态多态或静态链接，函数调用在程序执行前就准备好了，这也被称为早绑定，因为 area() 函数在程序编译期间就已经设置好了。

在 Shape 类中，area() 的声明前放置关键字 virtual。

//============================================================================
// Name        : polymorphism
// Author      : Yongqiang Cheng
// Version     : Version 1.0.0
// Copyright   : Copyright (c) 2019 Yongqiang Cheng
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
using namespace std;

class Shape
{
protected:
    int width, height;
public:
    Shape(int a = 0, int b = 0)
    {
        width = a;
        height = b;
    }

    virtual int area()
    {
        cout << "Parent class area :" << endl;
        return 0;
    }
};

class Rectangle: public Shape
{
public:
    Rectangle(int a = 0, int b = 0) :Shape(a, b)
    {
    }

    int area()
    {
        cout << "Rectangle class area :" << endl;
        return (width * height);
    }
};

class Triangle: public Shape
{
public:
    Triangle(int a = 0, int b = 0) :Shape(a, b)
    {
    }

    int area()
    {
        cout << "Triangle class area :" << endl;
        return (width * height / 2);
    }
};

int main()
{
    Shape *shape;
    Rectangle rec(10, 7);
    Triangle tri(10, 5);

    shape = &rec;
    shape->area();

    shape = &tri;
    shape->area();

    return 0;
}


Rectangle class area :
Triangle class area :

此时编译器看的是指针的内容，而不是它的类型。由于 tri 和 rec 类的对象的地址存储在 shape 中，所以会调用各自的 area() 函数。

每个子类都有一个函数 area() 的独立实现，这是多态的一般使用方式。有了多态，您可以有多个不同的类，都带有同一个名称但具有不同实现的函数，函数的参数甚至可以是相同的。

1. 虚函数

虚函数是在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到基类中定义的虚函数。

我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数，这种操作被称为动态链接或后期绑定。

2. 纯虚函数

想要在基类中定义虚函数，以便在派生类中重新定义该函数更好地适用于对象，但是您在基类中又不能对虚函数给出有意义的实现，这个时候就会用到纯虚函数。

基类中的虚函数 area() 改写为纯虚函数。

//============================================================================
// Name        : polymorphism
// Author      : Yongqiang Cheng
// Version     : Version 1.0.0
// Copyright   : Copyright (c) 2019 Yongqiang Cheng
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
using namespace std;

class Shape
{
protected:
    int width, height;
public:
    Shape(int a = 0, int b = 0)
    {
        width = a;
        height = b;
    }

    // pure virtual function
    virtual int area() = 0;
};

class Rectangle: public Shape
{
public:
    Rectangle(int a = 0, int b = 0) :Shape(a, b)
    {
    }

    int area()
    {
        cout << "Rectangle class area :" << endl;
        return (width * height);
    }
};

class Triangle: public Shape
{
public:
    Triangle(int a = 0, int b = 0) :Shape(a, b)
    {
    }

    int area()
    {
        cout << "Triangle class area :" << endl;
        return (width * height / 2);
    }
};

int main()
{
    Shape *shape;
    Rectangle rec(10, 7);
    Triangle tri(10, 5);

    shape = &rec;
    shape->area();

    shape = &tri;
    shape->area();

    return 0;
}


Rectangle class area :
Triangle class area :

= 0 告诉编译器，函数没有主体，上面的虚函数是纯虚函数。

C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数：

  1. 必须存在继承关系。
  2. 继承关系必须有同名虚函数 (其中虚函数是在基类中使用关键字 virtual 声明的函数，在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到基类中定义的虚函数)。
  3. 存在基类类型的指针或者引用，通过该指针或引用调用虚函数。

虚函数可以不实现 (定义)，不实现 (定义) 的虚函数是纯虚函数。在一个类中如果存在未定义的虚函数，那么不能直接使用该类的实例，可以理解因为未定义 virtual 函数，其类是抽象的，无法实例化。我们必须实现抽象类，否则无法实例化。

//============================================================================
// Name        : polymorphism
// Author      : Yongqiang Cheng
// Version     : Version 1.0.0
// Copyright   : Copyright (c) 2019 Yongqiang Cheng
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
using namespace std;

class Base
{
public:
    virtual void tall();
};

class People: Base
{
public:
    void tall()
    {
        cout << "people" << endl;
    }
};

int main()
{
    People people;

    people.tall();
    (&people)->tall();

    return 0;
}


20:51:56 **** Build of configuration Debug for project yongqiang ****
make all 
Building file: ../yongqiang.cpp
Invoking: GCC C++ Compiler
g++ -O0 -g3 -Wall -c -fmessage-length=0 -MMD -MP -MF"yongqiang.d" -MT"yongqiang.o" -o "yongqiang.o" "../yongqiang.cpp"
Finished building: ../yongqiang.cpp
 
Building target: yongqiang
Invoking: GCC C++ Linker
g++  -o "yongqiang"  ./yongqiang.o   
./yongqiang.o: In function `Base::Base()':
/home/strong/eclipse-workspace/yongqiang/Debug/../yongqiang.cpp:12: undefined reference to `vtable for Base'
makefile:44: recipe for target 'yongqiang' failed
./yongqiang.o:(.rodata._ZTI6People[_ZTI6People]+0x18): undefined reference to `typeinfo for Base'
collect2: error: ld returned 1 exit status
make: *** [yongqiang] Error 1

20:51:56 Build Finished (took 683ms)

//============================================================================
// Name        : polymorphism
// Author      : Yongqiang Cheng
// Version     : Version 1.0.0
// Copyright   : Copyright (c) 2019 Yongqiang Cheng
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
using namespace std;

class Base
{
public:
    virtual void tall()
    {
    }
};

class People: Base
{
public:
    void tall()
    {
        cout << "people" << endl;
    }
};

int main()
{
    People people;

    people.tall();
    (&people)->tall();

    return 0;
}

在 main 方法中，我们不能使用 Base base; 这行代码，此时的 tall 没有实现，函数表 (vtable) 的引用是未定义的，故而无法执行。但我们可以使用 People people; 然后 people.tall(); 或 (&people)->tall(); 因为 People 实现或者说重写、覆盖了 Base 的纯虚方法 tall()，使其在 People 类中有了定义，函数表挂上去了，于是可以诞生实例了。

people
people

针对普通的函数，即使我们只声明，不定义，也不会产生上述不可用的问题。

  1. 纯虚函数声明如下：virtual void funtion1() = 0;。纯虚函数一定没有定义，纯虚函数用来规范派生类的行为，即接口。包含纯虚函数的类是抽象类，抽象类不能定义实例，但可以声明指向实现该抽象类的具体类的指针或引用。
  2. 虚函数声明如下：virtual ReturnType FunctionName(Parameter) {}; 虚函数必须实现，如果不实现，编译器将报错。
  3. 对于虚函数来说，父类和子类都有各自的版本。由多态方式调用的时候动态绑定。
  4. 实现了纯虚函数的子类，该纯虚函数在子类中就编程了虚函数，子类的子类即孙子类可以覆盖该虚函数，由多态方式调用的时候动态绑定。
  5. 虚函数是 C++ 中用于实现多态 (polymorphism) 的机制。核心理念就是通过基类访问派生类定义的函数。
  6. 友元不是成员函数，只有成员函数才可以是虚拟的，因此友元不能是虚拟函数。但可以通过让友元函数调用虚拟成员函数来解决友元的虚拟问题。

动态联编的实现机制 VTABLE

编译器对每个包含虚函数的类创建一个虚函数表 VTABLE，表中每一项指向一个虚函数的地址，即 VTABLE 表可以看成一个函数指针的数组，每个虚函数的入口地址就是这个数组的一个元素。

每个含有虚函数的类都有各自的一张虚函数表 VTABLE。每个派生类的 VTABLE 继承了它各个基类的 VTABLE。如果基类 VTABLE 中包含某一项 (虚函数的入口地址)，则其派生类的 VTABLE 中也将包含同样的一项，但是两项的值可能不同。如果派生类中重载了该项对应的虚函数，则派生类 VTABLE 的该项指向重载后的虚函数。如果派生类中没有对该项对应的虚函数进行重新定义，则使用基类的这个虚函数地址。

在创建含有虚函数的类的对象的时候，编译器会在每个对象的内存布局中增加一个 vptr 指针项，该指针指向本类的 VTABLE。在通过指向基类对象的指针调用一个虚函数时，编译器生成的代码是先获取所指对象的指针，然后调用指针所指向类的 VTABLE 中的对应项 (具体虚函数的入口地址)。

当基类中没有定义虚函数时，其长度 = 数据成员长度。派生类长度 = 自身数据成员长度 + 基类继承的数据成员长度。

当基类中定义虚函数后，其长度 = 数据成员长度 + 虚函数表的地址长度。派生类长度 = 自身数据成员长度 + 基类继承的数据成员长度 + 虚函数表的地址长度。

包含一个虚函数和几个虚函数的类的长度增量为 0。含有虚函数的类只是增加了一个指针用于存储虚函数表的首地址。

派生类与基类同名的虚函数在 VTABLE 中有相同的索引号 (或序号)。

父类的虚函数或纯虚函数在子类中依然是虚函数。有时我们并不希望父类的某个函数在子类中被重写，在 C++11 及以后可以用关键字 final 来避免该函数再次被重写。

//============================================================================
// Name        : polymorphism
// Author      : Yongqiang Cheng
// Version     : Version 1.0.0
// Copyright   : Copyright (c) 2019 Yongqiang Cheng
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
using namespace std;

class Base
{
public:
    virtual void func()
    {
        cout << "This is Base" << endl;
    }
};

class _Base: public Base
{
public:
    void func() final
    {
        cout << "This is _Base" << endl;
    }
};

class __Base: public _Base
{
    //public:
    //    void func()
    //    {
    //        cout << "This is __Base" << endl;
    //    }
};

int main()
{
    Base *ptr;
    _Base a;
    __Base b;

    ptr = &a;
    ptr->func();

    ptr = &b;
    ptr->func();

    _Base *ptr2;

    ptr2 = &b;
    ptr2->func();

    return 0;
}


21:10:29 **** Build of configuration Debug for project yongqiang ****
make all 
Building file: ../yongqiang.cpp
Invoking: GCC C++ Compiler
g++ -O0 -g3 -Wall -c -fmessage-length=0 -MMD -MP -MF"yongqiang.d" -MT"yongqiang.o" -o "yongqiang.o" "../yongqiang.cpp"
../yongqiang.cpp:24:15: warning: override controls (override/final) only available with -std=c++11 or -std=gnu++11
     void func() final
               ^
Finished building: ../yongqiang.cpp
 
Building target: yongqiang
Invoking: GCC C++ Linker
g++  -o "yongqiang"  ./yongqiang.o   
Finished building target: yongqiang
 

21:10:29 Build Finished (took 677ms)

在这里插入图片描述

//============================================================================
// Name        : polymorphism
// Author      : Yongqiang Cheng
// Version     : Version 1.0.0
// Copyright   : Copyright (c) 2019 Yongqiang Cheng
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
using namespace std;

class Base
{
public:
    virtual void func()
    {
        cout << "This is Base" << endl;
    }
};

class _Base: public Base
{
public:
    void func() final
    {
        cout << "This is _Base" << endl;
    }
};

class __Base: public _Base
{
public:
    void func()
    {
        cout << "This is __Base" << endl;
    }
};

int main()
{
    Base *ptr;
    _Base a;
    __Base b;

    ptr = &a;
    ptr->func();

    ptr = &b;
    ptr->func();

    _Base *ptr2;

    ptr2 = &b;
    ptr2->func();

    return 0;
}


21:15:47 **** Incremental Build of configuration Debug for project yongqiang ****
make all 
Building file: ../yongqiang.cpp
Invoking: GCC C++ Compiler
g++ -std=c++0x -O0 -g3 -Wall -c -fmessage-length=0 -MMD -MP -MF"yongqiang.d" -MT"yongqiang.o" -o "yongqiang.o" "../yongqiang.cpp"
../yongqiang.cpp:33:10: error: virtual function ‘virtual void __Base::func()’
     void func()
          ^
../yongqiang.cpp:24:10: error: overriding final function ‘virtual void _Base::func()’
     void func() final
          ^
make: *** [yongqiang.o] Error 1
subdir.mk:18: recipe for target 'yongqiang.o' failed

21:15:47 Build Finished (took 677ms)

//============================================================================
// Name        : polymorphism
// Author      : Yongqiang Cheng
// Version     : Version 1.0.0
// Copyright   : Copyright (c) 2019 Yongqiang Cheng
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
using namespace std;

class Base
{
public:
    virtual void func()
    {
        cout << "This is Base" << endl;
    }
};

class _Base: public Base
{
public:
    void func() final
    {
        cout << "This is _Base" << endl;
    }
};

class __Base: public _Base
{
//public:
//    void func()
//    {
//        cout << "This is __Base" << endl;
//    }
};

int main()
{
    Base *ptr;
    _Base a;
    __Base b;

    ptr = &a;
    ptr->func();

    ptr = &b;
    ptr->func();

    _Base *ptr2;

    ptr2 = &b;
    ptr2->func();

    return 0;
}


This is _Base
This is _Base
This is _Base

如果不希望一个类被继承，可以使用 final 关键字。

class Class_Name final
{
    ...
};

则该类将不能被继承。

多态用到纯虚函数或虚函数，C++ 的这种特殊处理函数利用父对象指针来访问子对象，然后根据子对象的函数来调用。

Yongqiang Cheng
关注
专栏目录
C++基础总结（五）：C++进阶——多态和数据抽象
Hsuesh的博客
11-18 365
今天小编分享C++多态和数据抽象，建议大家收藏慢慢学习，同时希望对大家的C++学习有所帮助。 C++ 多态 多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。 C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。 下面的实例中，基类 Shape 被派生为两个类，如下所示： 实例 #include<iostream>using namespace std;classShape{ protected...
C++多态
沉剑池
03-31 321
c++多态多态存在的前提是有类的继承。当存在多个子类继承自父类时，这几个类都会有继承得来（同名的）的函数，调用函数时，根据具体调用的对象的不同来决定执行这几个同名函数中的哪一个的功能称为多态。看一个未使用多态的反例：#include &lt;iostream&gt; using namespace std; class Shape { protected: int widt...
写一个方法void isTriangle(int a,int b,int c)，判断三个参数是否能构成一个三角形。
热门推荐
健健
06-20 1万+
如果不能则抛出异常IllegalArgumentException，显示异常信息 “a,b,c不能构成三角形”，如果可以构成则显示三角形三个边长。在主方法中得到命令行输入的三个整数， 调用此方法，并捕获异常import java.util.Scanner; public class Test06 { public static void main(String[] args) { // ...
写一个方法void sanjiao(int a,int b,int c)，...........................
杨鑫newlife的专栏
10-27 3814
题目: 写一个方法void sanjiao(int a,int b,int c)，判断三个参数是否能构成一个三角形，如果不能则抛出异常IllegalArgumentException， 显示异常信息“a,b,c不能构成三角形”，如果可以构成则显示三角形三个边长， 在主方法中得到命令行输入的三个整数，调用此方法，并捕获异常。 代码： package helloWorld;
C++ 三大特征：封装、继承、多态
一千零一夜的博客
04-11 1069
C++ 完全支持面向对象的程序设计，包括面向对象开发的三大特征： 封装 继承 多态 一、封装 封装：把数据和操作数据的函数绑定在一起，通过设置私有成员，限制对数据的访问。类包含私有成员（private）、保护成员（protected）和公有成员（public）成员。默认情况下，在类中定义的所有成员都是私有的，这样才能保证良好的封装性。 class Box { public: ...
C++多态Demo
05-01
这个“C++多态Demo”示例中，我们看到长方形和三角形作为形状（Shape）类的派生类，体现了面向对象编程中的继承和多态概念。 首先，让我们来理解一下基础的面向对象概念： 1. **类（Class）**: 类是创建对象的蓝图...
C++多态的实现机制深入理解
12-26
在面试过程中C++的多态实现机制经常会被面试官问道。大家清楚多态到底该如何实现吗？下面小编抽空给大家介绍下多态的实现机制。 1. 用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。 2. 存在虚...
C++ 多态的游戏例程
01-20
1）头文件 game.h #ifndef GAME_H #define GAME_H // base class class CCreature { protected: int m_nLifePower， m_nPower; public: virtual void Attack(CCreature *pCreature){} virtual void Hurted...
C++ 继承异常类 runtime_error 时出现错误 [Error] overriding 'virtual std::runtime_error::~runtime_error() throw...
dgn19620的博客
04-28 937
创建一个类 DivisionException ，继承自 runtime_error 。 类的定义如下：class DivisionException : public std::runtime_error { private: MyComplex Divident_; MyComplex Divisor_; public: DivisionException(std:...
c++面向对象笔记
小白进阶的博客
11-15 302
1.继承类型继承形式如下：class derived-class: access-specifier base-class当一个类派生自基类，该基类可以被继承为 public、protected 或 private 几种类型。继承类型是通过上面讲解的访问修饰符 access-specifier 来指定的。我们几乎不使用 protected 或 private 继承，通常使用 public 继承。当使
C++ 学习笔记（基础数据类型和语法实例）
sanaerqi的博客
04-25 257
#include "iostream" #include "string" #include "limits" #include <cstring> using namespace std; static int count = 10;//全局变量，本文件中有效,作用是隐藏 int main() { //count += 1; /* 枚举 ...
039-C++多态
好好学习，天天向上
04-01 82
#include <iostream> using namespace std; /** * C++中的动态是通过virtual关键字来实现的 如果不使用virtual 即使派生类重写父类方法，最后在运行时还是会执行 * 父类的方法，这种情况属于静态绑定。如果使用了virtual 则在运行时会调用派生类重写的父类方法，这种情况叫做动态 * 绑定。 * 使用virtual 关键字，但是有实现的方法称为虚函数 * 使用virtual 关键字，但是没有实现 并且格式是 virtual .
【C++ 编程语言学习2】C++封装、继承、多态
wb790238030的博客
01-07 215
〇、面向对象的三个基本特征：封装、继承、多态 面向对象的三个基本特征是：封装、继承、多态。其中，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已知存在的代码模块（类）；它们的目的是为了代码重用。而多态是为了实现另外一个目的，接口重用。 一、封装：代码模块化 1、基本概念 1）封装是把数据和操作数据的函数绑定在一起的概念，封装的本质是模块化。 2）C++通过创建类来支持封装和数据隐...
C++中的虚函数(virtual function)
DX
06-02 2642
C++中的虚函数(virtual function) 1.简介 虚函数是C++中用于实现多态(polymorphism)的机制。核心理念就是通过基类访问派生类定义的函数。假设我们有下面的类层次：class A{public:virtual void foo() { cout "A::foo() is called" endl;}};class B: public A{public:virtual
写一个方法void triangle(int a,int b,int c)，判断三个参数是否能构成一个三角形。如果不能则抛出异常IllegalArgumentException，显示异常信息：a,b,
Messi_tz的博客
11-05 5196
写一个方法void triangle(int a,int b,int c)，判断三个参数是否能构成一个三角形。如果不能则抛出异常IllegalArgumentException，显示异常信息：a,b,c “不能构成三角形”；如果可以构成则显示三角形三个边长。在主方法中得到命令行输入的三个整数，调用此方法，并捕获异常。 package triangle; import java.lang.*; p
c++ 多态
最新发布
05-25
C++中的多态（Polymorphism）是指在父类和子类之间的相互转换，以及在不同对象之间的相互转换。 C++中的多态性有两种：静态多态和动态多态。 1. 静态多态 静态多态是指在编译时就已经确定了函数的调用，也称为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Yongqiang Cheng

梦想不是浮躁，而是沉淀和积累。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值