虚函数与多态（一）

已于 2023-08-24 17:50:40 修改
阅读量974 收藏 1
点赞数 3
分类专栏： C++奇技淫巧 文章标签： c++ 开发语言
于 2017-05-26 13:33:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/INGNIGHT/article/details/72765475
版权

1.多态

   （1）多态性是面向对象程序设计的重要特征之一。

   （2）多态性是指发出相同的消息被不同类型的对象接收时，有可能导致完全不同的行为。

   （3）多态的实现：函数重载，运算符重载，模板，虚函数

2.静态绑定与动态绑定

   （1）静态绑定：绑定过程出现在编译阶段，在编译期就已确定要调用的函数。

   （2）动态绑定：绑定过程工作在程序运行时执行，在程序运行时才确定将要调用的函数。

3.虚函数

   （1）虚函数的概念：在基类中冠以关键字virtual的成员函数

   （2）虚函数的定义：

             [1]virtual 函数类型 函数名称(参数列表)

             [2]如果一个函数在基类中被声明为虚函数，则它在所有派生类中都是虚函数

   （3）只有通过基类指针或引用调用虚函数才能引发动态绑定。

   （4）虚函数不能声明为静态

4.虚析构函数

   （1）何时需要虚析构函数？

   （2）当你可能通过基类指针删除派生类对象是

   （3）如果你算允许其他人通过基类指针调用对象的析构函数（通过delete这样做是正常的），并且被析构的对象是有重要的析构函数的派生类的对象，就需要让基类的析构函数作为虚函数

5.虚表指针

   （1）虚函数的动态绑定是通过虚表来实现的

   （2）包含虚函数的类头4个字节存放指向虚表的指针

 32 位系统虚拟内存空间的分布情况，最上方的内核空间不用多讲，下方的用户空间内存

通过这张图你可以看到，用户空间内存，从低到高分别是五种不同的内存段。

  1. 只读段，包括代码和常量等。

  2. 数据段，包括全局变量等。

  3. 堆，包括动态分配的内存，从低地址开始向上增长。

  4. 文件映射段，包括动态库、共享内存等，从高地址开始向下增长。

  5. 栈，包括局部变量和函数调用的上下文等。栈的大小是固定的，一般是 8 MB。

#include <iostream>

using namespace std;


class Base {
public:
	virtual void Fun1() {
		cout << "Base::Fun1" << endl;
	}
	virtual void Fun2() {
		cout << "Base::Fun2" << endl;
	}
	int data1_;
};



class Derived : public Base {
public:
	virtual void Fun2() override final {
		cout << "Derived::Fun2" << endl;
	}
	virtual void Fun3() {
		cout << "Derived::Fun3" << endl;
	}
	int data2_;
};

typedef void (*FUNC)();

int main() {
	cout << sizeof(Base) << endl;
	cout << sizeof(Derived) << endl;
	
	Base b;	
	long**p = (long**)&b;
	FUNC fun = (FUNC)p[0][0];
	(*fun)();
	fun = (FUNC)p[0][1];
	(*fun)();
	cout << endl;
	
	Derived d;
	p = (long**)&d;
	fun = (FUNC)p[0][0];
	(*fun)();
	fun = (FUNC)p[0][1];
	(*fun)();
	fun = (FUNC)p[0][2];
	(*fun)();
	cout << endl;
	
	Base* pp = &d;
	pp->Fun2();  // 动态绑定
	d.Fun2();  //  静态绑定 
	return 0;
}

6.object slicing与虚函数

模板方法模式

#include <iostream>

using namespace std;


class CObject {
public:
	virtual void Serialize() {
		cout << "CObject::Serialize ..." << endl;
	}
};


class CDocument : public CObject {
public:
	int data1_;
	CDocument() {
		cout << "CDocument()" << endl;
	}
	CDocument(const CDocument& other) {
		cout << "CDocument(const CDocument& other)" << endl;
	}
	void func() {
		cout << "CDocument::func ..." << endl;
		Serialize();
	}	
	virtual void Serialize() override {
		cout << "CDocument::Serialize ..." << endl;
	}
};


