3.7 new和delete

#include<iostream>
using namespace std;

class Test
{
public:
    Test()
    {
        m_a = 0;
        m_b = 0;
    }
    Test(int a,int b)
    {
        cout << "Test(int, int)" << endl;
        m_a = a;
        m_b = b;
    }
    void printT()
    {
        cout << "printT :" << m_a << "," << m_b << endl;
    }
    ~Test()
    {
        cout << "~Test()" << endl;
    }
private:
    int m_a;
    int m_b;

};

//C语言中
void test1()
{
    //在堆上开辟4个字节，返回一个地址给p
    int *p = (int *)malloc(sizeof(int));
    *p = 10;//给开辟的空间赋值
    if (p !=NULL) {
        free (p);
        *p = NULL;
    }   

    //开辟数组
    int *array_p = (int *)malloc(sizeof(int) *10);//10个元素，每个元素4个字节
                                     //也可以直接写40，上面那样写增加了可读性
    //赋值
    for (int i = 0; i < 10; i++)
        array_p[i] = i +1;
    for (int i = 0; i < 10; i++)
        printf("%d " ,array_p[i]);
    printf("\n");
    if (array_p !=NULL) {
        free(array_p);
         array_p = NULL;
    }   
}

//malloc free 是函数，是标准库，stdlib.h
//new delete 是操作符（集成的），效率高，没函数压栈和出栈
//new 在堆上初始化一个对象的时候，会触发对象的构造函数。malloc不能
//free并不能触发一个对象的析构函数。

//c++中
void test2()
{//在堆上开辟4个字节，返回一个地址给p
    int *p = new int;//new是一个关键字，malloc是一个函数
    *p = 10;
    if (p !=NULL) {
        delete p;
        p = NULL;
    }


    //开辟一个10个元素，每个元素4个字节的数组
    int *array_p = new int[10];
    for (int i = 0; i < 10; i++)
        array_p[i] = i +1;
    for (int i = 0; i < 10; i++)
        cout << array_p[i] << " ";
    cout << endl;
    if (array_p !=NULL) {
        delete[] array_p;//delete数组
    }

    cout << "------------" <<endl;
    Test *tp = new Test(10,20);//触发有参构造
    tp->printT();
    Test *tp2 = new Test;//触发无参构造
    tp2->printT();
    if (tp !=NULL) {
        delete tp;
        tp = NULL;
    }

}

int main()
{
    test1();
    cout << "------------------" << endl;
    test2();
    return 0;
}

总结：

malloc free 是函数，是标准库，stdlib.h
new delete 是操作符（集成的），效率高，没函数压栈和出栈
new 在堆上初始化一个对象的时候，会触发对象的构造函数。malloc不能
free并不能触发一个对象的析构函数。