c++的继承布局/多态

最新推荐文章于 2021-10-21 10:53:07 发布
最新推荐文章于 2021-10-21 10:53:07 发布
阅读量224 收藏
点赞数
分类专栏： c++ 文章标签： c++ 多态
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_28603977/article/details/56847810
版权
#include <iostream>
using namespace std;
//复杂的继承


                     //钻石型继承
class B
{
public:
int ib;
char cb;
B():ib(0),cb('b'){cout<<"B()\n";}
virtual void f(){cout<<"B::f()\n";}
virtual void Bf(){cout<<"B::Bf()\n";}
};


class B1 : virtual  public B
{
public:
int ib1;
char cb1;
public:
B1():ib1(11),cb1('1') {cout<<"B1()\n";}


virtual void f() { cout << "B1::f()" << endl;}
virtual void f1() { cout << "B1::f1()" << endl;}
virtual void Bf1() { cout << "B1::Bf1()" << endl;}


};


class B2 :   virtual public B
{
public:
int ib2;
char cb2;
public:
B2():ib2(11),cb2('1') {cout<<"B2()\n";}


virtual void f() { cout << "B2::f()" << endl;}
virtual void f2() { cout << "B2::f2()" << endl;}
virtual void Bf2() { cout << "B2::Bf2()" << endl;}


};


class D : public B1, public B2
{
public:
int id;
char cd;
public:
D():id(100),cd('D') {cout<<"D()\n";}


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;}


};


int main()
{
B1 b1;
int **p = (int**)&b1;
cout<<p[1][0]<<"\n";
cout<<p[1][1]<<"\n";
}


#if 0
int main()
{
D d;
cout<<sizeof(d)<<"\n";
}
#endif


/*
class D size(60):
+---
| +--- (base class B1)
0      | | {vfptr}
4      | | {vbptr}
8      | | ib1
12      | | cb1
| | <alignment member> (size=3)
| +---
| +--- (base class B2)
| | +--- (base class B)
16      | | | {vfptr}
20      | | | ib
24      | | | cb
| | | <alignment member> (size=3)
| | +---
28      | | ib2
32      | | cb2
| | <alignment member> (size=3)
| +---
36      | id
40      | cd
| <alignment member> (size=3)
+---
44      | (vtordisp for vbase B)
+--- (virtual base B)
48      | {vfptr}
52      | ib
56      | cb
| <alignment member> (size=3)
+---


D::$vftable@B1@:
| &D_meta
|  0
0      | &D::f1
1      | &B1::Bf1
2      | &D::Df


D::$vftable@:
| -16
0      | &D::f
1      | &B::Bf
2      | &D::f2
3      | &B2::Bf2


D::$vbtable@:
0      | -4
1      | 44 (D d(B1+4)B)


D::$vftable@B@:
| -48
0      | &(vtordisp) thunk: this-=32; goto D::f
1      | &B::Bf
*/
#if 0
                     //重复继承
class B
{
public:
int ib;
char cb;
B():ib(0),cb('b'){}
virtual void f(){cout<<"B::f()\n";}
virtual void Bf(){cout<<"B::Bf()\n";}
};


class B1 :  public B
{
public:
int ib1;
char cb1;
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;}


};


class B2 :  public B
{
public:
int ib2;
char cb2;
public:
B2():ib2(11),cb2('1') {}


virtual void f() { cout << "B2::f()" << endl;}
virtual void f2() { cout << "B2::f2()" << endl;}
virtual void Bf2() { cout << "B2::Bf2()" << endl;}


};


class D : public B1, public B2
{
public:
int id;
char cd;
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;}


};


int main()
{
D d;
}
/*
class D size(48):
+---
| +--- (base class B1)
| | +--- (base class B)
0      | | | {vfptr}
4      | | | ib
8      | | | cb
| | | <alignment member> (size=3)
| | +---
12      | | ib1
16      | | cb1
| | <alignment member> (size=3)
| +---
| +--- (base class B2)
| | +--- (base class B)
20      | | | {vfptr}
24      | | | ib
28      | | | cb
| | | <alignment member> (size=3)
| | +---
32      | | ib2
36      | | cb2
| | <alignment member> (size=3)
| +---
40      | id
44      | cd
| <alignment member> (size=3)
+---


D::$vftable@B1@:
| &D_meta
|  0
0      | &D::f
1      | &B::Bf
2      | &D::f1
3      | &B1::Bf1
4      | &D::Df


D::$vftable@B2@:
| -20
0      | &thunk: this-=20; goto D::f
1      | &B::Bf
2      | &D::f2
3      | &B2::Bf2
*/




#endif 






#if 0
                     //多重继承
