C/C++编程：new和delete运算符的原理

我就是我 2023-01-19 07:24 122阅读 0赞

# 针对POD类型的new语义 #

对于如下定义，分两个步骤完成：

int *pi = new int(5);

*  通过适当的new运算符函数实体，配置所需的内存：

// 调用函数库中的new运算符
    int *pi = __new(sizeof(int));

*  给配置来的对象设定初值：

*pi = 5;

跟进一步，初始化操作应该在内存配置成功之后才执行：

int pi;  // 重写声明
    if (pi = __new(sizeof(int))){
        
    	*pi = 5;  // 成功了才初始化
    }

delete的情况类似，对于：

delete pi;

时，如果pi的值是0，C++语言会要求delete运算符不要有操作。因此编译器必须为此调用构造一层保护膜：

if(pi != 0){
        
    	__delete(pi);
    }

请注意，pi并不会因此自动清除为0。

pi所指对象的生命会因为delete而结束。所以后继任何对pi的操作都不是良构的。但是我们还是可以把pi继续当作一个指针来用(虽然其使用受到限制)，比如：

// ok : pi仍然指向合法空间，即使存储于其中的object已经不再合法
    if(pi == sentinel)

在这里，使用指针pi和使用pi所指的对象，其差别在于哪一个的生命已经结束了。虽然该地址上的对象不再合法，但地址本身却仍然代表一个合法的程序空间，因此pi能够继续被使用，但是只能在受到限制的情况下，很像一个void\*指针的情况。

# 针对非POD类型的new语义 #

以constructor来配置一个class object，情况类似。比如：

Point3d *origin = new Point3d;

被转换为：

Point3d *origin;
    if(origin = __new(sizeof(Point3d))){
        
    	origin = Point3d::Point3d (origin);
    }

如果出现exception handling，那么准换结果可能会更复杂一点：

if(origin = __new(sizeof(Point3d))){
        
    	try{
        
    		origin = Point3d::Point3d(origin);
    	}catch(...){
        
    		// 调用delete library function以释放因new而配置的内存
    		__delete(origin );
    		// 将原来的exception上传
    		throw; 
    	}
    }

在这里，如果以new运算符配置object，而其构造函数丢出一个exception，配置得来的内存就会被释放掉。然后exception再被丢出去(上传)

destructor的应用类似，比如：

delete origin;

会变成：

if(origin != 0){
        
    	Point3d::~Point3d(origin);
    	__delete(origin);
    }

如果在exception handling的情况下，destructor应该被放在一个try区段中。exception handler会调用delete运算符，然后再一次丢出该exception。

一般library对new运算符的实现操作都很直截了当，但注意两点(此处不考虑exception handling)：

extern void *operator new(size_t size){
        
    	if(size == 0){
        
    		size = 1;
    	}
    
    	void *last_alloc;
    	while(!(last_alloc = malloc(size))){
        
    		if(__new_handler){
        
    			(*_new_handler)();
    		}else{
        
    			return 0;
    		}
    	}
    	return last_alloc;
    }

*  虽然这样写是合法的：

new T[0];

*  但语言要求每一次对new的调用都必须返回一个独一无二的指针。解决该问题的传统方法是传回一个指针，指向一个默认的1-byte的内存区域(也就是为什么size=1的原因)。这个实现技术的的另一个有趣之处在于它允许使用者提供一个属于自己的\_new handler()函数。这正式为什么每一次循环都调用\_new\_handler()之故
 *  new运算符实际上是用malloc完成的，同样的，delete用free()完成：

extern void operator delete(void *ptr){
        
    	if(ptr)
    		free((char *) ptr);
    }

# 针对数组的new语义 #

当遇到：

int *p_array = new int[5];

时，vec\_new()不会真正被调用，因为它的主要功能是把默认构造函数施行于类对象所组成的数组的每一个元素上。实际上，会调用new运算符：

int *p_array = (int *)__new(5 * sizeof(int));