class CMyDoc : public CDocument {
public:
	int data2_;
	virtual void Serialize() override {
		cout << "CMyDoc::Serialize ..." << endl;
	}
};

int main() {
	
	CMyDoc mydoc;
	CMyDoc* pmydoc = new CMyDoc;

	cout << "#1 testing" << endl;
	mydoc.func();
	
	cout << "#2 testing" << endl;
	((CDocument*)(&mydoc))->func();

	cout << "#3 testing" << endl;
	pmydoc->func();

	cout << "#4 testing" << endl;		
	((CDocument)mydoc).func();  // mydoc对象强制转换为CDocument对象，向上转型
				   //完完全全将对象转化为基类对象
				   //调用默认的拷贝构造函数
	
	delete pmydoc;
	pmydoc = NULL;
	return 0;
}

7.overload，override，overwrite 

 （1）成员函数被重载的特征：overload

             [1]相同的范围（在同一个类中）；

             [2]函数名字相同；

             [3]参数不同；

             [4]virtual关键字可有可无

  （2）覆盖是指派生类函数覆盖基类函数，特征是：override

            [1]不同的外围（分别位于派生类与基类）；

            [2]函数名字相同；

            [3]参数相同；

            [4]基类函数必须有virtual关键字

   （3）重定义（派生类与基类）：overwrite

            [1]不同的范围（分别位于派生类与基类）；

            [2]函数名与参数都相同，无virtual关键字；

            [3]函数名相同，参数不同，virtual可有可无

1. 子类继承父类的虚函数表的方式是复制一份。存在虚函数的类，都有自己的虚函数表，不与其他类共用。

2. 只要祖先类的某个函数被声明位virtual, 则在后代中无论是否显式地添加virtual，该函数一直都是虚的。

3. 如果子类重写了某个虚函数，则该类的虚函数表对应位置上的虚函数地址会被覆盖。如果完全不重写，则子类的虚函数表里面的内容和父类虚函数表内容保持一致。

4. 虚函数表类似于类的静态成员，被该类的所有实例共享。只不过该表是只读的，不存在线程安全问题。

5. 实例对象在起始4字节中，会存放虚函数表的地址(跟系统寻址范围有关，有的系统8字节才能表示一个地址)，可以通过手动寻址的方式完成虚函数调用。

6. 多重继承(有多个父类并列)时，该类有多张虚函数表，0~3字节，4~7字节分别表示第一张虚函数表地址，第二张虚函数表地址，以此类推。

7. 即便父类的虚函数是private的，子类的虚函数表中也依然存在它的地址，我们可以通过子类实例的首地址，寻找到虚函数表进而找到该虚函数，完成调用。这样会违背c++语言的设计初衷，破坏数据的安全性，一般不要轻易使用。

#include <iostream>
#include <string>
using namespace std;
 
typedef void(__stdcall *Fun)();
typedef void(__stdcall *Fun1)(double);
 
//声明virtual，让该成员函数地址在虚函数表中留下记录
class Brass{
  private:
    std::string fullname;
    long acctNum;
    double balance;
  public:
    Brass(const std::string & s ="NullBody",long an=-1,double bal=0.0);
    void Deposit(double amt);
    virtual void ViewAcct() const;
    virtual void withdraw(double amt);
    double Balance() const;
    virtual void test(){cout<<"Brass::test"<<endl;}
    virtual ~Brass(){}
};
 
//即便子类不再将父类的虚函数函数声明为virtual,只要祖先类中该函数是virtual,则它依然是虚函数
class BrassPlus:public Brass{
private:
    double maxLoan;
    double rate;
    double owesBank;
public:
    BrassPlus(const std::string & s ="NullBody",long an=-1,
              double bal=0.0,double ml=500,double r=0.11125);
    BrassPlus(const Brass &ba,double ml=500,double r=0.11125);
    void ViewAcct()const;
    void withdraw(double amt);
    void ResetMax(double m){maxLoan=m;}
    void ResetRate(double r){rate = r;}
    void ResetOwes(){owesBank=0;}
};
 
