C++ 覆盖方法和重载方法

/*
	关于从基类继承来的方法和属性的保护：
	class Pig:public Animal{....}
	
	C++不仅允许你对在类里定义的方法和属性实施访问控制，
	还允许你控制子类可以访问基类里的那些方法和属性
	
	public:
	是在告诉编译器：
	继承的方法和属性的访问级别不发生任何改变
	public 仍可以被所有代码访问
	protected 只能由基类的子类访问
	private 只能由基类本身访问
	
	protected:
	把基类的访问级别改为protected
	如果原来是public的话，
	这将使得这个子类外部的代码无法通过子类去
	访问基类中的public
	
	private：
	是在告诉编译器从基类继承来的每一个成员都当成
	private来对待
	这意味着这只有这个子类可以使用它从基类继承来的元素 

*/ 

/*
	覆盖方法 overriding 
	C++ 可以让我们很容易实现这种
	既有共同特征又需要在不同的类里有不同实现的方法。
    我们需要做的是在类里重新声明这个方法，然后再改
	写一下它的实现代码（就像它是一个增加的方法那样）就行啦。


	重载方法：
	
	简化编程工作和提高代码可读性
	的另一种方法：重载
	
	重载机制使你可以定义多个同名的方法（函数）
	只是他们的输入参数必须不同
	（因为编译器是依靠不同的输入参数来区别不同的方法的） 
	
	重载并不是一个真正的面向对象的特性，
	他只是以简化编程工作的捷径
	而简化编程工作正是C++的全部追求 
	
	 
	 
*/ 

//覆盖方法 
//为我们的 Animal 添加 eat（）方法，
//并在Pig 和 Turtle 中覆盖

/*
#include <iostream>
#include <string>

class Animal
{
public:
    Animal(std::string theName);
    void eat();
    void sleep();
    void drool();

protected:
    std::string name;
};

class Pig : public Animal
{
public:
    Pig(std::string theName);
    void climb();
    void eat();                     // new!
};

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

Animal::Animal(std::string theName)
{
    name = theName;
}

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

void Animal::sleep()
{
    std::cout << "I'm sleeping!Don't disturb me!\n" << std::endl;
}

void Animal::drool()
{
    std::cout << "我是公的，看到母的我会流口水，我正在流口水。。。\n" << std::endl;
}

Pig::Pig(std::string theName) : Animal(theName)
{
}

void Pig::climb()
{
    std::cout << "我是一个只漂亮的小母猪猪，我会上树，我正在爬树，嘘。。。\n" << std::endl;
}

void Pig::eat()
{
    Animal::eat();
    std::cout << name << "正在吃鱼!\n\n";         // new!
}

Turtle::Turtle(std::string theName) : Animal(theName)
{
}

void Turtle::swim()
{
    std::cout << "我是一只小甲鱼，当母猪想抓我的时候，我就游到海里。。哈哈。。\n" << std::endl;
}

void Turtle::eat()
{
    Animal::eat();
    std::cout << name << "正在吃东坡肉!\n\n";     // new!
}

int main()
{
    Pig pig("小猪猪");
    Turtle turtle("小甲鱼");

    // std::cout << "这只猪的名字是: " << pig.name << std::endl;                // 错误
    // std::cout << "每只乌龟都有个伟大的名字: " << turtle.name << std::endl;   // 错误

    pig.eat();
    turtle.eat();
    pig.climb();
    turtle.swim();

    return 0;
}
*/

//重载方法 
//对eat()方法进行重载

/* 
#include <iostream>
#include <string>

class Animal
{
public:
    Animal(std::string theName);
    void eat();
    //定义吃的数量实现重载 
    void eat(int eatCount);
    void sleep();
    void drool();

protected:
    std::string name;
};

class Pig : public Animal
{
public:
    Pig(std::string theName);
    void climb();
};

class Turtle : public Animal
{
public:
    Turtle(std::string theName);
    void swim();
};

Animal::Animal(std::string theName)
{
    name = theName;
}

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

//实现 重载 
void Animal::eat(int eatCount)
{
    std::cout << "我吃了" << eatCount << "碗馄饨!\n\n";
}

void Animal::sleep()
{
    std::cout << "I'm sleeping!Don't disturb me!\n" << std::endl;
}

void Animal::drool()
{
    std::cout << "我是公的，看到母的我会流口水，我正在流口水。。。\n" << std::endl;
}

Pig::Pig(std::string theName) : Animal(theName)
{
}

void Pig::climb()
{
    std::cout << "我是一个只漂亮的小母猪猪，我会上树，我正在爬树，嘘。。。\n" << std::endl;
}

Turtle::Turtle(std::string theName) : Animal(theName)
{
}

void Turtle::swim()
{
    std::cout << "我是一只小甲鱼，当母猪想抓我的时候，我就游到海里。。哈哈。。\n" << std::endl;
}

int main()
{
    Pig pig("小猪猪");
    Turtle turtle("小甲鱼");

    // std::cout << "这只猪的名字是: " << pig.name << std::endl;                // 错误
    // std::cout << "每只乌龟都有个伟大的名字: " << turtle.name << std::endl;   // 错误

    pig.eat();
    turtle.eat();

	//传入参数 进行调用 
    pig.eat(15);
    pig.climb();
    turtle.swim();

    return 0;
}
*/


//从基类继承来的方法进行重载，
//程序永远不会像你预期的那样工作！
#include <iostream>
#include <string>

class Animal
{
public:
    Animal(std::string theName);
    void eat();
    void sleep();
    void drool();

protected:
    std::string name;
};

class Pig : public Animal
{
public:
    Pig(std::string theName);
    void climb();
    //不可以重载基类的声明 
    void eat(int eatCount);
};

class Turtle : public Animal
{
public:
    Turtle(std::string theName);
    void swim();
};

Animal::Animal(std::string theName)
{
    name = theName;
}

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

void Animal::sleep()
{
    std::cout << "I'm sleeping!Don't disturb me!\n" << std::endl;
}

void Animal::drool()
{
    std::cout << "我是公的，看到母的我会流口水，我正在流口水。。。\n" << std::endl;
}

Pig::Pig(std::string theName) : Animal(theName)
{
}

void Pig::climb()
{
    std::cout << "我是一个只漂亮的小母猪猪，我会上树，我正在爬树，嘘。。。\n" << std::endl;
}

void Pig::eat(int eatCount)
{
    std::cout << "我吃了" << eatCount << "碗馄饨!\n\n";
}

Turtle::Turtle(std::string theName) : Animal(theName)
{
}

void Turtle::swim()
{
    std::cout << "我是一只小甲鱼，当母猪想抓我的时候，我就游到海里。。哈哈。。\n" << std::endl;
}

int main()
{
    Pig pig("小猪猪");
    Turtle turtle("小甲鱼");

    // std::cout << "这只猪的名字是: " << pig.name << std::endl;                // 错误
    // std::cout << "每只乌龟都有个伟大的名字: " << turtle.name << std::endl;   // 错误

    pig.eat();
    turtle.eat();

    pig.eat(15);
    pig.climb();
    turtle.swim();

    return 0;
}