//简单版，全功能版在后面
#include <iostream>
#include <string>

// 基类 Animal
class Animal {
protected:
	std::string name; // 动物的名字
public:
	// 构造函数
	Animal(const std::string& n) : name(n) {}
	// 打印动物名字的函数
	virtual void printName() const {
		std::cout << "动物的名字是： " << name << std::endl;
	}
	// 动物通常有叫的功能
	virtual void makeSound() const {
		std::cout << "动物在叫：汪汪汪" << std::endl;
	}
	// 析构函数
	virtual ~Animal() {}
};

// 派生类 Human
class Human : public Animal {
public:
	// 构造函数
	Human(const std::string& n) : Animal(n) {}

	//重写父类的printName()函数，输出人类的名字
	void printName() const override{
		std::cout << "人的名字是： " << name << std::endl;
	}
	
	// 人类特有的行为：说话
	void speak() const {
		std::cout << "人类在说话：你好" << std::endl;
	}

	// 重写父类的 makeSound 函数
	// 人类也有叫的功能，但叫声与动物不同
	void makeSound() const override {
		std::cout << "人类在叫：啊啊啊" << std::endl;
	}

	// 析构函数
	~Human() override {}
};

int main() {
	// 创建一个动物对象
	Animal* a = new Animal("小狗");
	a->printName();
	a->makeSound();

	// 创建一个人类对象
	Human* h = new Human("小明");
	h->printName();
	h->makeSound();
	h->speak();

	// 清理内存
	delete a;
	delete h;

	return 0;
}

#include<iostream>
#include<string>
using namespace std;
class Person {
public:
	string name;
	int age,id;
public:
	void show(){
		cout<<"[name="<<name<<",age="<<age<<",id="<<id<<"]"<<endl;
	}
};
int main() {
	Person p= {"zhangfs",12,1};
	p.show();
	return 0;
}
/*
1.类的一个特征就是封装，public和private作用就是实现这一目的。所以：
用户代码（类外）可以访问public成员而不能访问private成员；private成员只能由类成员（类内）和友元访问。
2.类的另一个特征就是继承，protected的作用就是实现这一目的。所以：
protected成员可以被派生类对象访问，不能被用户代码（类外）访问。
3.深入理解C++中public、protected及private用法，访问以下链接
https://zhuanlan.zhihu.com/p/70758317
*/

//全功能版
#include <iostream>
#include <string>
using namespace std; 
// 一、类是一个蓝图，用于创建具有相似特征和行为的对象
class Animal { //创建动物类Animal
	protected:    // 受保护成员 - 只有自己和子类可以访问
	string name; // 动物的名字
	private:      // 私有成员 - 外部不能直接访问
	int age;  // 动物的年龄
	public:       // 公有成员 - 外部可以访问
	// 构造函数 - 创建对象时自动调用
	Animal(const string& n, int a) : name(n), age(a) {
		cout << "创建了一个Animal对象，名字：" << name << endl;
	}
	
	//二、理解成员函数（方法）
	// 1. 普通成员函数
	void introduce() const {
		cout << "我是一只动物，名字叫" << name << "，今年" << age << "岁" << endl;
	}
	
	// 2. 虚函数 - 可以在子类中被重写（多态的基础）
	virtual void makeSound() const {
		cout << name << "在叫：汪汪汪" << endl;
	}
	
	//三、理解访问器（getter）和修改器（setter）
	// 获取名字
	string getName() const {
		return name;
	}
	
	// 设置名字
	void setName(const string& newName) {
		name = newName;
		cout << "动物改名为：" << name << endl;
	}
	
	// 获取年龄
	int getAge() const {
		return age;
	}
	
	// 四、理解析构函数 - 对象销毁时自动调用
	virtual ~Animal() {
		cout << "Animal对象" << name << "被销毁" << endl;
	}
};

// 五、理解继承 - Human继承自Animal
class Human : public Animal {//创建类 人类Human，Human继承自Animal
private:
	string occupation; // 人类特有的属性：职业
public:
	// 派生类构造函数 - 先调用基类构造函数
	Human(const string& n, int a, const string& occ) 
	: Animal(n, a), occupation(occ) {
		cout << "创建了一个Human对象，职业：" << occupation << endl;
	}
	
	//六、理解函数重写（override）
	void makeSound() const override {  //覆盖了父类的函数makeSound()
		cout << name << "在叫：啊啊啊" << endl;
	}
	
	// 七、理解派生类特有的功能
	void speak() const {
		cout << name << "在说话：你好！我是" << occupation << endl;
	}
	
	void work() const {
		cout << name << "正在工作：编程中..." << endl;
	}
	
	// 八、理解方法重载（同一个类中的同名函数，参数不同）
	void speak(const string& content) const {
		cout << name << "说：" << content << endl;
	}
	
	// 析构函数
	~Human() override {
		cout << "Human对象" << name << "被销毁" << endl;
	}
};

int main() {
	cout << "=== 面向对象编程基础教程 ===" << endl << endl;
	
	cout << "【第1部分：创建和使用对象】" << endl;
	cout << "------------------------" << endl;
	Animal dog("旺财", 3);
	dog.introduce();
	dog.makeSound();
	
	cout << "\n【第2部分：使用getter和setter】" << endl;
	cout << "------------------------" << endl;
	cout << "当前名字：" << dog.getName() << endl;
	dog.setName("小黄");
	cout << "修改后名字：" << dog.getName() << endl;
	
	cout << "\n【第3部分：继承和多态】" << endl;
	cout << "------------------------" << endl;
	Human xiaoming("小明", 20, "程序员");
	xiaoming.introduce();  // 继承自Animal的方法
	xiaoming.makeSound();  // 重写的方法
	xiaoming.speak();      // Human特有的方法
	xiaoming.work();
	
	cout << "\n【第4部分：方法重载】" << endl;
	cout << "------------------------" << endl;
	xiaoming.speak("今天天气真好！");
	
	cout << "\n【第5部分：使用指针和动态内存】" << endl;
	cout << "------------------------" << endl;
	Animal* animalPtr = new Animal("小猫", 2);
	Human* humanPtr = new Human("小红", 18, "学生");
	
	cout << "\n【第6部分：多态演示】" << endl;
	cout << "------------------------" << endl;
	// 使用基类指针指向派生类对象
	Animal* ptr = humanPtr;
	cout << "通过基类指针调用makeSound()：" << endl;
	ptr->makeSound();  // 调用的是Human版本的makeSound
	
	cout << "\n【第7部分：清理内存】" << endl;
	cout << "------------------------" << endl;
	delete animalPtr;
	delete humanPtr;
	
	cout << "\n=== 程序结束，自动调用析构函数 ===" << endl;
	// dog和xiaoming对象会在main函数结束时自动销毁
	
	return 0;
}