(2). 返回类型安全性
new 运算符内存分配成功时, 返回的是对象类型的指针, 类型严格与对象匹配, 无序进行类型转换, 故 new 是类型安全的运算符. 而 malloc 内存分配成功时返回的是 void * , 需要通过强制类型转换将 void * 指针转换成需要的类型.

(3). 内存分配失败时的返回值
new 内存分配失败时, 会抛出 bad_alloc 异常;
malloc 分配内存失败时会返回 NULL .
因此, 二者在判断是否分配成功时的代码逻辑不太, 如下所示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// malloc
int* a = (int*)malloc(sizeof(int));
if (a == NULL) {
    ...
} else {
    ...
}

// new
try {
    int* a = new int();
} catch (bad_alloc) {
    ...
}

(4). 是否调用构造函数/析构函数
new 和 delete 会调用对象的构造函数/析构函数以完成对象的构造/析构. 而 malloc 则不会.

(5). 对数组的处理
C++ 提供了 new[] 和 delete[] 来专门处理数组类型. 但是对于 malloc 和 free 来说, 它并不关心分配的内存是否为数组, 需要程序员自行决定参数的合理设置.

delete 会调用对象的析构函数, 和new对应

free 只会释放内存, 和malloc.

malloc/free是C++/C 语言的标准库函数, new/deletec是C++语言的运算符, 因此, 我们可以通过重载 new 和 delete 运算符, 来完成自定义的功能.

它们都可用于申请动态内存和释放内存, 对于非内部数据类型的对象而言, 光用 malloc/free 无法满足动态对象的要求, 对象在创建的同时要自动执行构造函数, 在消亡之时要自动执行析构函数, 由于malloc/free是库函数而不是运算符, 因此不在编译器控制权限之内, 不能够把执行构造函数和析构函数的任务强加于malloc/free. 因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new, 以及一个能完成清理与释放内存工作的运算符delete.

当我们在使用一个 new 的时候, 它就变成了一个表达式的形式, 如下所示:

1

Test* test = new Test;

new 表达式的行为主要有两步:

在对 内建数据类型 使用时, delete和delete[]是等价的, 因此delete[]会调用数组元素的析构函数, 但是内部数据类型没有析构函数, 所以可以直接使用.

(1). 只在对上分配类对象
就是不能静态建立类对象, 即不能直接调用类的构造函数.
首先要知道, 当对象建立在栈上面时, 是由编译器分配内存空间的, 当对象使用完以后, 编译器会调用析构函数来释放对象所占的空间. 实际上, 编译器在为类对象分配栈空间时, 会检查类的析构函数的访问性(其他非静态函数也会检查), 如果类的析构函数是私有的, 则编程器不会在栈空间上为类对象分配内存 . 因此, 我们只需要将析构函数设为私有, 类对象就无法建立在栈上了, 如下所示:

1
2
3
4
5
6
7

class A{
public:
    A(){}
    void destroy(){delete this;}
private:
    ~A(){}
}

注意 , 由于 new 表达式会在分配内存以后调用构造函数, 因此构造函数必须是公有的, 同时, 由于 delete 此时无法访问私有的析构函数, 因此必须提供一个 destroy 函数, 来进行内存空间的释放.

存在问题:

(2). 只在栈上分配类对象
只有使用new运算符，对象才会建立在堆上，因此，只要禁用new运算符就可以实现类对象只能建立在栈上。
虽然你不能影响new operator的能力（因为那是C++语言内建的），但是你可以利用一个事实：new operator 总是先调用 operator new，而后者我们是可以自行声明重写的。

因此，将operator new()设为私有即可禁止对象被new在堆上。

代码如下：

1
2
3
4
5
6
7
8
9

class A  
{  
private:  
    void* operator new(size_t t){}     // 注意函数的第一个参数和返回值都是固定的  
    void operator delete(void* ptr){} // 重载了new就需要重载delete  
public:  
    A(){}  
    ~A(){}  
};