C++ operator new & placement new

C++的new&delete

new的过程

new的过程：先分配memory，再调用ctor

我们常用的创建对象的方法有两种

Complex c(1,2);					//栈
Complex *pc = new Complex(1,2);	//堆

第一种创建出来的对象将保存在栈上，第二种则在堆上，必须手动回收内存空间（通过delete）

为了解释new的过程，我们先建立一个Complex类

class Complex
{
public:
	Complex(...) {...}//构造函数
	...
private:
	double real;
    double imag;
};

当我们使用new构建Complex类对象的时候

Complex *pc = new Complex(1,2);

当我们使用new这一个动作，在堆上动态创建一个对象时，编译器实际上帮你做了三件事：

Complex *pc;

//1.分配内存（调用 operator new() 函数）
void* memory = operator new(sizeof(Complex));
//2.转型
pc = static_cast<Complex*>(memory);
//3.调用构造函数
pc->Complex::Complex(1,2);

分配内存：operator new也是一个函数，其内部调用malloc(n)，拿到sizeof(Complex)大小的内存空间；这时候我们得到指向内存空间始址的指针memory，它是一个指向viod类型的指针
转型：用static_cast函数，把步骤①得到的指针memory（这是一个pointer to void）转换为pointer to Complex，并将其赋值到pc（步骤①和②可以写在一起）
调用构造函数：步骤②得到的指针pc指向的内存空间，即为新对象的起始内存地址；于是编译器将通过指针pc调用对象的构造函数

所以从结果上看，这两段代码是等效的

//代码1.
Complex *pc = new Complex(1,2);
//代码2.
Complex *pc;
void* memory = operator new(sizeof(Complex));	
pc = static_cast<Complex*>(memory);			
pc->Complex::Complex(1,2);

malloc和new的区别在于，当malloc失败时，它不会调用分配内存失败处理程序new_handler，因此我们还是要尽可能的使用new，除非有一些特殊的需求

delete的过程

delete的过程：先调用dtor，再释放memory

我们再建立一个包含指针的类String：

class String {
public:
	...
	~String()
    {delete[] m_data;}
	...
private:
	char* m_data;
};

当我们试用new&delete时：

String* ps = new String("HELLO")；
...
delete ps;

编译器在delete这里实际上帮你做了两件事：

String::~String(ps);	//1.调用析构函数
operator delete(ps);	//2.释放内存

调用析构函数：由于String类是包含指针的，所以设计时不能使用默认析构函数，而是重载一个符合需求的析构函数，在我们delete ps时，编译器第一步就是调用我们重载后的析构函数（没有重载则调用默认）
释放内存：operator delete和operator new一样也是一个函数，其内部调用free(ps)

new的三种形态

有的朋友可能被上面的new和operator new搞晕了，实际上在C++中提到new，至少可能代表以下三种含义：new operator，operator new，placement new

new operator

new operator 就是 new 操作符，不能被重载

我们上面所说的new，都是指new operator，也就是我们平时使用的new

operator new

operator new 是函数，可以被重载，new operator 调用它用来分配内存，通过重载它，可以改变 new operator 的功能

默认有三种

void* operator new (std::size_t size) throw (std::bad_alloc); 
void* operator new (std::size_t size, const std::nothrow_t& nothrow_constant) throw(); 
void* operator new (std::size_t size, void* ptr) throw();

