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

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
}

时间: 2024-10-23 10:54:12

C++ new、delete(new[]、delete[])操作符重载需要注意的问题_C 语言的相关文章

C++运算符重载的方法详细解析_C 语言

运算符重载实质上是函数的重载 重载运算符的函数一般格式如下: 函数类型    operator  运算符名称    (形参表列) {对运算符的重载处理} 例如,想将"+"用于Complex(复数)的加法运算,函数的原型可以是这样的: 复制代码 代码如下: Complex operator + (Complex & c1,Complex &c2); 其中,operator是关键字,时候专门用于定义重载运算符的函数的,运算符名称就是C++提供给用户的预定运算符. 注意:函数

c++运算符重载基础知识详解_C 语言

实际上,很多C++运算符已经被重载.eg:将*运算符用于地址,将得到存储在这个地址中的值,将他用于2个数字时,得到的将是他们的乘积.C++根据操作数的数目和类型来决定采用哪种操作. C++允许将运算符重载扩展到用户定义的类型.例如,允许使用+将两个对象相加.编译器将根据操作数的数目和类型决定使用加法定义.运算符重载可以使代码看起来更自然.例如,将2个数组相加是一种常见的运算.通常,需要使用下面这样的for循环来实现: 复制代码 代码如下: for (int i = 0; i < 20; i++)

【C/C++学院】(8)全局函数和类成员函数转化/友元/操作符重载

1.全局函数和类成员函数转化     全局函数和成员函数的相互转化:只需要修改一个指向本类的this指针: #include <iostream> using namespace std; class Test { public: Test(int a, int b) { this->a = a; this->b = b; } //成员函数 Test &Gadd2(Test &t2) { this->a = this->a + t2.a; this-&g

运算符重载-C++ 操作符重载的内存释放问题

问题描述 C++ 操作符重载的内存释放问题 =操作符重载,给复构造函数进行赋值时的代码如下: MyString & MyString::operator =(const MyString &str) { if(this == &str) return *this; delete []m_pData; //**???????????????????????????? ** m_pData = NULL; m_pData = new char(strlen(str.m_pData) +

拷贝构造,操作符重载

 拷贝构造 #include <iostream> #include <string.h>   using namespace std;   class mystring { public:     char *s; public:     mystring()     {        s = new char[1024];        cout << "mystring" << endl;     }     //拷贝构造   

C++中new与delete、malloc与free应用分析_C 语言

一般来说,在C/C++的面试时,对于new/delete和malloc/free这两对的使用和区别经常被考查到,如果这种基础的问题都答不上来,估计很难过面试了.本文即是对new/delete和malloc/free这两对的使用和区别较为简单的分析一下,供大家参考. 一.new和delete new和delete是C++的运算符,用于动态分配内存和释放内存. 1.new表达式 标准库定义了operator new函数的几个重载版本,没有使用noexcept说明的版本在内存分配失败时可能会抛出bad

C#锐利体验之第八讲 索引器与操作符重载

索引 索引器 索引器(Indexer)是C#引入的一个新型的类成员,它使得对象可以像数组那样被方便,直观的引用.索引器非常类似于我们前面讲到的属性,但索引器可以有参数列表,且只能作用在实例对象上,而不能在类上直接作用.下面是典型的索引器的设计,我们在这里忽略了具体的实现. class MyClass{    public object this [int index]    {        get        {            // 取数据        }        set  

C#中奇妙的操作符重载

C#中奇妙的操作符重载 细心的朋友可能发现,C#虽然可以重载操作符,但和C++比较起来,却有很大的不同.定义的时候重载操作符方法必须是static,而且至少有一个参数(一目和二目分别是一个和两个),C#和C++比起来,最重要的特征是:<.>:==.!=:true.false必须成对出现,即重载了"<"就必须重载">",重载了"=="就必须重载"!=",重载了"true"就必须重载&q

C++的操作符重载概述

1.什么是操作符重载 可以使用分词将操作符重载理解为:操作符+重载. C++中的操作符很多,如+,-,*,\等等. C++中的重载也是C++中面向对象多态的体现. 简单说操作符重载: C++中有:int a=2+3; 那么a=5 操作符重载可以实现对自定义类型的操作: #include <iostream> using namespace std; class Point{ public: int x; int y; Point(int _x,int _y):x(_x),y(_y){ } Po