分清operator new和new operator

最新推荐文章于 2024-03-23 18:00:56 发布

kr-氪

最新推荐文章于 2024-03-23 18:00:56 发布

阅读量1.1k

点赞数

分类专栏： c/c++ 文章标签： delete string 编译器 class 语言 buffer

c/c++ 专栏收录该内容

13 篇文章

订阅专栏

在C++中new operator与operator new非一回事也，new operator（即所谓的new expression）乃语言内建，咱们是没法改变其行为的，当你写string *ps = new string("Hands up!")时，你所使用的new是所谓的new operator，它其实干了两件事：一、分配足够的内存（实际大小是大于所创建的对象大小）二、调用对象构造函数，new operator永远干这两件事。上面的那段代码大约反映以下的行为：
      void *mem = operator new(sizeof(string));
     call string::string("Hands up!") on *mem;
     string *ps = static_cast<string*>(mem);
也就是说operator new仅仅分配内存（就像malloc一样），我们能够做的仅仅是重载operator new，为自己的类创建一个定制的内存管理方案，这也让我有点明白为什么在重载operator new的时候并没有写调用构造函数的代码，但它确实被调用了，原来都是new operator搞的鬼。

导读：
　　返回值类型是void*，表示其返回的是一个未经处理（raw）的指针，指向未初始化的内存。参数size_t确定分配多少内存。你能增加额外的参数重载函数operator new，但是第一个参数类型必须是size_t。头文件中有一个很好的重载的例子，那就是placement new，它看上去象这样：
　　void * operator new(size_t, void *location)
　　{
　　return location;
　　}
　　这初看上去有些陌生，但它却是new操作符的一种常见重载方法，使用一个额外的变量buffer，当new操作符隐含调用operator new函数时，把这个变量传递给它。被调用的operator new函数除了持有强制的参数size_t外，还必须接受void*指针参数，指向构造对象占用的内存空间。未被使用的（但是强制的）参数size_t没有参数名字，以防止编译器警告说它未被使用。在使用placement new的情况下，调用者已经获得了指向内存的指针，因为调用者知道对象应该放在哪里。placement new需要做的就是返回传递给它的指针。
　　我们更经常使用的new是new操作符(new operator)，而非操作符new(operator new)，如当你使用new操作符构建一个对象的时候，实际上做了两件事情，一是调用operator new函数获取内存，二是调用对象的构造函数，如：
　　string *ps = new string("Hello, world!");
　　它完成与下面代码相似的功能：
　　void *memory = operator new(sizeof(string)); // 为String对象得到未经处理的内存
　　call string::string("Hello, world!") on *memory; // 调用构造函数初始化内存中的对象
　　string *ps = static_cast(memory); // ps指针指向新的对象
　　注意第二步中构造函数的调用只能由编译器完成，用户是不允许这样操作的，也就是说如果你想建立一个堆对象就必须用new操作符，不能直接像上面一样调用构造函数来初始化堆对象。
　　new操作符(new operator)是编译器内置的，其行为被语言固定下来，不受用户控制。但是它们所调用的内存分配函数也就是操作符new(operator new)则可以根据需要进行重载。试着回顾new操作符(new operator)与操作符new(operator new)的关系，如果你想在堆上建立一个对象，应该用new操作符。它既分配内存又为对象调用构造函数。如果你仅仅想分配内存，就应该调用operator new函数，它不会调用构造函数。如果你想定制自己独有的内存分配过程，你应该重载全局的operator new函数，然后使用new操作符，new操作符会调用你定制的operator new。如果你想在一块已经获得指针的内存里建立一个对象，应该使用placement new。
　　最后需要记住的一点是，delete和new一样具有以上的特性，只是需要注意的一点是delte操作符中是首先调用对象的析构函数，然后再调用operator delete函数的。
　　2. 针对数组的new[]和delete[]操作
　　建立数组时new操作符(new[])的行为与单个对象建立(new)有少许不同：
　　第一是内存不再调用用operator new函数进行分配，代替以operator new[]函数(常称作array new)。它与operator new一样能被重载，允许定制数组的内存分配，就象定制单个对象内存分配一样。
　　第二个不同是new[]操作时调用构造函数的数量。对于new[]而言，在数组里的每一个对象的构造函数都必须被调用。
　　delete[]操作符的语义基本上和new[]相同，他们的实现类似这样：
　　void * operator new[](size_t size)
　　{
　　cout <<"new size of array in new[](): "<　　int *g =(int *) malloc(sizeof(size));
　　return g;
　　}
　　void operator delete[](void* p)
　　{
　　cout <<"delete address of array pointer in delete[](): "<

　　free(p);
　　}
　　3. operator new和delete函数的实现
　　operator new实际上总是以标准的C malloc()完成，虽然并没有规定非得这么做不可。同样，operator delete也总是以标准得C free()来实现，不考虑异常处理的话他们类似下面的样子：
　　extern void* operator new( size_t size )
　　{
　　if( size == 0 )
　　size = 1; // 这里保证像 new T[0] 这样得语句也是可行的
　　
　　void *last_alloc;
　　while( !(last_alloc = malloc( size )) )
　　{
　　if( _new_handler )
　　( *_new_handler )();
　　else
　　return 0;
　　}
　　return last_alloc;
　　}
　　extern void operator delete( void *ptr )
　　{
　　if(ptr) // 从这里可以看出，删除一个空指针是安全的
　　free( (char*)ptr );
　　}

