C++中动态内存管理的实现

int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
    static int staticVar = 1;
    int localVar = 1;
    int num1[10] = { 1,2,3,4 };
}

void Test
{
    char char2[] = "abcd";
    const char* pChar3 = "abcd"; // 常量字符串，如果不加const则权限放大，报错
    int* ptr1 = (int*)malloc(sizeof(int) * 4);
    int* ptr2 = (int*)calloc(4, sizeof(int));
    int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
    free(ptr1);
    free(ptr3);
}

int main()
{
    // C
    int* p1 = (int*)malloc(sizeof(int)); // 随机值
    free(p1);

    // C++ 动态申请一个int类型的空间
    int* p2 = new int; // 随机值
    delete p2;

    // C
    int* p3 = (int*)malloc(sizeof(int)*10); // 全是随机值
    free(p3);

    // C++ 动态申请10个int类型的空间
    int* p4 = new int[10]; // 全是随机值
    delete[] p4;

    // C++ 动态申请一个int类型的空间并初始化为10
    int* p5 = new int(10);
    delete p5;

    int* p6 = new int[10]{1,2,3}; // 其余是0
    delete[] p6;

    return 0;
}

struct ListNode
{
    int _val;
    struct ListNode* _next;

    ListNode(int x) // 构造函数
        :_val(x)
        , _next(NULL)
    {}
};

struct ListNode* BuyListNode(int x)
{
    // 单纯开空间
    struct ListNode* newnode = (struct ListNode*)malloc(sizeof(struct ListNode));
    // 检查
    newnode->_next = NULL;
    newnode->_val = x;

    return newnode;
}

int main()
{
    struct ListNode* n1 = BuyListNode(1);
    struct ListNode* n2 = BuyListNode(2);
    struct ListNode* n3 = BuyListNode(3);

    // 开空间+调用构造函数初始化
    ListNode* nn1 = new ListNode(1);
    ListNode* nn2 = new ListNode(2);
    ListNode* nn3 = new ListNode(3);

    return 0;
}

class A
{
public:
    A(int a = 0)
        : _a(a)
    {
        cout << "A():" << this << endl;
    }

    ~A()
    {
        cout << "~A():" << this << endl;
    }

private:
    int _a;
};

int main()
{
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = new A(1);
	free(p1);
	delete p2;

	A* p5 = (A*)malloc(sizeof(A) * 10);
	A* p6 = new A[4];
	free(p5);
	delete[] p6;

	return 0;
}

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

    ~A()
    {
        cout << "~A():" << this << endl;
    }

private:
    int _a;
};

int main()
{
	// A* p6 = new A[4]; // 报错：“A”: 没有合适的默认构造函数可用
    A* p6 = new A[4]{ 1,2,3,4 };
    A* p6 = new A[4]{ A(1),A(2),A(3),A(4) }; // 给4个匿名对象
	delete[] p6;
	return 0;
}

class A
{
public:
    A(int a, int b)
        : _a(a)
    {
        cout << "A():" << this << endl;
    }

    A(const A& aa)
        : _a(aa._a)
    {
        cout << "A(const A& aa):" << this << endl;
    }

    ~A()
    {
        cout << "~A():" << this << endl;
    }

private:
    int _a;
};

int main()
{
    A* p2 = new A(1, 1);
	delete p2;

    A* p6 = new A[4]{ A(1,1),A(2,2),A(3,3),A(4,4) };
	delete[] p6;

	return 0;
}

int main()
{
	// 申请一个堆上的栈对象
	Stack* p1 = new Stack;
	delete p1;

	return 0;
}

int main()
{
	try
	{
		// 申请一个堆上的栈对象
		Stack* p1 = new Stack;
		delete p1;
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}

int main()
{
    // p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
    A* p1 = (A*)malloc(sizeof(A));
    // 显示调用构造函数
    new(p1)A; // 注意：如果A类的构造函数有参数时，此处需要传参 new(p1)A(1);

    // 显示调用析构函数
    p1->~A();
    free(p1);
    // 自定义类型的对象才能自动调用构造、析构函数。p1是内置类型，必须显示调用析构

    return 0;
}