class Base1 {
public:
int ibase1;
Base1():ibase1(10) {}
virtual void f() { cout << "Base1::f()" << endl; }
virtual void g() { cout << "Base1::g()" << endl; }
virtual void h() { cout << "Base1::h()" << endl; }


};


class Base2 {
public:
int ibase2;
Base2():ibase2(20) {}
virtual void f() { cout << "Base2::f()" << endl; }
virtual void g() { cout << "Base2::g()" << endl; }
virtual void h() { cout << "Base2::h()" << endl; }
};


class Base3 {
public:
int ibase3;
Base3():ibase3(30) {}
virtual void f() { cout << "Base3::f()" << endl; }
virtual void g() { cout << "Base3::g()" << endl; }
virtual void h() { cout << "Base3::h()" << endl; }
};




class Derive : public Base1, public Base2, public Base3 {
public:
int iderive;
Derive():iderive(100) {}
virtual void f() { cout << "Derive::f()" << endl; }
virtual void g1() { cout << "Derive::g1()" << endl; }
};


int main()
{
Derive d;
return 0;
}


/*
class Derive    size(28):
+---
| +--- (base class Base1)
0      | | {vfptr}
4      | | ibase1
| +---
| +--- (base class Base2)
8      | | {vfptr}
12      | | ibase2
| +---
| +--- (base class Base3)
16      | | {vfptr}
20      | | ibase3
| +---
24      | iderive
+---


Derive::$vftable@Base1@:
| &Derive_meta
|  0
0      | &Derive::f
1      | &Base1::g
2      | &Base1::h
3      | &Derive::g1


Derive::$vftable@Base2@:
| -8
0      | &thunk: this-=8; goto Derive::f
1      | &Base2::g
2      | &Base2::h


Derive::$vftable@Base3@:
| -16
0      | &thunk: this-=16; goto Derive::f
1      | &Base3::g
2      | &Base3::h


Derive::f this adjustor: 0


Derive::g1 this adjustor: 0
*/
#endif 


#if 0


                       //单一继承


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


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


class GrandChild:public Child
{
public:
int igrandchild;
GrandChild():igrandchild(1000) {}
virtual void f() { cout << "GrandChild::f()" << endl; }
virtual void g_child() { cout << "GrandChild::g_child()" << endl; }
virtual void h_grandchild() { cout << "GrandChild::h_grandchild()" << endl; }
};
/*
child :           GrandChild:
&Child::f() ----->GranChiuld::f()
&Parent::g  ----->&Parent::g
        &Parent::h  ----->&Parent::h
&Child::g_child()->GrandChild::g_child()
&Child::h_child()->Child::h_child()
                ->GrandChild::h_grandchild()
iParent
ichild
iGrandChild
*/


typedef void (*FUN)();


int main()
{
FUN pFun = NULL;
GrandChild g;
int **pVtab = (int**)&g;
/*for(int i = 0; (FUN)pVtab[0][i] != NULL; ++i)
{
pFun = (FUN)pVtab[0][i];
pFun();
}*/
cout<<(int)pVtab[1]<<"\n";10
cout<<(int)pVtab[2]<<"\n";100
cout<<(int)pVtab[3]<<"\n";1000
}
#endif
//简单的继承
#if  0
class Base1 
{
public:
virtual void f() { cout << "Base1::f" << endl; }
virtual void g() { cout << "Base1::g" << endl; }
virtual void h() { cout << "Base1::h" << endl; }
};


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


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




class Derive : public Base1, public Base2, public Base3 {
public:
virtual void f() { cout << "Derive::f" << endl; }
virtual void g1() { cout << "Derive::g1" << endl; }
};
typedef void(*Fun)(void);




int main()
{
Fun pFun = NULL;
Derive d;
int **pVtab = (int**)&d;


pFun = (Fun)pVtab[0][0];
pFun();
pFun = (Fun)pVtab[0][1];
pFun();
pFun = (Fun)pVtab[0][2];
pFun();
pFun = (Fun)pVtab[0][3];
pFun();
pFun = (Fun)pVtab[1][0];
pFun();
pFun = (Fun)pVtab[1][1];
pFun();
pFun = (Fun)pVtab[1][2];
pFun();
pFun = (Fun)pVtab[2][0];
pFun();
pFun = (Fun)pVtab[2][1];
pFun();
pFun = (Fun)pVtab[2][2];
pFun();


}


Derive::f
Base1::g
Base1::h
Derive::g1
Derive::f
Base2::g
Base2::h
Derive::f
Base3::g
Base3::h


#endif


#if 0
class Base
{
public:
virtual void f(int i = 1)
{
cout<<"Base::f()"<<i<<"\n";
}
};