本文来自优快云博客，转载请标明出处：http://blog.youkuaiyun.com/caows/archive/2007/10/30/1856098.aspx

现在知道为什么删除指针前要将指针指空了吧，要不然会产生悬挂指针。呵呵

C++中的operator new与new operator，看上去挺像的两姐妹，却有天壤之别。

operator new

（1）只分配所要求的空间，不调用相关对象的构造函数。当无法满足所要求分配的空间时，则

->如果有new_handler，则调用new_handler，否则

->如果没要求不抛出异常（以nothrow参数表达），则执行bad_alloc异常，否则

->返回0

（2）可以被重载

（3）重载时，返回类型必须声明为void*

（4）重载时，第一个参数类型必须为表达要求分配空间的大小（字节），类型为size_t

（5）重载时，可以带其它参数

new operator

（1）调用operator new分配足够的空间，并调用相关对象的构造函数

（2）不可以被重载

相应地，operator delete与delete operator有相似的特性。

举个例子

class X { public: ………… static void* operator new(size_t size) { return ::operator new(size); } static void operator delete(void* pointee) { ::operator delete(pointee); } ………… }; X* px = new X();

该行代码中的new为new operator，它将调用类X中的operator new，为该类的对象分配空间，然后调用当前实例的构造函数。

delete px;

该行代码中的delete为delete operator，它将调用该实例的析构函数，然后调用类X中的operator delete，以释放该实例占用的空间。

new operator与delete operator的行为是不能够也不应该被改变，这是C++标准作出的承诺。而operator new与operator delete和C语言中的malloc与free对应，只负责分配及释放空间。但使用operator new分配的空间必须使用operator delete来释放，而不能使用free，因为它们对内存使用的登记方式不同。反过来亦是一样。

你可以重载operator new和operator delete以实现对内存管理的不同要求，但你不能重载new operator或delete operator以改变它们的行为。

当重载operator new时，可以提供更多的参数，在new一个对象时，通过在关键字new后的括号传递额外的参数。比如以下的类

class A { public: ………… static void* operator new(size_t size, const string& example) { cout << example << endl; return ::operator new(size); } ………… }; A* pa = new (“This will be printed out in operator new”) A();

新标准的C++允许以这样的方式传递一个名为nothrow的参数，以表明当为该对象分配空间失败时，不抛出异常，而是返回0，以兼容旧标准new的行为。比如

class B {}; B* pb = new (nothrow) B();

当然这只能对那些使用默认operator new操作符的类。对已经重载了operator new的类（比如上面的X和A），如果不声明能接受nothrow参数，自然无法享受C++标准带来的礼物。

--------

我们经常看到这么一句话： operator new 可以重载， placement new 不可重载。其实此处所说的不可重载应该是指全局的 placement new 不可重载，对于类域中的 placement new 是可以重载的，而且只要重载了任何一种形式的 operator new 都应该顺便重载 placement new ，即 void * operator new(std::size_t count, void *ptr) 。

操作符重载一般用于特定类型，名字解析过程同一般的函数重载。 Operator new 由于其特殊性，编译器提供了默认提供 6 种全局重载形式，同时还允许用户提供自定义的全局 operator new ，其参数甚至可以和全局版本一样，除全局 placement new 外。对于类域，任何形式的 new 都是可以重载的，包括 placement new 形式。

全局的 operator new( 函数 ) 有六种重载形式

void *operator new(std::size_t count)

throw(std::bad_alloc); // 一般的版本

void *operator new(std::size_t count, // 兼容早版本的 new

const std::nothrow_t&) throw(); // 内存分配失败不会抛出异常

void *operator new(std::size_t count, void *ptr) throw(); //placement 版本

void *operator new[](std::size_t count) //

throw(std::bad_alloc);

void *operator new[](std::size_t count, //

const std::nothrow_t&) throw();

void *operator new[](std::size_t count, void *ptr) throw();

重载 operator new 规则