C++ 学习7 1.1 析构函数（destructor) 析构函数是在销毁对象时自动调用，作用是完成对象的清理工作，例如

1.1 析构函数（destructor)

析构函数是在销毁对象时自动调用，作用是完成对象的清理工作，例如释放动态分配的内存、关闭文件等。清理内存等。同样适用于栈和堆分配的对象。
当你用new分配一个对象，调用delete，析构函数会调用。
在C++中，析构函数的名称与类名相同，前面加上波浪线（~）。它没有参数和返回值，并且只能有一个析构函数。

需要注意的是，当对象被显式地删除（delete）时，会先调用析构函数，然后再释放对象占用的内存。同样地，当对象是通过new运算符动态创建的，需要手动使用delete来释放对象的内存，确保析构函数能够被调用。

因为是栈分配（对象在栈上创建，超出作用域，自动销毁），只有当主函数退出时，析构函数才会被调用。作用：避免人清理不足，出现内存泄漏。

如果是在堆上分配对象，需要手动清理。

1.2 C++的继承（inheritance)

定义：C++中的继承是一种面向对象编程的重要概念，允许一个类（称为_派生类_或子类）从另一个类（称为基类或父类）继承属性和行为。通过继承，子类可以使用父类已定义的成员变量和成员函数，并且可以扩展或修改它们。

补充词汇： Inheritance - 继承 Base class - 基类 Derived class - 派生类 Superclass - 超类 Subclass - 子类 Public inheritance - 公有继承 Protected inheritance - 保护继承 Private inheritance - 私有继承 Member variable - 成员变量 Member function - 成员函数 Override - 覆盖 Access level - 访问级别 Code reuse - 代码重用 Polymorphism - 多态性 Modular - 模块化的 Extensible - 可扩展的 Constructor - 构造函数 Destructor - 析构函数

#include <iostream>
class Entity
{
public:
   float X,Y;
   void Move(float xa,float ya)
   {
      X += xa;
      Y += ya;
   }
};

class Player : public Entity
{
   public:
      const char* Name;
   void PrintName()
   {
      std::cout << Name << std::endl;
   }
};

int main()
{
   std::cout << sizeof(Entity) << std::endl;
   std::cout << sizeof(Player) << std::endl;
   Player player;
   player.Move(5,5);
   player.X = 2;
   player.Y = 3;


   std::cin.get();
}

结果：

1.3 虚函数（Virtual function)

虚函数是面向对象编程中的一个重要概念，它用于实现运行时多态性（runtime polymorphism）。在基类中声明为虚函数的成员函数，可以在派生类中进行重写，并且在运行时根据对象的实际类型来调用相应的函数。
在C++中，通过在基类中将需要实现多态性的成员函数声明为virtual，可以使其成为虚函数。派生类可以对虚函数进行重写，而且可以根据需要进行动态绑定。

#include <iostream>
#include <string>

class Entity
{
public:
   virtual std::string GetName() { return "Entity";}
   //虚函数player类也可用了
};

class Player : public Entity
{
private:
   std::string m_Name;
public:
   Player(const std::string& name)
      : m_Name(name) {}

   std::string GetName(){return m_Name;}
};

void PrintName(Entity* entity)
{
   std::cout << entity->GetName() << std::endl;
}

int main()
{
   Entity* e = new Entity();
   PrintName(e);
   //std::cout << e->GetName() << std::endl;

   Player* p = new Player("yameng");
   PrintName(p);//函数在类内部起作用

   delete e;
   delete p;
   std::cin.get();
}

结果：

 #include <iostream>

class Animal
{
public:
   virtual void MakeSound()
   {
      std::cout << "Animal makes a sound!" << std::endl;
   }
};

class Dog:public Animal
{
public:
   void MakeSound() override
   {
      std::cout << "dog barks" << std::endl;
   }
};

class Cat:public Animal
{
public:
   void MakeSound() override
   {
      std::cout << "cat memos" << std::endl;
   }
};

int main()
{
    Animal* animal1 = new Dog();
    Animal* animal2 = new Cat();

    animal1->MakeSound(); // Dog barks!
    animal2->MakeSound(); // Cat meows!

    delete animal1;
    delete animal2;

    return 0;
}

结果：