class Drive:public Base
{
public:
void f(int  i = 2)               //函数值相同，参数列表相同才能够重写,返回值不同会被认为同一函数
{
cout<<"Drive::f()"<<i<<"\n";
}


};


typedef void (*PFU)();


int main()
{
Drive d;
Base *p = &d;
p->f(3);
//Base *p = &d;  //子类私有方法也能重载
//p->f();
/*PFU pFun = (PFU)*(int*)(*(int*)(&d));
pFun();*/
}
#endif


#if 0
class Base1
{
public:
virtual void f1()
{
cout<<"Base1::f1()\n";
}
virtual void g1()
{
cout<<"Base1::g1()\n";
}
virtual void h1()
{
cout<<"Base1::h1()\n";
}


};


class Base2
{
public:
virtual void f1()
{
cout<<"Base2::f1()\n";
}
virtual void g2()
{
cout<<"Base2::g2()\n";
}
virtual void h2()
{
cout<<"Base2::h2()\n";
}


};
class Drive:public Base1,public Base2
{
public:
virtual void f1()
{
cout<<"Drive::f1()\n";
}
virtual void g2()
{
cout<<"Drive::g2()\n";
}
virtual void h3()
{
cout<<"Drive::h3()\n";
}
};




typedef void (*Fun)(void);


int main()
{
Drive d;
Base1 *b1 = &d;
Base2 *b2 = &d;
d.f1();
b1->f1();
b2->f1();


/*Drive b;
Fun pFun = NULL;
cout<<"虚函数表地址:"<<(int*)(&b)<<"\n";
cout<<"第一个函数地址:"<<(int*)*(int*)(&b)<<"\n";*/


/*pFun = (Fun)*((int*)*(int*)(&b));
pFun();
pFun = (Fun)*((int*)*(int*)(&b)+1);
pFun();
pFun = (Fun)*((int*)*(int*)(&b)+2);
pFun();
pFun = (Fun)*((int*)*(int*)(&b)+3);
pFun();
pFun = (Fun)*((int*)*(int*)(&b)+4);
pFun();
pFun = (Fun)*((int*)*(int*)(&b)+5);
pFun();*/
}
#endif


#if 0
class A
{
public:
A(int a):_a(a){cout<<"A()\n";}
private:
public:
int _a;
};


class B
{
public:
B(int b):_b(b){cout<<"B()\n";}
private:
int _b;
};


class C :public A,public B
{
public:
C(int c = 0):_c(c),A(c),B(c){cout<<"C()\n";}
private:
int _c;
};


