×
广告

C++ 里面的new,operator new ,placement new的关系和区别

96
爱秋刀鱼的猫
2018.04.21 15:59* 字数 427

最近在思考c++里面空间分配的机制,里面涉及到几个概念。什么是new,什么是malloc?什么是operator new?什么是placement new ?
对于初学者,可能不需要考虑这个问题,因为 只需要会写 int * p = new int[10] ; 就可以了。

但是,这个明白这个,对理解c++还是很有帮助哒~

对于如下的代码,如果看明白了,就基本上理解什么是new,什么是operator new ,什么是 placement new 了。

class Test
{
public:
    Test(int n) : n_(n)
    {
        cout << "构造函数 : Test(int n) : n_(n)" << endl;
    }
    Test(const Test& other)
    {
        cout << "Test(const Test& other)" << endl;
    }
    ~Test()
    {
        cout << "~Test()" << endl;
    }
    void *operator new(size_t size)//普通情况调用,标注为0
    {
        cout << "mark 0 : void* operator new(size_t size)" << endl;
        void* p = malloc(size);
        return p;
    }
    void operator delete(void* p)
    {
        cout << "void operator delete(void* p)" << endl;
        free(p);
    }
    void operator delete(void* p, size_t size)//如果上面那个和这个delete都有,那么调用上面的。
    {
        cout << "void operator delete(void* p, size_t size)" << endl;
        free(p);
    }

    void* operator new(size_t size, void* p)//另一种情况调用,标注为2
    {
        cout << "mark 2 : run" << endl;
        return p;
    }

    int n_;
};

void* operator new[](size_t size) {
    cout << "operator new[] , 全局非test类调用这个" << endl;
    void * p = malloc(size);
    return p;
}

void * operator new(size_t size) {
    cout << "operator new , 全局非test类调用这个" << endl;
    void * p = malloc(size);
    return p;
}

void operator delete[](void * p) {
    cout << "operator delete[] , 全局非test类调用这个 " << endl;
    free(p);
}

void operator delete(void * p) {
    cout << "operator delete , 全局非test类调用这个 " << endl;
    free(p);
}

int main(void)
{
    //第一个知识点
    Test* p1 = new Test(100);    // new operator = operator new + 构造函数的调用 调用标注0
    delete p1;                  //delete = 析构函数的调用+operator delete

    //第二个知识点
    char* str = new char[100]; //调用标注3
    delete[] str;

    char * str2 = new char;
    delete str2;


    //第三个知识点
    char chunk[10];
    Test* p2 = new (chunk) Test(200);    //operator new(size_t, void *_Where)+构造函数的调用
                                         // placement new,不分配内存+ 构造函数的调用
                                         //调用标注2
    cout << p2->n_ << endl;
    p2->~Test();                        // 显式调用析构函数,因为没有分配内存,所以直接调用析构函数
    return 0;
}

运行结果:


  • 小结 , 我的理解是 :
  1. 运算符 new = 先调用函数 operator new 分配空间 + 然后调用构造函数。

  2. 对于operator new 函数内部,他是通过再调用malloc函数,进行空间分配的(当然也可以重写一个自己的空间分配器)。

  3. placement new 指的是,不进行分配空间,而是在指定的空间上面进行调用构造函数。当然,在析构的时候,也只能显示的调用析构函数。(因为并不是真正的释放空间)

这个有一个问题:

class Test
{
public:
    Test() : n_(0)
    {
        cout << "构造函数 : Test() : n_(0)" << endl;
    }

    void operator delete[](void* p, size_t size)
    {
        cout << "void operator delete(void* p, size_t size)" << endl;
        cout<<size<<endl;     # 问题,这个size 的输出是多少?
        free(p);
    }
};

int main(void)
{
    cout<<"sizeof ptr : "<<sizeof(int *)<<endl;

    Test * p2 = new Test[10];
    delete [] p2;
}
# 程序delete[] 函数里面size的输出是多少? 
# 答案是:44

但是,为什么是44?
一个对象的大小是4,10个对象的大小应该是40,这个4表示的是什么?

分配空间的伪代码是:

count =10;
size =sizeof(Test)
void * _p =malloc(Count*Size+4)
void * tp =(void *)(((char*)p)+4)
for I in 0..10:
    tp=(void*)(((char*)tp)+Size*I)
    ((Test*)tp)->Super();
*(int*)_p=Count
sp =(Test*)((int*)_p+1);

也就是说,分配出来的空间的前4个字节存放的是一个int,表达的是对象数组的长度。这样delete[]的时候,才知道要delete的对象的个数是多少。


参考 : https://blog.csdn.net/jmh1996/article/details/77647976

C/C++笔记
Web note ad 1