一、函数的重写
什么叫函数的重写呢？在子类中和在父类中定义的函数类型是一样的就叫做函数的重写，注意这里的函数重写和函数重载的区别。
问题的引入：那么如果发生了函数的重写那该怎么办，编译器是如何解析的呢？
要想解决这个问题，那么我们首先得搞清楚到底什么是函数重写，下面举例说明：
1.在子类中定义与父类中原型相同的函数
2.函数重写只发生在父类与子类之间
#include <iostream>
using namespace std;
class Parent
{
public:
void print()
{
cout<<"voidParent::print() ... "<<endl;
}
};
class Child: public Parent
{
public:
void print()
{
cout<<"voidChild::print() ... "<<endl;
}
};
int main(int argc, char **argv)
{
Childchild;
child.print();
child.Parent::print();
cin.get();
return0;
}
上述实例打印的内容:
void Child::print() ...
void Parent::print() ...由此可得出结论:
1.父类中被重写的函数依然会继承给子类
2.默认情况下子类中重写的函数将隐藏父类中的函数
3.通过作用域分辨符::可以访问到父类中被隐藏的函数
二、现在已经明白了函数重写是怎么回事，那么现在开始第二个问题，当我们的函数重写遇到赋值兼容性原则又该怎么办呢？
比如下面的程序将输出什么内容呢
#include <iostream>
using namespace std;
class Parent
{
public:
void print()
{
cout<<"voidParent::print() ... "<<endl;
}
};
class Child:public Parent
{
public:
void print()
{
cout<<"voidChild::print() ... "<<endl;
}
};
int main(int argc, char **argv)
{
Childchild;
Parent parent;
Parent *P1 = &child;
Parent *P2 = &parent;
Parent& P3 = child;
Parent& P4 = parent;
P1->print();
P2->print();
P3.print();
P4.print();
cin.get();
return0;
}要想知道答案，我们还得了解编译器的行为:
1.C++与C相同，是静态编译型语言
2.在编译时，编译器自动根据指针的类型判断指向的是一个什么样的对象
3.所以编译器认为父类指针指向的是父类对象（根据赋值兼容性原则，这个假设合理）
4.由于程序没有运行，所以不可能知道父类指针指向的具体是父类对象还是子类对象
5.从程序安全的角度，编译器假设父类指针只指向父类对象，因此编译的结果为调用父类的成员函数
看了上面的描述，我想答案一目明了，出于安全性的考虑，那么输出结果就是:
void Parent::print() ... void Parent::print() ... void Parent::print() ... void Parent::print() ...
三、那么上面的结果使我们想要的么，我们明明赋值的是一个子类对象，但是指向的还是父类对象，那么解决方案又是什么呢？
我们需要的结果：
1.根据实际的对象类型来判断重写函数的调用
2.如果父类指针指向的是父类对象则调用父类中定义的函数
3.如果父类指针指向的是子类对象则调用子类中定义的重写函数
面向对象中的多态
1.根据实际的对象类型决定函数调用语句的具体调用目标
2.多态：同样的调用语句有多种不同的表现形态
|
那么，在C++中多态是如何实现的呢？下面来看多态的本质
1.C++中通过virtual关键字对多态进行支持
2.使用virtual声明的函数被重写后即可展现多态特性
没错，这就是传说中的虚函数
那么下面我们就对上述函数进行改进，如下：
#include <iostream>
using namespace std;
class Parent
{
public:
virtual void print()
{
cout<<"voidParent::print() ... "<<endl;
}
};
class Child:public Parent
{
public:
virtual void print()
{
cout<<"voidChild::print() ... "<<endl;
}
};
int main(int argc, char **argv)
{
Childchild;
Parent parent;
Parent *P1 = &child;
Parent *P2 = &parent;
Parent& P3 = child;
Parent& P4 = parent;
P1->print();
P2->print();
P3.print();
P4.print();
cin.get();
return0;
}
看看打印的内容：
void Child::print() ...
void Parent::print() ...
void Child::print() ...
void Parent::print() ...
这样就符合我们预期的要求了。
四、前面我们一直提到要区别开重载和重写的概念，那么重载和重写到底有什么区别呢？
下面先罗列出两者的区别：
函数重载
1.必须在同一个类中进行
2.子类无法重载父类的函数，父类同名函数将被覆盖
3.重载是在编译期间根据参数类型和个数决定调用函数
函数重写
1.必须发生于父类与子类之间
2.并且父类与子类中的函数必须有完全相同的原型
3.使用virtual声明之后能够产生多态
4.多态是在运行期间根据具体对象的类型决定调用函数
概念上陈述清楚了，那么看一个实例
#include <iostream>
using namespace std;
class Parent
{
public:
virtual void print()
{
cout<<"Parent::print() ... "<<endl;
}
virtual void print(int i)
{
cout<<"Parent::print(inti) ... "<<endl;
}
virtual void print(int i,int j)
{
cout<<"Parent::print(inti,int j) ... "<<endl;
}
};
class Child:public Parent
{
public:
virtual void print(int i,int j)
{
cout<<"Child::print(inti,int j) ... "<<endl;
}
virtual void print(int i,int j,int k)
{
cout<<"Child::print(inti,int j,int k) ... "<<endl;
}
};
int main(int argc, char **argv)
{
Child child;
child.print(1,2); //实现多态
child.print(1,2,3);//调用子类中的成员函数
child.print(1); //报错，因为父类成员函数被覆盖
cin.get();
return0;
}主函数里面解释的很清楚了，正是因为父类会被子类覆盖，而不会发生重载，所以报错。
五、关于多态的一些概念性的东西已经解释清楚了，下面就来深入了解虚函数，在C++中多态的实现原理
1.当类中声明虚函数时，编译器会在类中生成一个虚函数表
2.虚函数表是一个存储类虚成员函数指针的数据结构
3.虚函数表是由编译器自动生成与维护的
4.virtual成员函数会被编译器放入虚函数表中
5.存在虚函数时，每个对象中都有一个指向虚函数表的指针
这是一张虚函数表建立的模型图
毫无疑问：通过虚函数表指针VPTR调用重写函数是在程序运行时进行的，因此需要通过寻址操作才能确定真正应该调用的函数。而普通成员函数是在编译时就确定了调用的函数。在效率上，虚函数的效率要低很多。出于效率考虑，没有必要将所有成员函数都声明为虚函数。
现在又提出一个问题：对象中的VPTR指针什么时候被初始化？
1.对象在创建的时候由编译器对VPTR指针进行初始化
2.只有当对象的构造完全结束后VPTR的指向才最终确定
3.父类对象的VPTR指向父类虚函数表
4.子类对象的VPTR指向子类虚函数表
所以说：构造函数中调用虚函数无法实现多态。
这里自己一试便知，不再举例：
六、最后来看个纯虚函数
在项目经常用到虚函数和纯虚函数，那么到底是怎么回事呢？
面向对象中的抽象概念
在进行面向对象分析时，会有一些抽象的概念！也就是其实是不存在的概念，比如让你求一个图形的面积，但是却不告诉你什么图形，那该怎么求呢？这个对象的设计完全脱离实际，没有任何的意义！如下：
class Shape
{
public:
virtual double area() = 0;
};这就是纯虚函数的格式
那如何让他变得有意义呢？那么这就要在我们的继承类中对他进行实现，比如：
class Rectangle : public Shape
{
private:
double R_a;
double R_b;
public:
Rectangle(int a, int b)
{
R_a= a;
R_b= b;
}
virtual double area()
{
return( (R_a) * (R_b) );
}
};初步尝试纯虚函数的使用方法后，进行深一步了解纯虚函数
面向对象中的抽象类
1.抽象类可用于表示现实世界中的抽象概念
2.抽象类是一种只能定义类型，而不能产生对象的类
3.抽象类只能被继承并重写相关函数
4.抽象类的直接特征是纯虚函数
纯虚函数是只声明函数原型，而故意不定义函数体的虚函数。
抽象类与纯虚函数
1.抽象类不能用于定义对象
2.抽象类只能用于定义指针和引用
3.抽象中的纯虚函数必须被子类重写
上面的area是纯虚函数，= 0 告诉编译器，这个函数故意只声明不定义。
最后，我们看一个纯虚函数实现的例子:
#include <iostream>
using namespace std;
class Shape
{
public:
virtual double area() = 0;
};
class Rectangle : public Shape
{
private:
double R_a;
double R_b;
public:
Rectangle(int a, int b)
{
R_a= a;
R_b= b;
}
virtual double area()
{
return( (R_a) * (R_b) );
}
};
class Circle : public Shape
{
private:
double C_r;
public:
Rectangle(int r)
{
C_r= r;
}
virtual double area()
{
return( 3.14 *(C_r) * (C_r) );
}
};
void area(Shape* s)
{
cout<<s->area()<<endl;
}
int main(int argc, char **argv)
{
Rectanglerect(10, 5);
Circle circle(5);
cin.get();
return0;
}这也和我们上面所说的一定要咋子类中实现是一致的。
七、总结一下：
1.函数重写是面向对象中很可能发生的情形
2.函数重写只可能发生在父类与子类之间
3.需要根据实际对象的类型确定调用的具体函数
4.virtual关键字是C++中支持多态的唯一方式
5.被重写的虚函数即可表现出多态的特性
6.函数重载与函数重写不同
7.多态是通过虚函数表实现的
8.虚函数在效率上会受到影响
9.抽象类可用于表示现实世界中的抽象概念
10.抽象类是通过纯虚函数实现的
原文：http://blog.csdn.net/jxnu_xiaobing/article/details/39236475