1、什么是函数重写

　　函数重写分为 虚函数重写（会发生多态） 与 非虚函数重写（重定义的一种形式）； 

　　函数重写：也叫做覆盖。子类重新定义父类中有相同返回值、名称和参数的虚函数。函数特征相同。但是具体实现不同，主要是在继承关系中出现的 。

　　注：一般而言，函数重写 就是 虚函数重写，为的是实现多态调用； 

2、函数重写的条件

　　1. 函数的返回类型、方法名、参数列表完全相同；

　　2. 必须发生在不同的作用域中（基类与派生类中）；

　　3. 基类中有 virtual 关键字声明，派生类中可有可无，不能有 static （虚函数重写）；

3、函数重写的意义

　　在面向对象的继承关系中，我们了解到子类可以拥有父类中的所有属性与行为；但是，有时父类中提供的方法并不能满足现有的需求，所以，我们必须在子类中重写父类中已有的方法，来满足当前的需求。

1、什么是函数重定义

　　子类重新定义父类中有相同名称的函数 ( 不包括虚函数重写 ) 。

2、重定义的表现形式

　　1. 必须发生在不同的作用域中（基类与派生类中）；

　　2. 函数名相同；

　　3. 返回值可以不同；

　　4. 参数列表不同，此时，无论基类中的同名函数有无 virtual 关键字，基类中的同名函数都会被隐藏。

　　5. 参数列表相同，此时，基类中的同名函数没有 virtual 关键字，则基类中的同名函数将会被隐藏 --- 非虚函数重写 。

3、关于同名覆盖的结论（归纳：基类与派生类中存在同名成员；--- 同名覆盖）

　　1. 子类将隐藏父类中的同名成员；

　　2. 父类中的同名成员依然存在于子类中；

　　3. 可以通过作用域分辨符(::)访问被隐藏的父类中的同名成员；

　　4. 不可以直接通过子类对象访问父类成员；

　　　注：同名覆盖规则适用于类的成员变量与成员函数；

　　相关代码展示：

 1 #include <iostream>
 2 #include <string>
 4 using namespace std;
 6 class Parent
 8 public:
 9     int mi;
11     Parent()
12     {
13         cout << "Parent() : " << "&mi = " << &mi << endl;
14     }
15 };
17 class Child : public Parent
18 {
19 public:
20     int mi;
22     Child()
23     {
24         cout << "Child() : " << "&mi = " << &mi << endl;
25     }
26 };
28 int main()
29 {
30     Child c;
32     c.mi = 100;    
34     c.Parent::mi = 1000;
36     cout << "&c.mi = " << &c.mi << endl;
37     cout << "c.mi = " << c.mi << endl;
39     cout << "&c.Parent::mi = " << &c.Parent::mi << endl;
40     cout << "c.Parent::mi = " << c.Parent::mi << endl;
42     return 0;
43 }
45 /**
46 * Parent() : &mi = 0x7ffe98191450
47 * Child() : &mi = 0x7ffe98191454
48 * &c.mi = 0x7ffe98191454
49 * c.mi = 100
50 * &c.Parent::mi = 0x7ffe98191450
51 * c.Parent::mi = 1000
52 */

 1 #include <iostream>
 2 #include <string>
 4 using namespace std;
 6 class Parent
 8 public:
 9     int mi;
11     void add(int v)
12     {
13         mi += v;
14     }
16     void add(int a, int b)
17     {
18         mi += (a + b);
19     }
20 };
22 class Child : public Parent
23 {
24 public:
25     int mi;
27     void add(int v)
28     {
29         mi += v;
30     }
32     void add(int a, int b)
33     {
34         mi += (a + b);
35     }
37     void add(int x, int y, int z)
38     {
39         mi += (x + y + z);
40     }
41 };
43 int main()
44 {
45     Child c;
47     c.mi = 100;        
48     c.Parent::mi = 1000;
50     cout << "c.mi = " << c.mi << endl;    
51     cout << "c.Parent::mi = " << c.Parent::mi << endl;
53     c.add(1);
54     c.add(2, 3);
55     c.add(4, 5, 6);
56     c.Parent::add(10);
57     c.Parent::add(11, 12);
59     cout << "c.mi = " << c.mi << endl;    
60     cout << "c.Parent::mi = " << c.Parent::mi << endl;
62     return 0;
63 }
64 /**
65 * c.mi = 100
66 * c.Parent::mi = 1000
67 * c.mi = 121
68 * c.Parent::mi = 1033
69 */