class BrassPlusPlus:public BrassPlus{
public:
    void ViewAcct() const override{cout<<"BrassPlusPlus viewacct"<<endl;}
};
 
 
Brass::Brass(const std::string & s,long an,double bal):fullname(s),acctNum(an),balance(bal){}
void Brass::Deposit(double amt){return;}
void Brass::withdraw(double amt){cout<<"Brass withdraw: "<<amt<<endl;return;}
double Brass::Balance() const{return balance;}
void Brass::ViewAcct()const{cout<<"Brass viewacct"<<endl;}
 
BrassPlus::BrassPlus(const std::string & s,long an,double bal,double ml,double r):Brass(s,an,bal),maxLoan(ml),rate(r){}
BrassPlus::BrassPlus(const Brass &ba,double ml,double r):Brass(ba),maxLoan(ml),rate(r){}
void BrassPlus::ViewAcct()const{cout<<"BrassPlus viewacct"<<endl;}
void BrassPlus::withdraw(double amt){cout<<"BrassPlus withdraw: "<<amt<<endl;return;}
 
void test(const Brass& br){
    br.ViewAcct();
    //br.withdraw(6.0);//编译不通，const 实例只能调用const成员函数；
    Brass& bbp=const_cast<Brass&>(br);
    bbp.withdraw(6.0);
}
 
int main()
{
#ifdef _WIN64
    typedef __int64 ADTY;//64位操作系统，8个字节表示一个地址
#else
    typedef __int32 ADTY;
#endif
    cout << "Hello World!" << endl;
    Brass bra("Jim",2,0.06);
    BrassPlus brap("Jhon",5,0.58,500,0.014);
 
    const Brass bra_2("Jack",3,0.02);
    Brass& b1 = bra;
    Brass& b2 = brap;
 
    Brass *bas[2];
    bas[0] = &bra;
    bas[1] = &brap;
 
    cout << "对象bas[0]的虚函数表位于："<<hex<<*(ADTY*)bas[0]<<",对象bas[0]的第一个虚函数位于："<<hex<<*( (ADTY *)*(ADTY*)bas[0] + 0 )<<endl;
    cout << "对象bas[1]的虚函数表位于：" <<hex<<*(ADTY*)bas[1]<<",对象bas[1]的第一个虚函数位于："<<hex<<*( (ADTY *)*(ADTY*)bas[1] + 0 )<<endl;
    cout << "子类虚函数表会从父类继承(复制一份，不是共用一份)，如果子类重写了某个虚函数，则子类的虚函数表中对应的函数地址会被覆盖"<<endl;
 
    Fun cc = (Fun)( *( (ADTY *)*(ADTY*)bas[1] + 0 ) );
    Fun1 dd = (Fun1)( *( (ADTY *)*(ADTY*)bas[1] + 1 ) );
    cout<<"对象bas[1]虚函数调用结果："<<endl;
    cc();
    dd(8.9);
 
    ADTY *ptr = (ADTY*)(&bra);
 
    //可以看出虚函数表类似于类的静态成员，对象的首地址位置保存了虚函数表的地址
    cout << "对象bra的虚函数表位于："<<hex<<*ptr<<",对象bra的第一个虚函数位于："<<hex<<*( (ADTY*)*ptr + 0 )<<endl;
    cout << "对象bra_2的虚函数表位于：" <<hex<<*(ADTY*)(&bra_2)<<",对象bra_2的第一个虚函数位于："<<hex<<*( (ADTY*)*(ADTY*)(&bra_2) + 0 )<<endl;
    cout << "说明bra的虚函数表 与 bra_2的虚函数表 是同一张表"<<endl;
 
    ADTY* ptr1 =(ADTY*)*ptr;
    Fun pFun = (Fun)*(ptr1+0); //等效于 (Fun)(*((ADTY*)*(ADTY*)(&bra)+0));
    pFun();
 
    Fun1 pFun1 = (Fun1)*(ptr1+1); //等效于 (Fun)(*((ADTY*)*(ADTY*)(&bra)+1));
    pFun1(9.0);
    cout << "Hello World end" << endl;
    return 0;
}

