重载

• 必须是在一个作用域，函数名相同，参数不同（个数不同，类型不同），才会构成函数重载

// add 函数构成了重载
int add(int a, int b)
{
	cout << "add_int_int" << endl;
	return a + b;
}

int add(double a, int b)
{
	cout << "add_double_int" << endl;
	return a + b;
}

int main()
{
	int x = add(1, 1);
	int y = add(1.0, 2);
	return 0;
}

为什么C++支持重载，而C语言不支持呢？

假设某个C 函数的声明如下：

void foo(int x, int y);

该函数被C 编译器编译后在库中的名字为_foo，而C++编译器则会产生像_foo_int_int 之类的名字用来支持函数重载和类型安全连接。

隐藏（重定义）

1. 在继承体系中基类和派生类都有独立的作用域。

2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏， 也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）

3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。

4. 注意在实际中在继承体系里面最好不要定义同名的成员。

// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆
class Person
{
protected:
	string _name = "小李子"; // 姓名
	int _num = 111;    // 身份证号
};

class Student : public Person
{
public:
	void Print()
	{
		cout << " 姓名:" << _name << endl;
		cout << " 身份证号:" << Person::_num << endl;
		cout << " 学号:" << _num << endl;
	}
protected:
	int _num = 999; // 学号
};

void Test()
{
	Student s1;
	s1.Print();
};

int main()
{
	Test();
	return 0;
}

// B中的fun和A中的fun不是构成重载，因为不是在同一作用域
// B中的fun和A中的fun构成隐藏，成员函数满足函数名相同就构成隐藏。
class A
{
public:
	void fun()
	{
		cout << "func()" << endl;
	}
};

class B : public A
{
public:
	void fun(int i)
	{
		A::fun();
		cout << "func(int i)->" << i << endl;
	}
};

void Test()
{
	B b;
	b.fun(10);
};

int main()
{
	Test();
	return 0;
}

多态：

继承中要构成多态还有两个条件：

1. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写
2. 必须通过基类的指针或者引用调用虚函数

虚函数：即被virtual修饰的类成员函数称为虚函数。

重写（覆盖）

• 只要虚函数才能重写

• 派生类中有一个跟基类完全相同的虚函数（即派生类虚函数与基类虚函数的 返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。

class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};

class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }

	/*注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因
   为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),但是该种写法不是很规范，不建议
   这样使用*/

   /*void BuyTicket() { cout << "买票-半价" << endl; }*/
};

void Func(Person& p)
{
	p.BuyTicket();
}

int main()
{
	Person ps;
	Student st;

	Func(ps);
	Func(st);
	return 0;
}

虚函数重写的两个例外：

1. 协变（基类与派生类虚函数返回值类型不同） （了解）

   派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指 针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。

   class A{};
   
   class B : public A {};
   
   class Person {
   
   public:
    virtual A* f() {return new A;}
   };
   
   class Student : public Person {
   
   public:
    virtual B* f() {return new B;}
   };
   

2. 析构函数的重写（基类与派生类析构函数的名字不同）

   编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

   class Person {
   public:
   	virtual ~Person() { cout << "~Person()" << endl; }
   };
   
   class Student : public Person {
   public:
   	virtual ~Student() { cout << "~Student()" << endl; }
   };
   
   /* 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函数，
   才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。*/
   
   int main()
   {
   	Person* p1 = new Person;
   	Person* p2 = new Student;
   	delete p1;
   	delete p2;
   	return 0;
   }
   

三者的区别

没有构成重写就是重定义