C++内存管理

void test(){
    int* p1 = (int*)malloc(sizeof(int));
    free(p1);

    
    int* p2 = (int*)calloc(4, sizeof(int));
    int* p3 = (int*)realloc(p2, sizeof(int)*10);
    //realloc调整之后,  原来的空间修改为了新的空间,不需要释放原来的空间
    free(p3);
}

void Test(){
    //申请一个内存空间-->4byte
    int* ptr1 = new int;
    delete ptr1;

    //申请一个内存空间,初始化为10-->4byte
    int* ptr2 = new int(10);
    delete ptr2;

    //申请一个连续的内存空间,包含10个元素-->40byte,内存为随机值
    int* ptr3 = new int[10];
    //释放连续的空间
    delete[] ptr3;
}

class A{
public:
    //默认构造
    A(){
        cout "A()"  endl;
    }
    //带参构造
    A(int a)
        :_a(a)
    {}

    A(int a, int b, int c)
        :_a(a)
    {}

    //析构函数
    ~A(){
    cout "~A()"  endl;
    }


private:
    int _a = 10;

};

void test(){
    //自定义类型:  malloc:  申请空间(不进行初始化,不调用构造函数)
    A* mpa = (A*)malloc(sizeof(A));
    //自定义类型:  free:  释放空间(不清理资源,不调用析构函数)
    free(mpa);


    //自定义类型:  new:  申请空间 + 调用构造函数进行空间内容的初始化
    A* ptr = new A;
    //自定义类型:  delete:  先调用析构函数进行空间资源的清理 + 空间释放
    delete ptr;

    // 自定义类型:  连续空间(不能使用带出构造)
    //new[]:  申请空间 + 调用N次构造函数
    A* arr = new A[100];
    //delete[]:  调用N次析构函数 + 释放空间
    delete[] arr;



    /*调用默认构造函数(无参或全缺省)*/
    A* p1 = new A;
    delete p1;

    /*如果有初始化,要调用带参构造函数*/
    A* p2 = new A(10);
    A* p3 = new A(1,2,3);
    delete p2;
    delete p3;
}

void test(){
    //使用方式类似于malloc/free
    //operator new:  malloc + 异常,  malloc如果申请失败会给一个指针空值,  并不会异常
    int* ptr = (int*)operator new(sizeof(int));
    int* ptr2 = (int*)malloc(sizeof(int));

    //operator delete:  封装free
    operator delete(ptr);
    free(ptr2);
}

class A{
public:
    A(int a)
        :_a(a)
    {
        cout " A(int) " endl;
    }

    ~A(){
        cout "~A()"  endl;
    }
private:
    int _a;

};

void test(){
    A* pa = (A*)malloc(sizeof(A));
    //初始化已有的空间
    //new定位表达式: new(指针)类型(参数列表(可选))-->显示调用构造函数
    new(pa)A(10);
    pa->~A();
    free(pa);
}