INGNIGHT
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多态与虚函数
Hustle Everyday
03-07 915
一、什么是多态 多态就是向不同的对象发送同一个消息，不同的对象在接收时会产生不同的行为。也就是说，每个对象可以用自己的方式去响应共同的消息。使用相同的代码实现不同的动作，体现了面向对象编程的优越性。 在C++中，多态就是利用基类指针指向子类实例，通过基类指针调用子类（虚）函数从而实现“一个接口，多种形态”的效果。 简单的说就是，实现了一个函数会根据传入参数的不同有不同的功能，比如： vo...
C++ 基础之虚函数和虚基类
LSEC小陆的博客
02-28 6606
C++ 基础之虚函数和虚基类 C++ 有别于 C ,比较重要的就是其抽象、封装、继承和多态等特性。多态又具体地体现在重载、虚函数和模板等等之上。 今天就和大家聊一聊虚函数和虚基类。 虚函数 我们来思考一个问题。假如子（派生）类 B 继承自父（基）类 A，现在有一个 A 类型的指针指向了 B，这时候指针只能调用 B 中继承自 A 的那一部分东西。那么，现在假设 B 中有一个和 A 中同名、同传入参数...
C++虚基类、虚函数、虚析构函数、纯虚函数
weixin_40763897的博客
08-16 2070
举个例子来说明一下什么是虚基类吧。return 0;}BaseDerived ABaseDerived B从上面打印出来的结果可以看出Base在内存中有两个副本。但实际上只需要一个Base副本就可以了。BaseDerived ADerived B此时Base在内存只有一份了。...
【C++入门】(纯)虚函数和多态、抽象类、接口
最新发布
weixin_42031299的博客
10-28 1554
(1)当基类含有1个或多个虚函数时，其析构函数需要声明为virtual虚函数；(2)将析构函数定义为虚函数，可以保证派生类析构时能调用正确的析构函数；(1)虚函数的作用是实现面向对象的多态效果，让成员函数在运行时动态解析和绑定具体的执行函数；(2)将成员函数定义为virtual虚函数是有额外开销的，因为要在运行时动态绑定；如果是普通函数，在编译时就可以确定并绑定完成；
多态性和虚函数
haiki66的博客
03-13 493
多态性：是指具有不同功能的函数可以用同一个函数名，这样就可以用一个函数名调用不同内容的函数。 向不同的对象发送同一个消息，不同的对象在接收时会产生不同的行为(即方法)。也就是说，每个对象可以用自己的方式去响应共同的消息。 静态多态性(编译时的多态性) 在程序编译时系统就能决定调用的是哪个函数 通过函数的重载实现的(运算符重载实质上也是函数重载)。 动态多态性(运行时的多态性) ...
C++虚基类、虚函数、纯虚函数与抽象基类区分
weixin_57796792的博客
11-06 1307
#C++虚基类、虚函数、纯虚函数与抽象基类 C++的一个最重要特点就是继承，关于继承有很多概念，如虚基类、虚函数、纯虚函数和抽象基类。这些概念容易混淆，以下我做一些简单的区分，可能有些地方说明不够充分，望见谅。 虚基类与虚函数容易混淆，虽然同是在继承环境下，但是毫无关系。虚基类 主要是在多重继承时使用。内容比较复杂，初学者只需要掌握一点就可以 有需要的可以查看其他资料。 | 如果子类C同时继承A与B，那么就会将父类的成员变量继承两遍， |这个时候在继承时需要加上virtual，此时相当于只继承了父类的一个
深入解析C++中的虚函数与多态
01-21
1.C++中的虚函数C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是...
c++语言中虚函数实现多态的原理详解
12-25
自上一个帖子之间跳过了一篇总结性的帖子，之后再发，今天主要研究了c++语言当中虚函数对多态的实现，感叹于c++设计者的精妙绝伦 c++中虚函数表的作用主要是实现了多态的机制。首先先解释一下多态的概念，多态是c++...
c++继承与多态，虚函数实例
04-26
虚函数在实现多态中扮演着关键角色，它可以确保程序在运行时能够调用到正确的方法，即便对象的实际类型与指针或引用声明的类型不同。 首先，让我们深入理解“虚函数”这一概念。在C++中，虚函数通过在基类中使用`...
虚函数与多态总结
qq_40358433的博客
07-01 147
一、基础知识1、多态性的基本概念多态性是指一个名字多种语义，或界面相同多种实现重载函数是多态性的一种简单形式虚函数允许函数调用与函数体的联系在运行时才进行，称为动态联编2动态联编（1）虚函数和基类指针写有关键字virtual的成员函数称为虚函数，实现运行多态的关键是要说明虚函数，另外必须用基类指针调用派生类的不同实现版本。注意：一个虚函数，在派生类层界面相同的重载函数都保持虚特性虚函数必须是类的成...
虚函数和多态
gunqu_d的博客
11-15 3278
一、虚函数&多态基础 虚函数是加了virtual关键词之后的类成员函数。 虚函数重写：当在子类中定义了一个与父类完全相同的虚函数时，则称子类的这个函数重写（也叫覆盖）了父类的这个虚函数。 上图中，类Person和类Student中的虚函数Buy一样，且Student继承了Person，所以，Student中的Buy函数重写（覆盖）了Person中的Buy。 至于多态，其形成的条
【c++基础】笔记（七）
AG的博客
10-13 243
1 静态联编和动态的联编 1.1 分类  静态多态  动态多态 1.2 静态多态 1.2.1 运算符重载  函数重载 1.2.2 地址早绑定，编译阶段绑定的 1.3 动态多态 1.3.1 继承  虚函数 1.3.2 地址晚绑定  ，运行时候再去绑定地址 1.4 virtual void fun()  虚函数 2 多态的工作原理 2.1 当父类中有了虚函数中，内部维护一个虚函
虚函数多态
juewangdeniqiu的博客
08-25 289
一、知识点 1、一个操作随着所传递的对象类型的不同能够做出不同的反应，其行为模式成为多态。（P413）   2、基类与派生类的同名操作，只要标记上virtual，则该操作便具有多态性。（P416）   3、一旦标记基类的函数为虚函数，便有连锁反应，后面继承的类中一切同名成员函数都变成了虚函数。如果是引发实际复制动作的传递，则子类对象完全变成基类对象了，这时候，便不会再
c++中基类虚函数表的深入解析
sinat_26494443的博客
01-10 589
前言   C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。     关于虚函数的使
C++ 学习之路(11)：多态性与虚函数
Rioer的博客
04-02 849
一、多态性： 1、概念: ①不同对象收到相同的消息时，产生不同的动作。即多态性。 ②即用相同的接口访问不同功能的函数，实现“一种接口，多种 方法” 2、多态可分为编译时的多态和运行时的多态 ①连编：即把函数名与函数体的程序代码连接(联系)在一起的过 程。
C++之多态性与虚函数（一）
qq_39220334的博客
04-02 340
多态性与虚函数（一）1 多态性1.1 多态的概念1.2 多态的分类2 利用虚函数实现动态多态性2.1 虚函数的作用2.2 静态关联和动态关联2.3 虚函数的注意事项2.4 虚析构函数 1 多态性 1.1 多态的概念 多态性：向不同的对象发送同一个消息，不同的对象在接收时会产生不同的行为（方法）。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。函数的重载、运算符重载都是多态现象。 C++中的多态：具有不同功能的函数可以用同一个函数名，这样就可以实现用一个函数名调用不同内容的函数。 1.2
回调函数(__stdcall)
把握自己。
02-09 3768
2 过程语言中的回调（C） 2.1 函数指针 回调在C语言中是通过函数指针来实现的,通过将回调函数的地址传给被调函数从而实现回调。因此，要实现回调，必须首先定义函数指针，请看下面的例子： void Func(char *s)；// 函数原型 void (*pFunc) (char *);//函数指针 可以看出，函数的定义和函数指针的定义非常类似。 一般的化，为了简化函数指针类型的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值