相同的情况，如果我们写：

struct simple_aggr {
        float f1, f2};
    simple_aggr *p_aggr= new simple_aggr[5];

vec\_new()也不会被调用。为什么呢？因为simple\_aggr 并没有定义一个析构函数或者构造函数，所以配置数组以及清楚p\_aggr数组的操作，只是单纯的获得内存和释放内存而已。这些操作由new和delete运算符来完成就绰绰有余了。

然而如果类定义有一个默认构造函数，某些版本的vec\_new()就会被调用，配置并构造类对象所组成的数组。比如：

Point3d *p_array = new Point3d[10];

通常会被编译为：

Point3d *p_array;
    p_array = vec_new(0, sizeof(Point3d), 10, &Point3d::Point3d, &Point3d::~Point3d);

注意，在个别的数组元素构造过程中，如果发生exception，destructor就会被传递给vec\_new()，只有已经被构造妥当的元素才需要destructor的施行，因为它们的内存已经被配置出来了，vec\_new()有责任在exception发生的时候把那些内存释放掉。

对于：

delete[] p_array;

与

delete p_array;

寻找数组维度会给delete运算符的效率带来很大的印象，所以：只有在\[\]出现时，编译期才寻找数组的维度，否则它就假设只有单独一个对象要被删除。也就是说，对于`delete p_array`，只有第一个元素才会被析构，其他的元素仍然存在。

那应该如何记录元素的数目？一个明显的方法是位vec\_new()所传回的每一个内存区块配置一个额外的word，然后把元素数组包藏在那个word中。通常这种被包藏的数值称为cookie

`vec_delete`的操作并不总是如预期所需。看个例子：

class Point{
        
    	public:
    		Point();
    		virtual ~Point();
    };
    
    class Point3d : public Point{
        
    public:
    	Point3d();
    	virtual ~Point3d();
    };

如果我们配置一个数组，内带10个Point3d objects，我们会预期Point和Point3d的构造函数被各调用10次，每次作用于数组中的一个元素：

//这不是一个好主意
    Point *ptr = new Point3d[10];

而当我们delete“由ptr所指向的10个Point3d元素”时，会发生什么事情呢？很明显，我们需要虚拟机制的帮助，以获得预取的Point析构函数和Point3d析构函数各10次调用(每一个作用于数组中的一个元素)

// 这不是我们想要的：只有Point::~Point()被调用
    delete [] ptr;

作用于数组上的析构函数，只有Point destructor。这并非我们所希望的。此外，每个元素的大小也一并被传递过去。本例被传递过去的是Point class object的大小而不是Point3d class object的大小。这个运行过程非常不幸的失败了，不只是因为执行错误的析构函数，而且自从第一个元素之后，该析构函数被运行在不正确的内存区块中（因为元素的大小不对）

那应该怎么做呢？**最好是避免以一个基类指向一个派生类对象所组成的数组**。如果你一定要这么写的话，解决方法在代码层面，而非语言层面：

for(int ix = 0; ix < elem_count; ++ix){
        
    	Point3d *p = &((Point3d*)ptr)[ix];
    	delete p;
    }

# 其他 #

**如果要用到C++特性的话，请用new不要用malloc**

class stream {
        
    public:
        virtual int sys_read(void *buf, size_t size) = 0;
        int read_to_buffer( void *buf, size_t size){
        
            return sys_read(buf, size);
        }
    };
    
    class stream_file : public stream{
        
    public:
        int sys_read(void *buf, size_t size){
        
            printf("-----------------");
        }
    };
    
    int main() {
        
        stream_file * streamFile;
       // streamFile = (stream_file *) calloc(1, sizeof(stream_file));// Process finished with exit code 139 (interrupted by signal 11: SIGSEGV)
        streamFile = new stream_file;
       streamFile->read_to_buffer(NULL,  0);

calloc分配时没有分配虚表，所以会段错误