脱离其作用范围，或者释放一个指向类对象的指针

比如现在有一串代码

一种情况

可以复制到编译器，看一下里面的show函数，这个show函数不是析构函数，但传入了一个类的对象，当一个函数调用结束时，释放形参的内存，这个新参正好是类的对象，那么它的作用域就在这个函数之中，当函数调用结束时，自动执行析构函数

比如我现在删了主函数的show，那么333333333（作为一个标记）上面就没有执行了析构函数这句话，

同理，主函数也是一个函数，只是在主函数里面创建的类的对象不是作为实参传入罢了，这个类的对象的作用域就是主函数的作用域，所以当主函数结束时，自动执行析构函数

#include <iostream>
#include "student.h"
using namespace std;


int main()
{
    student stu(10,20,(char*)"30",(char*)"40");
    cout<<"9999999999"<<endl;
    student ssttuu(20,40,(char*)"50",(char*)"70");
    cout<<"6666666666"<<endl;
    stu.show(stu);
    cout<<"3333333333"<<endl;
    cout<<"8888888888"<<endl;

    

    return 0;
}

#include <iostream>
using namespace std;


class student
{
    //类的属性：
    //学生有id，年龄，姓名等等
    //不能用auto、extern、regist修饰
    //可以static修饰，静态属性可以进行显性的初始化
    int id;
    int age;
    char* name;


    //被private说明为私有
    //访问方式只有：
    //该类的成员函数
    //友元函数
    private:
        char* height;

    public:
        void show(student stu)
        {
            cout<<stu.age<<endl;
            cout<<stu.name<<endl;
            cout<<stu.id<<endl;
            cout<<stu.height<<endl;
        }

        //要想在类外面写函数的函数体，要先声明一下，放在类外面写
        inline void sayhello(student stu);
        //对于使用频繁的可以在前面加上inline，
        //使他成为内联函数，这样会提高他的运行效率
        //所以上面的也可以写成inline void sayhello(student stu);

        student();//构造函数

        student(int mid,int mage,char* mname,char* mheight);//构造函数重载了

        //析构函数一般不内联
        
        inline ~student();//析构函数
        

};


//在类体外定义的成员函数，必须要用::指出该方法所属于的类
//这个函数必须在类里面声明过
inline void student::sayhello(student stu)
{
    cout<<stu.name<<"：我是"<<stu.name<<"你好"<<endl;
    return ;
}

//编写构造函数
//构造函数的函数名必须与类名相同
//否则视为一般函数
//构造函数没有返回值
//不用说明类型
//只能对属性进行初始化，且一般为私有成员（可以类属性）
//只是一般用来初始化私有属性
//不能被显式调用
student::student(int mid,int mage,char* mname,char* mheight)
{
    id = mid;
    age = mage;
    name = {mname};
    height = {mheight};
}

//重载构造函数
student::student()
{
    id = 0;
    age = 0;
    name = 0;
    height = 0;
}

inline student::~student()
{
    cout<<"执行析构函数"<<endl;
}