C++ new、delete(new[]、delete[])操作符重载需要注意的问题

new、delete(new[]、delete[])操作符的重载需要注意:

1.重载的 new、delete(或者 new[]、delete[])操作符必须是类的静态成员函数(为什么必须是静态成员函数,这很好理解,因为 new 操作符被调用的时候,对象还未构建)或者是全局函数,函数的原型如下:

void* operator new(size_t size) throw(std::bad_alloc);

// 这里的 size 为分配的内存的总大小

void* operator new[](size_t size) throw(std::bad_alloc);

 

void operator delete(void* p) throw();

void operator delete[](void* p) throw();

 

void operator delete(void* p, size_t size) throw();

// 区别于 new[] 的参数 size,这里的 size 并非释放的内存的总大小

void operator delete[](void* p, size_t size) throw();

另外,我们可以使用不同的参数来重载 new、delete(或者 new[]、delete[])操作符,例如:

// 第一个参数仍为 size_t

void* operator new(size_t size, const char* file, int line);

// 此操作符的使用

string* str = new(__FILE__, __LINE__) string;

重载全局的 new、delete(或者 new[]、delete[])操作符会改变所有默认分配行为(包括某个类的分配行为),因此必须小心使用,如果两个库都 new 等进行了全局重载,那么就会出现链接错误(duplicated symbol link error)。而在类中定义的 new、delete(或者 new[]、delete[])操作符只会影响到本类以及派生类。

很多人完全没有意识到 operator new、operator delete、operator new[]、operator delete[] 成员函数会被继承(虽然它们是静态函数)。有些时候,我们只想为指定的类设置自定义的 operator new 成员函数,而不希望影响到子类的工作。《Effective C++ Third Edition》提供了如下的方案:

void * Base::operator new(std::size_t size) throw(std::bad_alloc)

{

    // 如果大小不为基类大小

    if (size != sizeof(Base))

        // 调用标准的 new 操作符

        return ::operator new(size);

 

    自定义大小为基类大小的分配处理

}

这样处理的一个前提是:认为子类的大小一定大于父类。

对于 operator new[] 来说,我们很难通过上面的方式检查到底是父类还是子类调用了操作符。通过 operator new[] 操作符的参数,我们无法得知分配的元素的个数,无法得知分配的每个元素的大小。operator new[] 的参数 size_t 表明的内存分配的大小可能大于需要分配的元素的内存大小之和,因为动态内存分配可能会分配额外的空间来保存数组元素的个数。

2.兼容默认的 new、delete 的错误处理方式

这不是个很简单的事(详细参考《Effective C++ Third Edition》 Item 51)。operator new 通常这样编写:

// 这里并没有考虑多线程访问的情况

void* operator new(std::size_t size) throw(std::bad_alloc)

{

    using namespace std;

 

    // size == 0 时 new 也必须返回一个合法的指针

    if (size == 0)

        size = 1;

 

    while (true) {

 

        尝试进行内存的分配

 

        if (内存分配成功)

            return (成功分配的内存的地址);

 

        // 内存分配失败时,查找当前的 new-handling function

        // 因为没有直接获取到 new-handling function 的办法,因此只能这么做

        new_handler globalHandler = set_new_handler(0);

        set_new_handler(globalHandler);

 

        // 如果存在 new-handling function 则调用

        if (globalHandler) (*globalHandler)();

        // 不存在 new-handling function 则抛出异常

        else throw std::bad_alloc();

    }

}

这一些方面是我们需要注意的:operator new 可以接受 size 为 0 的内存分配且返回一个有效的指针;如果存在 new-handling function 那么在内存分配失败时会调用它并且再次尝试内存分配;如果不存在 new-handling function 失败时抛出 bad_alloc 异常。

要注意的是,一旦设置了 new-handling function 内存分配就会无限循环进行下去,为了避免无限循环的发生,new-handling function 必须做以下几件事中的一件(详细参考《Effective C++ Third Edition》 Item 49):让有更多内存可用、设置另一个能发挥作用的 new-handler、删除当前的 new handler、抛出一个异常(bad_alloc 或者继承于 bad_alloc)、直接调用 abort() 或者 exit() 等函数。

对于 operator delete 的异常处理就简单一些,只需要保证能够安全的 delete 空指针即可:

void operator delete(void *rawMemory) throw()

{

    // 操作符可以接受空指针

    if (rawMemory == 0) return;

 

    释放内存

}

多态的问题(详细参考《ISO/IEC 14882》)

前面谈到了 new、delete(new[]、delete[])操作符的继承,这里额外讨论一下多态的问题,显然我们只需要讨论 delete、delete[] 操作符:

struct B {

    virtual ~B();

    void operator delete(void*, size_t);

};

 

struct D : B {

    void operator delete(void*);

};

 

void f()

{

    B* bp = new D;

    delete bp;  //1: uses D::operator delete(void*)

}

通过上面的例子,我们可以看到,delete 时正确的调用了 D 的 operator delete 操作符。但是同样的,对于 delete[] 操作符工作就不正常了(因为对于 delete[] 操作符的检查是静态的):

struct B {

    virtual ~B();

    void operator delete[](void*, size_t);

};

 

struct D : B {

    void operator delete[](void*, size_t);

};

 

void f(int i)

{

    D* dp = new D[i];

    delete [] dp;  //uses D::operator delete[](void*, size_t)

    B* bp = new D[i];

    delete[] bp;  //undefined behavior

}

以上是 C++ new、delete(new[]、delete[])操作符重载需要注意的问题 的全部内容, 来源链接: utcz.com/z/334435.html

回到顶部