Question

我想尝试TBB的scalable_allocator，但是当我不得不替换我的一些代码时感到很困惑。这是分配器的分配方式：

SomeClass* s = scalable_allocator<SomeClass>().allocate( sizeof(SomeClass) );

编辑：上面显示的不是如何使用scalable_allocator完成分配。作为ymett correctly mentioned，分配如下：

int numberOfObjectsToAllocateFor = 1;
SomeClass* s = scalable_allocator<SomeClass>().allocate( numberOfObjectsToAllocateFor );
scalable_allocator<SomeClass>().construct( s, SomeClass());
scalable_allocator<SomeClass>().destroy(s);
scalable_allocator<SomeClass>().deallocate(s, numberOfObjectsToAllocateFor);

这就像使用malloc一样：

SomeClass* s = (SomeClass*) malloc (sizeof(SomeClass));

这是我想要替换的代码：

SomeClass* SomeClass::Clone() const
{
   return new SomeClass(*this);
}//Clone

所以尝试了一个程序：

#include<iostream>
#include<cstdlib>
using namespace std;

class S
{
        public:
        int i;
        S() {cout<<"constructed"<<endl;}
        ~S() {cout<<"destructed"<<endl;}
        S(const S& s):i(s.i) {}
};

int main()
{
        S* s = (S*) malloc(sizeof(S));
        s = (S*) S();//this is obviously wrong
        free(s);
}

在这里我发现调用malloc不会实例化对象（我之前从未使用过malloc）。因此，在确定如何将*this传递给复制文件之前，我想知道在使用malloc时如何实例化对象。

Answer 1

从placement new获取原始内存后，您需要使用malloc。

void* mem = malloc(sizeof(S));
S* s = new (mem) S(); //this is the so called "placement new"

当你完成对象时，你必须确保显式调用它的析构函数。

s->~S();
free(mem);

Answer 2

使用placement new

#include <memory>
//...
int main()
{
        S* s = (S*) malloc(sizeof(S));
        s = new (s) S();//placement new
        //...
        s->~S();
        free(s);
}

Answer 3

allocate()的参数是对象的数量，而不是以字节为单位的大小。然后调用分配器的construct()函数来构造对象。

scalable_allocator<SomeClass> sa;
SomeClass* s = sa.allocate(1);
sa.construct(s, SomeClass());
// ...
sa.destroy(s);
sa.deallocate(s);

如果想将它与标准库容器或其他std allocator识别类型一起使用，只需给它分配器类型。

std::vector<SomeClass, scalable_allocator<SomeClass>> v;

使用malloc而不是new，并在创建对象时调用复制构造函数

3 个答案: