一.多态是如何实现的
首先用文字叙述:
1.当类中声明虚函数时,编译器会在类中生成一个虚函数表
2.虚函数表是一个存储类成员函数指针的数据结构
3.虚函数表是由编译器自动生成与维护的
4.virtual成员函数会被编译器放入虚函数表中
5.当存在虚函数时,每个对象中都有一个指向虚函数的指针(C++编译器给父类对象,子类对象提前布局vptr指针),当进行test(parent *base)函数的时候,C++编译器不需要区分子类或者父类对象,只需要再base指针中,找到vptr指针即可)
6.vptr一般作为类对象的第一个成员
下来根据代码分析:
class parent
{
public:
virtual void fun()
{
cout << "我是父类..." << endl;
}
};
class child:public parent
{
public:
virtual void fun()
{
cout << "我是子类..." << endl;
}
};
void test(parent *base)//只需要根据对象中的vptr指针来找虚函数表,找函数入口地址,调用函数,实现多态,实现迟绑定效果
{
base->fun();
}
int main()
{
parent c1;//用类定义对象的时候,C++编译器会在对象中添加一个vptr指针
child c2;
test(&c1);
test(&c2);
system("pause");
return 0;
}
二.如何证明vptr指针的存在
测试加vitual的类和没有vitual类的大小看看是不是差四个字节。
三.构造函数中调用虚函数,能实现多态吗?
class parent
{
public:
parent(int a = 10)
{
this->a = a;
fun();//调用子类的fun函数还是父类的fun函数
}
virtual void fun()
{
cout << "我是父类..." << endl;
}
private:
int a;
};
class child:public parent
{
public:
child(int b = 20) :parent(15)
{
this->b = b;
}
virtual void fun()
{
cout << "我是子类..." << endl;
}
private:
int b;
};
int main()
{
child c2;//定义了一个子类对象调用父类构造函数,在父类构造函数中调用虚函数能发生多态吗?
system("pause");
return 0;
}
在这样试试:
class parent
{
public:
parent(int a = 10)
{
this->a = a;
}
virtual void fun()
{
cout << "我是父类..." << endl;
}
private:
int a;
};
class child:public parent
{
public:
child(int b = 20) :parent(15)
{
this->b = b;
fun();//调用子类的fun函数还是父类的fun函数
}
virtual void fun()
{
cout << "我是子类..." << endl;
}
private:
int b;
};
int main()
{
child c2;//定义了一个子类对象调用父类构造函数,在父类构造函数中调用虚函数能发生多态吗?
system("pause");
return 0;
}
但是很明显没有发生多态现象~
为什么呢。这就涉及到了vpt指针的初始化,因为vptr指针是分步初始化的,接下来我画图说明
四.父类指针和子类指针步长问题?
首先,我们来看如下代码:
class parent
{
public:
parent(int a = 10)
{
this->a = a;
}
virtual void fun()
{
cout << "我是父类..." << endl;
}
private:
int a;
};
class child:public parent
{
public:
child(int b = 20) :parent(15)
{
//this->b = b;
}
virtual void fun()
{
cout << "我是子类..." << endl;
}
private:
//int b;
};
int main()
{
child c2;
parent *p1 = NULL;
child *p2 = NULL;
child arr[] = { child(1), child(2), child(3) };
p1 = arr;//父类指针指向arr
p2 = arr;//子类指针指向arr
p1->fun();
p2->fun();
p1++;
p2++;
p1->fun();
p2->fun();
system("pause");
return 0;
}
在执行过程中会出现什么问题呢?结果如下:
我们会发现程序崩溃了!这是为什么呢?
接下来我们再把child类里面的成员b屏蔽了,
class parent
{
public:
parent(int a = 10)
{
this->a = a;
}
virtual void fun()
{
cout << "我是父类..." << endl;
}
private:
int a;
};
class child:public parent
{
public:
child(int b = 20) :parent(15)
{
//this->b = b;
}
virtual void fun()
{
cout << "我是子类..." << endl;
}
private:
//int b;
};
int main()
{
child c2;
parent *p1 = NULL;
child *p2 = NULL;
child arr[] = { child(1), child(2), child(3) };
p1 = arr;//父类指针指向arr
p2 = arr;//子类指针指向arr
p1->fun();
p2->fun();
p1++;
p2++;
p1->fun();
p2->fun();
system("pause");
return 0;
}
再运行看结果:
这样就通过了,为什么呢?
这就是因为父类指针步长和子类步长不一样。
接下来我就画图解释一下: