c++ 入门——浅析构造函数和析构函数

关于“c++ 入门——浅析构造函数和析构函数”的攻略，我们可以分为以下三个部分来进行讲解：

一、构造函数

1.1 什么是构造函数

构造函数是一类特殊的成员函数，当我们创建类的新对象时，就会自动被调用。它的作用是初始化对象的成员变量。

class Test{
public:
  Test(int a, int b){
    x = a;
    y = b;
  }
private:
  int x, y;
};

在上述的代码中，Test 类中的构造函数被定义了，当我们创建一个新对象的时候可以使用这个构造函数来初始化 x 和 y 的值。

1.2 默认构造函数

如果我们没有定义任何构造函数，编译器就会自动为我们生成一个默认的构造函数，该函数不接受任何参数，也不执行任何操作。

class Test{
public:
  int x;
  int y;
};

在上述代码中，由于没有定义任何构造函数，编译器会自动生成一个默认的构造函数，该函数并没有做任何操作。

1.3 构造函数的重载

我们可以根据需要定义多个构造函数，这就是构造函数的重载。

class Test{
public:
  Test(){}
  Test(int a, int b){
    x = a;
    y = b;
  }
private:
  int x, y;
};

在上述代码中，我们定义了两个构造函数。第一个是空的构造函数，它接受一个没有参数的调用。第二个构造函数需要传入两个整型参数。

二、析构函数

2.1 什么是析构函数

析构函数是在对象被删除之前自动调用的函数，它的作用是释放对象使用的资源。

class Test{
public:
  Test(){}
  ~Test(){
    cout << "Object is destroyed" << endl;
  }
};

在上述代码中，我们定义了一个析构函数，当对象被删除时，析构函数会自动被调用。

2.2 虚析构函数

在使用继承实现多态时，当我们使用父类指针指向子类对象，并使用 delete 关键字释放指针所指向的对象时，如果子类未定义析构函数，就会调用父类的析构函数，这样子类对象中的资源可能无法被正常释放。因此，在父类中定义一个虚析构函数，可以保证子类对象中的资源也能得到正确地释放。

class Parent{
public:
  virtual ~Parent(){
    cout << "Parent object is destroyed" << endl;
  }
};

class Child : public Parent{
public:
  ~Child(){
    cout << "Child object is destroyed" << endl;
  }
};

在上述代码中，我们在父类 Parent 中定义了一个虚析构函数，子类 Child 继承了父类。当我们执行以下代码时：

Parent* p = new Child();
delete p;

此时会先执行子类的析构函数，再执行父类的析构函数。

三、示例

这里我们来看一个示例，假设我们要设计一个简单的人类。一个人需要有名字、性别和年龄这三个属性。我们可以设计一个 Person 类如下：

class Person{
public:
  Person(string name, string gender, int age){
    m_name = name;
    m_gender = gender;
    m_age = age;
  }

  ~Person(){
    cout << "Person object is destroyed" << endl;
  }

private:
  string m_name;
  string m_gender;
  int m_age;
};

在上述代码中，我们定义了 Person 类，它有名字、性别和年龄这三个属性。构造函数需要传入这三个参数，并将它们分别赋值给类中的成员变量。析构函数用来释放对象中的资源。

现在我们要创建一个名字叫 Tom 的男孩（年龄为 10 岁），我们可以这样写：

Person* p = new Person("Tom", "male", 10);
delete p;

这里我们用了 new 运算符创建了一个名为 p 的 Person 类对象，并从堆区分配内存。delete 关键字用于释放 p 所指向的对象。

再来看一个例子，我们现在要设计一个图形类（抽象类），包括一个虚函数 get_area() 用来计算图形的面积。我们还要设计两个具体的图形类 Circle 和 Rectangle，它们都是从图形类派生而来。Circle 类包括一个成员变量 r 代表圆的半径；Rectangle 类包括两个成员变量 w 和 h 分别代表矩形的宽和高。我们可以这样写：

#include <iostream>
using namespace std;

class Shape{
public:
  virtual float get_area() = 0;
};

class Circle : public Shape{
public:
  Circle(float r){
    m_r = r;
  }

  float get_area(){
    return 3.14 * m_r * m_r;
  }

private:
  float m_r;
};

class Rectangle : public Shape{
public:
  Rectangle(float w, float h){
    m_w = w;
    m_h = h;
  }

  float get_area(){
    return m_w * m_h;
  }

private:
  float m_w, m_h;
};

int main(){
  Shape* s1 = new Circle(5);
  cout << "Circle: " << s1->get_area() << endl;
  delete s1;

  Shape* s2 = new Rectangle(3, 4);
  cout << "Rectangle: " << s2->get_area() << endl;
  delete s2;

  return 0;
}

在上述代码中，我们定义了一个抽象类 Shape，其中有一个纯虚函数 get_area()。接着我们派生出两个具体的类 Circle 和 Rectangle，它们都实现了 get_area() 函数。在 main 函数中，我们分别用 Circle 和 Rectangle 类型的指针来创建对象，并调用它们的 get_area() 函数来计算面积。

以上就是关于“c++ 入门——浅析构造函数和析构函数”的完整攻略，希望能对初学者有所帮助。