int main()
{
C c;
}
#endif
hanqingkuo
关注
专栏目录
C++继承与多态—多重继承的那些坑该怎么填
GeniusAng的博客
06-22 894
施磊C++语言基础提高课程笔记，包括了虚基类和虚继承、菱形继承的问题、C++语言级别提供的四种类型转换方式
C++封装、继承、多态
Z's Palace
01-26 1409
面向对象的三个基本特征 面向对象的三个基本特征是：封装、继承、多态。其中，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！ 封装
C++笔记8.22
iMercedes的博客
08-23 358
不可修饰的对象 const Currency the_raise(42,38) 编译器只知道原型，不知道body并不知道对象的body中的函数会不会修改这个const 所以在函数（）后面加const，原型和body都要加 class A{ int i; public: A():i(0){} void f() {cout <<"f"<<endl;} void f() const{cout<<"f const"<<endl;} }; int main()
面向对象程序设计的预习和复习 一（c++）
Z201988009的博客
10-21 315
类与对象 定义类 class 类名{ private: 变量或函数 protected: 变量或函数 public: 变量或函数 }; private定义私有成员，外部不能调用。 public定义共有成员，外部直接调用，是内部与外部的接口。 protected定义保护成员，外部不能直接调用，但是派生类可以使用。 eg: class person{ private: sting name; char se
C++继承和Java继承的对比+动态联编的注意事项
weixin_46028606的博客
10-02 272
#include <iostream> using namespace std; class A { public: void f() { cout << "A\n"; } }; class B :public A { public: B() { } void f() { cout << "B\n"; } }; int main() { A a = B(); a.f();/
【C++基础之十一】虚函数的用法
偶尔e网事
09-22 9611
虚函数的作用和意义，就不进行说明了，这里主要讨论下虚函数的用法。 1.典型的虚函数用法 可以看到，只有标识为virtual的函数才会产生多态的效果，而且是编译多态。它只能借助指针或者引用来达到多态的效果。 class A { public: virtual void f(){cout<<"A::f()";}//虚函数 void g(){cout<<"A::g()";}//普通
c++面试题
hangyejiadao的专栏
07-07 431
// cpp.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include using namespace std; class A { public: A() { } virtual void f() { cout << "A::f()\n"; } void f()const { cout << "A::f() const\n
EDA/PLD中的C++对象布局及多态实现之动态和强制转换
11-18
《EDA/PLD中的C++对象布局及多态实现之动态和强制转换》 这篇文章探讨的是C++编程语言在电子设计自动化（EDA）和可编程逻辑器件（PLD）领域中的应用，特别是关于对象布局、多态性以及动态和强制类型转换的实现。在...
C++对象布局及多态实现之动态和强制转换
01-19
下面我们看看引入虚继承后的影响。为了有所对比我们首先看看普通成员函数的调用情况。 执行如下代码，它包括了对象的普通成员函数调用，类的静态成员函数调用、通过指针调用普通成员函数： C010 obj; ...
C++中的多态与多重继承实现与Java的区别
12-20
为了解决这个问题，C++采用了一种称为菱形继承的解决方案，即将所有基类的虚函数表合并到派生类的vtable中，并在派生类的对象内存布局中包含所有基类的数据。在类型转换时，指针的值会被调整以指向正确的vtable部分...
c++类实例对象内存布局
红茶的博客
06-04 553
下面对几种情况分别讨论单一简单类class father { public: father(){}; ~father(){}; public: void doSomething(){}; static void sDoSomething(){}; private: char a; int b; static int c; };对他进行编译，我们
【总结篇】C++中普通多态多重继承、普通虚继承、多态多重继承与虚继承相结合对类的内存布局sizeof的影响
m0_38014304的博客
11-23 210
这一篇是对我的另外两篇博客（https://blog.csdn.net/m0_38014304/article/details/84286266和https://blog.csdn.net/m0_38014304/article/details/84335787）的总结，对继承体系中类的sizeof大小做一个最后的归纳，如果以后有内存布局有变动，均在这一篇博客上进行修改。 源码： # inc...
关于vtordisp知多少？
weixin_33873846的博客
01-14 293
关于vtordisp知多少？我相信不少人看到这篇文章，多半是来自于对标题中“vtordisp”的好奇。其实这个关键词也是来源于我最近查看对象模型的时候偶然发现的。我是一个喜欢深究问题根源的人（有点牛角尖吧），所以当我第一次发现vtordisp的时候，我也是很自然的把它输进google查找相关资料，但是结果令我不太满意。不过，即使如此，我还是把与它相关的资料整理如下，并结合自己的理解和大家...
C++类的内存对齐-C++alignment
yinjun66的博客
04-08 4798
在C++中的某一个类的内存大小是由以下三部分组成： 1：nonstatic data member的总和大小 2：alignment所填补的空间，可能存在于members之间，也可能是类的边界 3：为了支持virtual而由内部产生的额外负担，比如：指虚基类表的指针或指向虚函数表的指针 其中1和3都比较好确定，比较难确定的是2中的内存对齐（填补）的大小 以下的分析都是Visual Std
继承、虚继承的类的格式与大小
youxiazc的专栏
10-07 364
#includeusingnamespace std;class class1{public:int a;double aa;virtualvoid f(){}};class class2:virtualpublic class1{public :int b;char bb;};class class3:virtualpublic class1{public:int d;double dd;};class class4: public class2, public class3{public:int e;d
[C++基础]对象内存分布--基本
超越
08-14 1452
对于C++开发者来说，了解其内存是非常必要的，同时C++的多态（动态绑定）的原理也是很重要的。VS打开工程，右键工程名称—>属性—>c/c++—>命令行—> /d1 reportAllClassLayout 空类 class emptyClass {}; //1 > class emptyClass size(1) : //1 > +-- - //1 &g...
虚基类、虚函数，对象内存分布
northhero的专栏
09-06 2075
在Project Properties->C++->Command Line->Additional Options里面加上/d1reportSingleClassLayoutDerived编译时，可输出类Derived的内存布局。  非虚拟继承：在派生类对象里，按照继承声明顺序依次分布基类对象，最后是派生类数据成员。若基类声明了虚函数，则基类对
Windows系统远程桌面设置（附win11家庭版开启组策略功能及远程桌面）
最新发布
11-10
Windows系统远程桌面设置（附win11家庭版开启组策略功能及远程桌面）
C++多态与多重/虚拟继承：对象模型、效率解析
C++中的多重继承和虚拟继承是面向对象编程中两个关键概念，它们涉及到对象模型、多态性和性能效率。首先，让我们从多态性开始讨论。 多态性是C++的重要特性，它允许一个接口具有多种形态，即在不同上下文中表现出...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值