第一种分配size个字节的存储空间，并将对象类型进行内存对齐。如果成功，返回一个非空的指针指向首地址。失败抛出bad_alloc异常。（A* a = new A; 调用第一种
第二种在分配失败时不抛出异常，它返回一个NULL指针。 (A* a = new(std::nothrow) A; //调用第二种
第三种是 placement new 版本，它本质上是对 operator new 的重载，定义于#include 中，它不分配内存，调用合适的构造函数在 ptr 所指的地方构造一个对象，之后返回实参指针ptr，下文细谈

重载 operator new

class Complex
{
public:
	Complex(...) {...}//构造函数
	...
    //重载第一种
    void* operator new(size_t size){
		cout << "operator new called\n" << endl;
        //通过::operator new调用了原有的全局的new
		return ::operator new(size);
	}
    void operator delete(void* pointer)
	{
		cout << "operator delete" << endl;
		::operator delete(pointer);
	}
private:
	double real;
    double imag;
};

然后你可以直接调用 Complex::operator new()，或者使用 new 来调用

int main()
{
    Complex* pc2 = new Complex(1,2);
}

输出

operator new called
operator delete

这里通过::operator new调用了原有的全局的new，也就相当于是在分配内存之前输出一句话

如上代码所示，delete 也有 delete operator 和 operator delete 之分，后者也是可以重载的。并且，如果重载了 operator new，就应该也相应的重载 operator delete，这是良好的编程习惯

重载 operator new 需要注意以下几点：

重载时，返回类型必须声明为void*
重载时，第一个参数类型必须为表达要求分配空间的大小（字节），类型为 size_t
重载时，可以带其它参数

带其他参数的重载：

void* operator new(size_t size, string str) {
    cout << "operator new called\n" << endl;
    cout << "with string:" << str << endl;
    //通过::operator new调用了原有的全局的new
    return ::operator new(size);
}

调用时就可以这样操作

Complex* pc = new("Test") Complex(1,2);

placement new

placement new 是 c++ 实现的 operator new 版本，它的实现如下

// Default placement versions of operator new.
inline void* operator new(std::size_t, void* __p) _GLIBCXX_USE_NOEXCEPT
{ return __p; }
inline void* operator new[](std::size_t, void* __p) _GLIBCXX_USE_NOEXCEPT
{ return __p; }

// Default placement versions of operator delete.
inline void operator delete  (void*, void*) _GLIBCXX_USE_NOEXCEPT { }
inline void operator delete[](void*, void*) _GLIBCXX_USE_NOEXCEPT { }
//@}

可以看到实际上它就返回了传进来的地址，根据operator的第二个例子，通过重载全局的operator new之后，new函数的操作就被改变了。也就能猜出，在调用new的时候参数需要加上一个地址，placement new的功能就是在这个地址之上进行构造。

placement new 的使用步骤如下：

//1.分配内存
char* buff = new char[ sizeof(Complex) * N ];
memset( buff, 0, sizeof(Foo)*N );
//2.构建对象
Complex* pc = new (buff)Complex;
//3.使用对象
pc->XXXXXX();
//4.析构对象，显式的调用类的析构函数
pc->~Complex();
//5.销毁内存
delete[] buff;

上面5个步骤是标准的placement new的使用方法

placement new 是用来实现定位构造的，因此可以实现 new operator 三步操作中的调用构造函数这一步（在取得了足够内存空间后，在这块内存空间是上构造一个对象）

上面写的pc->Complex::Complex(1,2);这句话并不是一个标准的写法，正确的写法是使用 placement new：

#include <new.h>

int main()
{
    char* buff = new char[ sizeof(Complex) ];
	Complex* pc = new(buff) Complex(1,2);
    ...
}

placement new 它实现了在指定内存地址上用指定类型的构造函数来构造一个对象的功能，这块指定的地址既可以是栈，又可以是堆，placement 对此不加区分

除非特别必要，不要直接使用placement new ，这毕竟不是用来构造对象的正式写法，只不过是new operator的一个步骤而已。使用new operator地编译器会自动生成对placement new的调用的代码，因此也会相应的生成使用delete时调用析构函数的代码

如果是像上面那样在栈上使用了placement new，则必须手工调用析构函数，这也是显式调用析构函数的唯一情况

pc->~Complex();

当我们觉得默认的new operator对内存的管理不能满足我们的需要，而希望自己手工的管理内存时，placement new就有用了。STL中的allocator就使用了这种方式，借助placement new来实现更灵活有效的内存管理。

posted @ 2020-02-10 20:50 KelvinVS 阅读(813) 评论(0) 编辑收藏举报

刷新页面返回顶部

KelvinVS