c++虚继承 虚继承实现原理
C++类的大小是怎样计算的
class Rectangle:public Point一.简单情况的计算
c++虚继承 虚继承实现原理
c++虚继承 虚继承实现原理
#include
计算结果：8
二.空类的大小
本文中所说是C++的空类是指这个类不带任何数据，即类中没有非静态(non-static)数据成员变量，没有虚函数(virtual function)，也没有虚基类(virtual base class)。
直观地看，空类对象不使用任何空间，因为没有任何隶属对象的数据需要存储。然而，C++标准规定，凡是一个的(非附属)对象都必须具有非零大小。换句话说，c++空类的大小不为0
#include
输出:
The size of an object of empty class is: 11
C++标准指出，不允许一个对象（当然包括类对象）的大小为0，不同的对象不能具有相同的地址。这是由于：
new需要分配不同的内存地址，不能分配内存大小为0的空间
但是，有两种情况值得我们注意
种情况，涉及到空类的继承。
class Empty {};
sizeof(D)为4。
class Empty {};class HoldsAnInt {
sizeof(HoldsAnIn{return 0;}t)为8。
继承空类的派生类，如果派生类也为空类，大小也都为1。
三.含有虚函数成员
首先，要介绍一下虚函数的工作原理：
虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。编译器必需要保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证正确取到虚函数的偏移量）。
设我们有这样的一个类：
class Base {public:virtual void f() { cout << "Base::f" << endl; }virtual void g() { cout << "Base::g" << endl; }virtual void h() { cout << "Base::h" << endl; }
当我们定义一个这个类的实例，Base b时，其b中成员的存放如下：
指向虚函数表的指针在对象b的最前面。
虚函数表的多加了一个结点，这是虚函数表的结束结点，就像字符串的结束符”0”一样，其标志了虚函数表的结束。这个结束标志的值在不同的编译器下是不同的。在vs下，这个值是NULL。而在linux下，这个值是如果1，表示还有下一个虚函数表，如果值是0，表示是一个虚函数表。
例如：
class Base {public:int a;virtual void f() { cout << "Base::f" << endl; }virtual void g() { cout << "Base::g" << endl; }virtual void h() { cout << "Base::h" << endl; }
sizeof(Base)为16。
下面将讨论针对基类含有虚函数的继承讨论:
（1）在派生类中不对基类的虚函数进行覆盖，同时派生类中还拥有自己的虚函数，比如有如下的派生类：
class Derived: public Base
基类和派生类的关系如下：
当定义一个Derived的对象d后，其成员的存放如下：
可以发现：
1）虚函数按照其声明顺序放于表中。
2）基类的虚函数在派生类的虚函数前面。
此时基类和派生类的sizeof都是数据成员的大小+指针的大小8。
（2）在派生类中对基类的虚函数进行覆盖，设有如下的派生类：
class Derived: public Base
基类和派生类之间的关系：其中基类的虚函数f在派生类中被覆盖了
可以发现：
1）覆盖的f()函数被放到了虚表中原来基类虚函数的位置。
2）没有被覆盖的函数依旧。
派生类的大小仍是基类和派生类的非静态数据成员的大小+一个vptr指针的大小
这样，我们就可以看到对于下面这样的程序，
Base b = new Derive();
b->f();
由b所指的内存中的虚函数表的f()的位置已经被Derive::f()函数地址所取代，于是在实际调用发生时，是Derive::f()被调用了。这就实现了多态。
（3）多继承：无虚函数覆盖
对于派生类实例中的虚函数表，是下面这个样子：
我们可以看到：
1） 每个基类都有自己的虚表。
2） 派生类的成员函数被放到了个基类的表中。（所谓的个基类是按照声明顺序来判断的）
由于每个基类都需要一个指针来指向其虚函数表，因此d的sizeof等于d的数据成员加上三个指针的大小。
（4）多重继承，含虚函数覆盖
我们可以看见，三个基类虚函数表中的f()的位置被替换成了派生类的函数指针。这样，我们就可以任一静态类型的基类类来指向派生类，并调用派生类的f()了。如：
Derive d;
此情况派生类的大小也是类的所有非静态数据成员的大小+三个指针的大小
举一个例子具体分析一下大小吧：
#include
结果分析:
四.虚继承的情况
对虚继承层次的对象的内存布局，在不同编译器实现有所区别。
它在gcc下实现比较简单，不管是否虚继承，GCC都是将虚表指针在整个继承关系享的，不共享的是指向虚基类的指针。
class A { int a;
以上代码中sizeof(A)=16,sizeof(B)=24,sizeof(C)=24,sizeof(D)=32.
C和C++经典笔试题附解析
virtual void a(){};C和C++经典笔试题附解析
Class A{ const int size=0;};1. 用预处理指令#define声明一个常数，用以表明1年中有多少秒(忽略闰年问题)。
：#define SECONDS_PER_YEAR(606024365)UL
应该意识到表达式将使一个16位机的整形数溢出，因此要用到长整型符号L，表达式中UL表示无符号长整型。
2. 写一个“标准”宏MIN，这个宏输入连个参数并返回较小的一个。
3. sizeof 的一些考察
char ss1=”0123456789”; char ss2[]=”0123456789”; char ss3[100]=”0123456789”;
int ss4[100]; char q1[]=”abc”; char q2[]=”a
：ss1是一个字符指针，指针的大小是一个确定的值，就是4，sizeof(ss1)=4;
ss2是一个字符数组，这个数组最初的大小未定，填充值是“0123456789”，一个字符占一位，再加上隐含的“0”一共是11位。
ss3是一个字符数组，这个数组开始预分配100，所以它的大小是100位。
ss4是一个整型数组，但是每个整型变量所占空间是4，所以它的大小一共是400位。
q1与ss2类似，占4位。Q2里面有一个“
4. What is the output of the following code?
#include
using namespace std;
class A {};
class A2 {char d,e;};
struct B{};
struct D{int x,y;};
main()
{cout< cout< A p1=new A();
Ap3;
cout< cout< cout< cout< cout< cout< return 0;
}：对于一个类而言，即便它是一个空的类，编译器仍然要要给它一个空间，所以类A即便什么也没有，它的空间大小依然为1，而类A2大小是类中连个字符 d，e之和，所以它的空间大小依然是2，至于p1，p2，p3，p1和p3是指针，大小是一致的，而且是定值，为4，p2是A的对象，所以它的大小和类A 相等，为1，B和C得解释同A和A2，至于D，它和C不同点在于，结构体有两个整型变量，每个整型变量所占空间为4，所以D所占空间大小为8。
结果是 1， 2，4， 1，4，1，2，8
#include using namespace std;
class A1 { public: int a; static int b;A1(); ~A1();}; 4
class A2 { public: int a; char c; A2(); ~A2();}; 8
class A3 { public: float a; char c; A3(); ~A3();}; 8
class A4 { public: float a; int b; char c; A4(); ~A4();}; 12
class A5 { public: double d; float a; int b; char c; A5(); ~A5();} 24
int main() { cout< ：因为静态变量是存放在全局数据区的，sizeof计算栈中分配的大小，是不会计算在内的，所以sizeof(A1)是4;为了照顾数据对其，int 大小为4，char大小为1，所以sizeof(A2)是8;为了照顾数据对其，float大小为4，char大小为1，所以sizeof(A3)为8;为了照顾数据对其，float大小为4，int大小为4，char大小为1，所以sizeof(A4)为12;为了照顾数据对其，double大小为 8，float大小为4，int大小为4，char大小为1，所以sizeof(A5)为24。
6. 以下代码的输出结果是()
char var[]
Int test(char var[]){ retrun sizeof(var);}
：因为var[]等价于var，已经退化成一个指针了，所以大小是4.
7. 以下代码的输出结果是()
Class B { float f; char p; int asf[3];}; cout< ：float f占了4个字节，char p占了一个字节，int adf[3]占了12个字节，总共是17个，根据内存的对齐原则，要选择4的倍数，是20个字节。
8. 以下代码的输出结果是()
Class B { double d; char p; int asf[4];}; cout< ：double d占了8个字节，char p占了一个字节，int adf[4]占了16个字节，总共是25个，根据内存的对齐原则，要选择8的倍数，是32个字节。
9. 一个空类所占空间为1，多重继承的空类所占的空间还是1，但是虚继承涉及到虚表(虚指针)，所以虚继承的空类占的空间为4
10. this指针是在实例化一个对象后产生的,并且指向对象本身.比如实例化一个对象pt,那么this=&pt;用”&”取地址符来取对象的地址.同样,如果定义对象pt这个类中,有一个public变量x,那么就可以用this->x=0来定义x的值,等同于pt.x=0.
11. #include using namespace std;
Void GetMemory(int z) { z=5; }
Int main() { int v; GetMemory(&v); cout< Getmory把v的地址传了过来,z是地址里的值,是v的副本.通过直接修改地址里的值,不需要有返回值,也把v给修改了,因为v所指向地址的值发生了改变,最终程序会崩溃.
12. 下面的数据声明都代表什么意思?
(1)float(def)[10]
Def是一个二级指针，它指向的是一个一维数组的指针，数组的元素都是float。
(2)double(gh)[10]
Gh是一个指针，它指向一个一维数组，该数组元素都是double
(3) double(f[10])()
F是一个数组，f有十个元素，元素都是函数的指针，指向的函数类型是没有参数且返回double的函数
(4)int((b)[10])
就跟“int(b)[10]”是一样的，b是一维数组的指针
(5)long(fun)(int)
函数指针
(6)int((f)(int,int))(int)
F是一个函数的指针，指向的函数的类型是有两个int参数并且返回一个函数指针的函数，返回的函数指针指向一个int参数且返回int的'函数。
13. 指针数组与数组指针
指针数组，是指一个数组里面装着指针，数组指针，代表它是指针，指向真个数组
一个指向整型数组的指针定义为()
A. int(ptr)[] B.int ptr[] C.int(ptr[]) D.int ptr[]
int(ptr)[]是以一个指向整型数组的指针
int ptr[]是指针数组，ptr[]里面存的的是地址。它指向位置的值就是ptr[0],ptr[1],ptr[2]，不要存ptr[0]=5,ptr[1]=6,因为里面没有相应的地址
int(ptr[])与B相同
14. 用变量a给出下面的定义
(1)一个整型数
(2)一个指向整形数的指针
(3)一个指向指针的指针，它指向的指针是一个整型数
(4)一个有10个整型数的数组
(5)一个有10个指针的数组，该指针是指向一个整型数的
(6)一个指向有10个整型数组的指针
(7)一个指向函数的指针，该函数有一个整型参数并返回一个整型数
(8)一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整数
Itn a; int a; int a; int a[10]; int a[10]; int (a)[10]; int (a)(int); int (a[10])(int)
15.C++中的空类默认产生那些类成员函数?
Class Empty
{ public:
};
:对于一个空类,编译器默认产生4个成员函数:默认构造函数,析构函数,拷贝构造函数和赋值函数
16.那一种成员变量可以在同一个类的实例之间共享?
:必须使用静态成员变量在一个类的所有实例间共享数据.如果想限制对静态成员变量的访问,则必须把他们声明成保护型或私有型.不允许使用静态成员变量去存放一个对象的数据。静态成员数据是在这个类的所有对象间共享的。
静态数据成员：静态成员可以实现多个对象之间的数据共享，并且使用静态数据成员还不会破坏隐藏的原则，即保证了安全性。节省内存;提高时间效率。使用静态数据成员可以因为它是所有对象所公有的，因此，对多个对象来说，静态数据成员只存储一处，供所有对象共用。静态数据成员的值对每个对象都是一样，但它的值是可以更新的。只要对静态数据成员的值更新一次，保证所有对象存取更新后的相同的值，
2、静态成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式如下：
<数据类型><类名>::<静态数据成员名>=<值>
这表明：
(1) 初始化在类体外进行，而前面不加static，以免与一般静态变量或对象相混淆。
(2) 初始化时不加该成员的访问权限控制符private，public等。
3、静态数据成员是静态存储的，它是静态生存期，必须对它进行初始化。
4、引用静态数据成员时，采用如下格式：
静态数据成员的访问权限允许的话(即public的成员)，可在程序中，按上述格式来引用静态数据成员。
下面举一例子，说明静态数据成员的应用：
#include
class Myclass
void GetNumber();
void GetSum();
int A, B, C;
static int Sum;
};
int Myclass::Sum = 0;
Myclass::Myclass(int a, int b, int c)
{A = a;
B = b;
C = c;
Sum += A+B+C;
}void Myclass::GetNumber()
void Myclass::GetSum()
{cout<<”Sum=”< }
void main()
M.GetNumber();
N.GetNumber();
M.GetSum();
N.GetSum();
}从输出结果可以看到Sum的值对M对象和对N对象都是相等的。这是因为在初始化M对象时，将M对象的三个int型数据成员的值求和后赋给了Sum，于是Sum保存了该值。在初始化N对象时，对将N对象的三个int型数据成员的值求和后又加到Sum已有的值上，于是Sum将保存另后的值。所以，不论是通过对象M还是通过对象N来引用的值都是一样的，即为54。
静态成员函数
静态成员函数和静态数据成员一样，它们都属于类的静态成员，它们都不是对象成员。因此，对静态成员的引用不需要用对象名。
在静态成员函数的实现中不能直接引用类中说明的非静态成员，可以引用类中说明的静态成员。如果静态成员函数中要引用非静态成员时，可通过对象来引用。下面通过例子来说明这一点。
#include
class M
M(int a) { A=a; B+=a;}
static void f1(M m);
int A;
static int B;
};
void M::f1(M m)
{cout<<”A=”< cout<<”B=”< }
int M::B=0;
void main()
M::f1(P); file://调用时不用对象名
M::f1(Q);
}读者可以自行分析其结果。从中可看出，调用静态成员函数使用如下格式：
<类名>::<静态成员函数名>(<参数表>);
17.判断选择
1. C++语言没有可移植性。 B不正确
2. 定义数组时可以不确定元素个数。 B不正确
3. 指针是一种特殊的变量，只能用来保存地址。 A正确
4. 通过引用或者指针调用对象的成员函数时，如果引用或者指针的类型跟对象的类型不一致时，能自动正确调用对象所属的类中对这个函数的定义。 B不正确
5.类myclass，为myclass类对象以成员函数形式重载后++运算符的声明应该为 C myclass operator++( int );
A. myclass operator++();
B. myclass& operator++();
C. D. myclass& operator++( int );
5. 父类和子类各自定义一个成员函数，函数名相同，参数表不同，那么 C子类中的函数会覆盖父类中的函数。 函数同名,通通覆盖,不同层次的函数不能重载
myclass obj = 100;会 B调用整型参数的构造函数。等价于 myclass obj = myclass(100)
7. 抽象类指的是 D有纯虚函数的类
8. 多重继承时，如果派生类的两个父类有一个共同的虚基类，那么虚基类的初始化参数由 C派生类
的构造函数来传递。
9. 多态性是通过 C虚函数 实现的。
10. 如果有如下语句
char str[20];
cin >> str;
cout << str;
执行时输入的是“this is a test line!”，则输出的内容是 D 。
A. this is a test line!
B. this is a test line
C. this is a test
D. this
11. 执行语句
char ch[] = “Hello”;
char p = &ch[0];
cout << p;
结果是输出 C 。Hello
18.以下生面是否正确?
：常量必须在构造函数的初始化列表里面初始化或者将其设置为static
正确的程序如下：
Class A
{ A(){ const int size=0; }};
Class A
{ static const int size=0; };
;
有关sizeof与继承，虚继承的问题
sizeof(A) + sizeof(B) + sizeof(class_ptr)
class_ptr即类指针，指向virtual说明的虚基类列表
Myclass(int a, int b, int c);注意，这里面存在内存对齐规则
个代码：
sizeof(A) + sizeof(B) + sizeof(class_ptr) = 1 + 1 + 4, 对齐，得到8
第二个代码：
sizeof(A) + sizeof(B) = sizeof(vptr) + sizeof(当我们定义一个派生类对象d后，其d的成员存放为：vptr) = 4 + 4 = 8,虚函数表指针
第三个代码：
sizeof(A) + sizeof(B) + sizeof(class_ptr) = 4 + 4 + 4 = 12
就是在第二个的基础上多了一个class_ptr，无论多少个类，都只有一个class_ptr指向这一系列的virtual class。
你看看这个帖子吧，里面说的很详细
c/c++继承的问题?
1、静态数据成员在定义或说明时前面加关键字static。如果你再定义一个类
{cout<D()
{cout<<"D = "< }}; 然后再main函数中 void main() {D d; }运行，可以得到结果 如果去掉了virtual，程序会出错，显示a的定义有歧义。 这是因为，当B、C虚继承A类，则A为D类的虚基类，D的成员变量a就是A类所定义的，对象d在构造时只需要分配给四个字节的空间给整型变量a，如果B、C不是虚继承，则D继承自B、C，分别继承了这两个类的成员变量，而且都是a，那么，编译器就应该给对象d分配两个四字节空间来存储这两个a，不仅增加了冗余，而且两个成员变量取同一个名字也是不可想象的，程序就报错了 class B :virtual public A 表示 B虚继承 A 这种情况下 B不产生副本 // test7.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include using namespace std; class A //少 { void display() {cou(3) 初始化时使用作用域运算符来标明它所属类，静态数据成员是类的成员，而不是对象的成员。t<<"A::display()is called!"< }; //少 ; class B //少 { void display() {cout<<"B::display()is called!"< }}; class C: public A, public B {int a; C(int i=0){a=i;} void show(){ display();} //会产生二义性 }; {C obj; obj.display(); //会产生二义性 return 0; }/ 类C从基类A,B中都继承了display()函数，我感觉就算把基类A,B中的函数都声明为虚函数，也不能解决二义性的问题． 而且虚函数的声明，是为了产生个公共接口，实现多态性． 应该用虚继承来消除二义性．举个例子： class A //定义基类A void display(); }; class B:virtual public A //A为B的虚基类 {}; class C:virtual public A //A为C的虚基类 {}; class D:public B,public C //类D继承了类B,类C {}; //在主函数中定义个对象d,如果没有用到虚继承,就会产生二义性. int main() {D d; d.diplay() return 0; }/ #include class Point {double x,y; Point(double i,double j) {x=i;y=j;} virtual double Area() //加上关键字virtual }; {double w,h; Rectangle(double i,double j,double k,double l):Point(i,j) {w=k;h=l;} double Area(){return wh;} }; void fun (Point&s) {cout< }void main() {Rectangle rec(3.5,15.2,5,28); fun(rec); }/ 在class Point{};的Area()前加上关键字virtual 就能实现多态性了. 楼主学C++到了虚继承和虚函数了吧..多看看C++教程里的例题吧... / 你以为你是谁，考官？还是雇工头老板呐？ “在main函数中，要求创建一个Box类型的对象，并求出该对象的体积。” 还要求者要求那的，请问你是猪吗，还需要人喂饭吗？摆个破题还说是改错题 还“满意再加50”，给小费呢？ 那点破分，谁稀罕 #include using namespace std; class box {private: double length; double width; double height; double mvol; box(double x,double y,double z) {length=x; width=y; height=z; mvol=xyz; }void volume() {cout<<"length="<
声明：本站所有文章资源内容，如无特殊说明或标注，均为采集网络资源。如若本站内容侵犯了原著者的合法权益，可联系 836084111@qq.com 删除。
大家来给这个题改个错，c++高手进 100分，满意再加50
}-----------