15.C++动态内存数组，动态内存对象

 探究动态对象的构造过程

#include<iostream>
using namespace std;

class A
{
private:
    int data;
public:
    A(int i) :data(i) {}
    //~A();
    void InitObject(int i) { data = i; }
    void Destroy(A* p) { data = 0; }//删除所有数据和动态内存
    void FreeObject(A* p) {
        Destroy(p);//1.摧毁对象
        free(p);//2.释放p指向空间
    }
};

void use_malloc_free()
{
    A* p = (A*)malloc(sizeof(A));
    if (p == NULL) {
        cout << "空间申请失败" << endl;
        exit(0);
    }
    else
    {
        cout << p << endl;
        p->InitObject(10086);
    }
    p->FreeObject(p);
    cout << p << endl;
}
void use_new_delete()
{
    A* p = new A(10086);//申请空间，调用构造
    cout << p << endl;
    delete p;//调用析构摧毁对象，释放p指向空间
    cout << p << endl;
}
int main()
{
    use_malloc_free();
    use_new_delete();
    return 0;
}

动态数组在堆区分配，需要手动释放

#include <iostream>
using namespace std;
class Int{
    private:
        int a;
        int b;
    public:
        Int(int a = 100,int b =101):a(a),b(b){cout<<this<<" Object: "<<a<<b<<endl;}
        ~Int(){cout<<a<<b<<endl;};
}; 

int main()
{
    Int a=Int(111,222);//a(111,222);会不会是生成Int(111,222)这个临时对象，然后把地址给了a
    Int b[2]={Int(1,2),Int(3,4)};
    //Int b[2]={(1,2),(3,4)};
    //因为从定义Int b[2]已经知道是"Int类"类型的数组了，所以可以简写成
 
    Int* x=new Int[2];//这种写法，构造函数需要有默认值,或者不写构造函数，系统默认给所有参数初始化0
    delete[] x;

    Int* p = new Int(333,444);//堆曲分配，需要手动释放
    Int* q = new Int[2]{Int(01,02),Int(03,04)};
    //Int* q = new Int[2]{(01,02),(03,04)};
    delete p;
    delete[] q;//[]释放多个连续对象
    
    return 0;
}