C++类对象的创建与释放过程详解

类的定义与实例化
类对象的创建方法
类对象的创建过程
类对象的释放过程
析构函数
缺省析构函数
类的定义与实例化
类对象的创建方法
1、在栈上创建

类名 对象;    // 无参创建方法
类名 对象(实参);    // 有参创建方法

2、在堆上创建

类名* 对象指针 = new 类名;
类名* 对象指针 = new 类名();

3、创建多个对象

类名 对象 = {(实参),(实参),(实参)};
类名* 对象指针 = new 类名(n){类名(实参),类名(实参),类名(实参)};
注意：
    1、通过malloc创建的类对象不能调用构造函数。
    2、通过new[]创建的对象，一定要通过delete[]释放。

类对象的创建过程
1、分配类所需要的空间，无论是栈还是堆。
2、传递实参调用构造函数，完成如下任务：

1、根据继承表依次调用父类的构造函数。
2、根据成员变量的顺序依次调用成员变量的构造函数。
3、执行构造函数体中的代码。
注意：执行构造函数的代码是整个构造函数的最后一步，要保证构造函数代码所需要的一切资源和先决条件在该代码执行前已经准备充分，并得到正确的初始化。

#include

using namespace std;
class A
{
public:
    A(void)
    {
        cout << "我是A的构造函数" << endl;
    }
};

class B
{
public:
    B(void)
    {
        cout << "我是B的构造函数" << endl;
    }
};

class C : public A
{
public:
    B b;
    C(void)
    {
        cout << "我是C的构造函数" << endl;
    }
};

int main()
{
    C c;
}
 

类对象的释放过程
析构函数
析构函数负责释放在构造函数期间获取的所有资源，它的执行过程：

1、先执行析构函数本身代码
2、调用成员类的析构函数
3、调用父类的析构函数

缺省析构函数
如果一个类没实现析构函数，编译器会自动生成一个具有析构功能的二进制指令，它负责释放编译器能够看得到的资源（成员变量、类成员、父类成员），这就是缺省析构。
如果类中没有动态资源，也不需要做善后工作，缺省析构就完全够用了，不需要再定义新析构函数。
注意：缺省析构无法释放动态资源（堆内存）。
#include
#include
#include

using namespace std;

class A
{
public:
    A(void)
    {
        cout << "我是类A的构造函数" << endl;
    }
    ~A(void)
    {
        cout << "我是类A的析构函数" << endl;
    }
};

class B
{
public:
    B(void)
    {
        cout << "我是类B的构造函数" << endl;
    }
    ~B(void)
    {
        cout << "我是类B的析构函数" << endl;
    }
};

class User : public A
{
    char* name;
    char* pass;
    B b;
public:
    User(const char* name,const char* pass)
    {
        this->name = new char[strlen(name)+1];
        strcpy(this->name,name);
        this->pass = new char[strlen(pass)+1];
        strcpy(this->pass,pass);

        cout << "构造函数" << endl;
    }

    ~User(void)
    {
        delete name;
        delete pass;

        cout << "析构函数" << endl;
    }
};

int main()
{
    User* user = new User("zhizhen","zzxx");
    cout << "----------" << endl;
    delete user;
}