覆盖 和 重载

一、覆盖（Override）

存在于继承体系中，函数名相同，参数列表（类型、个数、顺序）相同，返回类型相同，函数体不同

在基类中提供一个通用的函数，在他的某个子类里修改这个方法的实现。

#include <iostream>
#include <string>
//父类 
class Animal
{
public:
    std::string name;
    Animal(std::string theName);  
protected:	    
	void eat(); //!!!
};
//子类 
class Pig : public Animal
{
public:
	Pig(std::string theName); 
    void climb();
    void eat();//!!!
};

 class Fish : public Animal
{
public:
	Fish(std::string theName); 
    void swim();
    void eat(); //!!!

};

//父类有参构造函数定义 
Animal::Animal(std::string theName)
{ 
name = theName;
} 

//Pig子类有参构造函数定义 
Pig::Pig(std::string theName) : Animal(theName) 
{ 
}

//Fish子类有参构造函数定义 
Fish::Fish(std::string theName) : Animal(theName)  
{ 
}

void Animal::eat()
{
    std::cout << "I'm eatting!" << std::endl;
}

void Pig::eat()
{	
	Animal::eat(); 
	std::cout << name<<"猪吃!" << std::endl;
}
void Fish::eat()
{
	Animal::eat(); 
	std::cout << name<<"鱼吃!" << std::endl;
}

int main()
{
	Pig pig("A");
	Fish fish("B");
    
    pig.eat();
    fish.eat();
    return 0;
}

 

二、重载（Overload）

• 在同一作用域内（如同一个类中），函数名相同，参数列表不同（参数的类型、个数或顺序不同）的函数，这些函数可实现不同的功能。重载与函数的返回类型无关。
• 编译器是依靠不同的输入参数来区分不同的方法

// 重载示例1
class OverloadExample {
public:
    int func(int a) { return a; }
    double func(double a) { return a; }
};



// 函数重载示例2
class Calculator {
public:
    // 计算两个整数的和
    int add(int a, int b) {
        return a + b;
    }

    // 计算两个浮点数的和
    double add(double a, double b) {
        return a + b;
    }
};

三、覆盖鱼重载的区别 

比较项	重载（Overload）	覆盖（Override）
作用域	同一作用域（如同一个类中）	不同作用域（基类和派生类之间）
函数名	相同	相同
参数列表	不同（类型、个数或顺序不同）	相同
返回类型	可以不同，但不能仅靠返回类型区分重载函数	相同（协变返回类型除外）
关键字	无特殊关键字	建议使用 override 关键字明确表示覆盖
调用方式	根据调用时的参数类型和个数来决定调用哪个函数	通过基类指针或引用调用时，根据对象的实际类型来决定调用哪个函数
与继承的关系	不依赖继承	依赖继承，是继承体系中的一种多态实现方式

---

未完待续。。。