对象和类—构造函数和析构函数

构造函数：在创建对象时，自动进行初始化工作。

析构函数：在销毁函数前，自动完成清理工作。

一.构造函数：

语法：类名（）{......}

1.访问权限必须是public。

2.函数名必须与类名相同。

3.没有返回，也不写void

4.可以有参数，可以重载，可以有默认参数。

5.创建对象时会自动调用一次，不能手工调用。

若没有这个构造函数，那就还没有初始化，就会显示乱码：

#include <iostream>
#include <string>
using namespace std;

class person
{
public:
    string name;
    int age;
    char memo[301];
    void setvalue(string name1, int age1) {
        name = name1;
        age = age1;
    }
   
    void show() {
        cout << "姓名： " << name << ", 年龄：" << age << endl;
    }
};

int main() {
    person zhongjiaming;
    zhongjiaming.show();
    return 0;
}

搞了个构造函数的话：

#include <iostream>
#include <string>
using namespace std;

class person
{
public:
    string name;
    int age;
    char memo[301];
    void setvalue(string name1, int age1) {
        name = name1;
        age = age1;
    }
    person()//构造函数，可以对这三个成员变量进行初始化
    {
        name.clear(); age = 0; memset(memo, 0, sizeof(memo));
        cout << "调用了person（）构造函数。\n";
    }

    void show() {
        cout << "姓名： " << name << ", 年龄：" << age << endl;
    }
};

int main() {
    person zhongjiaming;
    zhongjiaming.show();
    return 0;
}

这样就调用了构造函数，成员变量已被初始化，没有乱码了。

再写一个带参数的构造函数：

#include <iostream>
#include <string>
using namespace std;

class person
{
public:
    string name;
    int age;
    char memo[301];
    void setvalue(string name1, int age1) {
        name = name1;
        age = age1;
    }
    person()//构造函数，可以对这三个成员变量进行初始化
    {
        name.clear(); age = 0; memset(memo, 0, sizeof(memo));
        cout << "调用了person（）构造函数。\n";
    }
    person(string name1)//再写一个构造函数，让她带一个参数：姓名name
    {
       name.clear(); age = 0; memset(memo, 0, sizeof(memo));
       cout << "调用了person（name）构造函数。\n";
       name = name1;
    }

    void show() {
        cout << "姓名： " << name << ", 年龄：" << age << endl;
    }
};

int main() {
    person zhongjiaming;
    zhongjiaming.show();
    return 0;
}

现在有俩构造函数了，那创建对象的时候，该调用哪个函数呢？答案是按函数重载的规则调用。

创建对象的时候，如果对象名后面什么都不写，就调用没有参数的那个构造函数。

 person zhongjiaming;

如果想调用有一个参数的这个该站属，就需要在对象名后面写括号和一个实参。

    person zhongjiaming("钟佳铭");

再写一个带两个参数的构造函数（仅展示局部）。

   person(string name1,int age1)//再写一个带两个参数的构造函数。
   {
       name.clear(); age = 0; memset(memo, 0, sizeof(memo));
       cout << "调用了person（name,age）构造函数。\n";
       name = name1;
       age = age1;
   }

    person zhongjiaming("钟佳铭",18);

构造函数也可以有默认参数。

    person(string name1= "钟佳铭",int age1=18)//再写一个带两个参数的构造函数。
    {
        name.clear(); age = 0; memset(memo, 0, sizeof(memo));
        cout << "调用了person（name,age）构造函数。\n";
        name = name1;
        age = age1;
    }

二.析构函数：

语法：~类名（）{......}

1.访问权限必须是public。

2.函数名必须在类名前加~。

3.没有返回，也不写void。

4.没有参数，不能重载。

5.销毁对象前之会自动调用一次，但是也可以手工调用。

#include <iostream>
#include <string>
using namespace std;

class person
{
public:
    string name;
    int age;
    char memo[301];
    void setvalue(string name1, int age1) {
        name = name1;
        age = age1;
    }
    person()//没有参数的构造函数，可以对这三个成员变量进行初始化
    {
        name.clear(); age = 0; memset(memo, 0, sizeof(memo));
        cout << "调用了person（）构造函数。\n";
    }
    person(string name1)//再写一个构造函数，让她带一个参数：姓名name
    {
       name.clear(); age = 0; memset(memo, 0, sizeof(memo));
       cout << "调用了person（name）构造函数。\n";
       name = name1;
    }
    person(string name1= "钟佳铭",int age1=18)//再写一个带两个参数的构造函数。
    {
        name.clear(); age = 0; memset(memo, 0, sizeof(memo));
        cout << "调用了person（name,age）构造函数。\n";
        name = name1;
        age = age1;
    }
    ~person() {
      
        cout << "调用了~person()\n";
    }
    void show() {
        cout << "姓名： " << name << ", 年龄：" << age << endl;
    }
};

int main() {
    person zhongjiaming("钟佳铭",18);
    zhongjiaming.show();
    return 0;
}

手动调用也可以（不常用）

    zhongjiaming.~person();