内存角度探寻C++面向对象 之 继承、多态

一,简单继承:

#include <iostream>

class TableTennisPlayer
{
private:
int id;
public:
TableTennisPlayer(int id);
void sayHi();
}; TableTennisPlayer::TableTennisPlayer(int n)
{
id = n;
} void TableTennisPlayer::sayHi()
{
std::cout << "Hi,I am player" << id << std::endl;
} class MasterPlayer :public TableTennisPlayer
{
private:
int id;
public:
MasterPlayer(int id);
void fuck();
}; MasterPlayer::MasterPlayer(int n) :TableTennisPlayer(n)
{
id = n;
} void MasterPlayer::fuck()
{
std::cout << "fuck you" << std::endl;
} int main(void)
{
using std::cout;
using std::cin;
TableTennisPlayer player(1);
MasterPlayer master(2);
player.sayHi();
master.sayHi();
master.fuck();
cout << sizeof(player) << std::endl;
cout << sizeof(master) << std::endl;
cin.get();
}

父类成员变量id在构造函数初始化。

子类也有成员变量id,在子类构造函数初始化。

反汇编代码看出,子类构造函数初始化子类时首先调用父类构造函数初始化父类--具体是初始化父类成员变量。

所以:

这是父类在内存中的存储 00 00 00 01 占4字节

内存角度探寻C++面向对象 之 继承、多态

这是子类在父类的存储:

00 00 00 02 00 00 00 02  占8字节,前四字节是父类成员变量,后四字节是子类成员变量

内存角度探寻C++面向对象 之 继承、多态

由此看出,子类对父类是包含关系。具体是指包含父类成员变量。另外,构造函数没什么特殊的。其实就是类建立时自动调用的函数。去初始化类成员,也就是为成员变量申请内存。子类初始化,先调用父类构造方法初始化,父类成员变量。然后调用自己的,初始化自己成员变量。

二,虚函数

由于C++中存在指针的概念。所以,必须引出虚函数。这一点你如果不从内存角度思考,去真正理解C++中对象、以及指向对象的指针的概念是什么,你是无法真正理解虚函数的!!!

如果一个指针指向子类。那么:

#include<iostream>
using namespace std;
class A
{
public:
void print()
{
cout<<"This is A"<<endl;
}
}; class B : public A
{
public:
void print()
{
cout<<"This is B"<<endl;
}
}; int main()
{
A a;
B b;
a.print();
b.print();
return ;
}

运行结果:指向子类的指针,调用的却是父类的print函数。

这便是引入虚函数概念的原因:

#include<iostream>
using namespace std;
class A
{
private:
int a = ;
public:
virtual void print()
{
cout << "This is A" << endl;
}
}; class B : public A
{
private:
int b = ;
public:
virtual void print()
{
cout << "This is B" << endl;
}
}; class C : public B
{
private:
int c = ;
public:
virtual void print()
{
cout << "This is C" << endl;
}
}; int main()
{
A a;
B b;
C c;
A *p1 = &a;
A *p2 = &b;
A *p3 = &c;
p1->print();
p2->print();
p3->print();
cin.get();
return ;
}

内存角度探寻C++面向对象 之 继承、多态

所以利用指针来操作的话,虽然调用的是指向子对象的指针,其实那里存储的是子对象里包含着的父对象的空间。

加上virtual修饰符后,则是完全另一种结果。

带有虚函数的对象是另外一种初始化方式:在构造函数中会将this指针指向虚函数表(对象内存地址里首先保存的是虚函数表)。

也就是说:带有虚函数的对象,对象地址首先保存的是,指向虚函数表的指针(地址),然后才是类成员变量。

子类继承了,带有虚函数的父类。对象地址首先保存的是,指向虚函数表的指针(地址),然后是父类成员变量,然后才是子类成员变量。

三、多重继承

继续上面的例子,C继承B,B继承A(A为虚函数)。那么C在内存中是什么样子呢?前四个字节是虚函数表指针,然后是A类成员变量,然后是B类成员变量,最后才是自己的成员变量。

四、多继承

如下代码所示,类C继承类B、类A

#include<iostream>
using namespace std;
class A
{
private:
int a = ;
public:
virtual void print()
{
cout << "This is A" << endl;
}
}; class B
{
private:
int b = ;
public:
virtual void print()
{
cout << "This is B" << endl;
}
}; class C : public B,public A
{
private:
int c = ;
public:
virtual void print()
{
cout << "This is C" << endl;
}
}; int main()
{
C c;
A *p = &c;
p->print();
cin.get();
return ;
}

内存角度探寻C++面向对象 之 继承、多态

由反汇编结果可知,内存中存储结果为:指向虚函数表的指针、类B成员变量、指向虚函数表的指针、类A成员变量、最后是自己的成员变量。

五,总结

由上面几个例子可以知道。

1 C++为了实现面向对象语言中的“向上转型”,特别引入了虚函数的概念。为何如此?因为C++有指针!!!!!!

Java是不需要的,因为java没有指针。

2 虚函数表具体是什么样的?具体可以看这篇博客:http://blog.csdn.net/haoel/article/details/1948051/内存角度探寻C++面向对象 之 继承、多态

类似这张图,虚函数表中,父类的虚函数在子类虚函数前面。

上一篇:jQuery全选反选实例


下一篇:jquery全选 反选