Question

我一直在努力创建一个自定义分配器作为一个有趣的练习/练习，我遇到了创建数组的两个潜在问题。对于典型的分配呼叫，我将使用malloc和placement new。但是，当我去创建一个数组时，我对它应该如何完成感到困惑。有一次，我注意到某些地方似乎placement new可能对here等数组不安全。在尝试将placement new用于数组时，我也遇到了自己的错误。我会得到

的错误

`错误C2679：binary'='：找不到运算符，它采用'SomeClass *'类型的右手操作数（或者没有可接受的转换）

我理解错误（我相信）但我希望通过我的数组构造方法解决错误。我有两个问题

1）分配器如何在不使用new[]的情况下创建数组？是placement new吗？如果是这样，那么我在上面发布的链接中提到的潜在危险呢？

2）如果我想使用placement new并在数组中的每个元素上调用它，为什么我会得到上面提到的错误？

#include <stdio.h>
#include <new>

class SomeClass{
public:
    SomeClass() {
        printf("Constructed\n");
    }

    ~SomeClass() {
        printf("Destructed\n");
    }
};

void* SomeAllocationFunction(size_t size) {
    return malloc(size);
}

template<typename Type>
Type* SomeArrayAllocationFunction(size_t count){
    Type* mem = (Type*)SomeAllocationFunction(sizeof(Type) * count);

    for(unsigned int i = 0; i < count; ++i)
    {
        mem[i] = new(mem + i) Type();
    }

    return mem; 
}

int main(void){
    SomeClass* t = SomeArrayAllocationFunction<SomeClass>(2);
}

Answer 1

mem[i]的类型为Type&，而new(mem + i) Type();的类型为Type*。这些显然是不兼容的类型，无法分配。我相信你可以完全删除作业，它会解决，仍然会为你初始化那个位置的内存。

我仍然会稍微谨慎地实现你自己的数组分配器（例如vector的自定义分配器会更明显）。

Answer 2

1）分配器如何在不使用new []的情况下创建数组？这是新的安置吗？如果是这样，那么我在上面发布的链接中提到的潜在危险呢？

链接中的问题是误解了事情的运作方式。每个实现都有一个实现定义的方法来记录有关已分配数组的信息。单个对象不需要此信息，因为它由客户端通过delete的实现进行管理。

使用数组，实现必须记录诸如元素计数，析构函数（如果适用），元素大小......这些东西通常存储在返回分配的开头，并且实现明显抵消了大小适当的分配请求。因此，实际尺寸是偏移的，以便适应这些隐藏值。这就是为什么除非你的分配器执行额外的簿记（btw，malloc(sizeof...)和集合接口带来的），std::allocator将无效。

要正确记录此信息，您可以定义static void* operator new[]。要通过放置在此方案中合并您自己的分配器，您可以使用以下方法：

// quick/dirty/incomplete illustration:
#include <stdio.h>
#include <new>
#include <cstdlib>

class t_allocator {
public:
    t_allocator() {
    }

    ~t_allocator() {
    }

public:
    void* allocate(const size_t& size) {
        return malloc(size);
    }
};

class SomeClass {
public:
    SomeClass() {
        printf("Constructed\n");
    }

    ~SomeClass() {
        printf("Destructed\n");
    }

public:
    static void* operator new[](size_t size, t_allocator& allocator) {
        return allocator.allocate(size);
    }

    /* in case static void* operator new[](size_t size, t_allocator& allocator) throws: */
    static void operator delete[](void* object, t_allocator& allocator) {
        /* ... */
    }

    static void operator delete[](void* object) {
        /* matches t_allocator::allocate */
        free(object);
    }
};

int main(void) {
    t_allocator allocator;
    SomeClass* t(new (allocator) SomeClass[2]);

    delete[] t;
    t = 0;

    return 0;
}

请注意，如果您的分配器可能会抛出，您将同样实现展示位置operator delete[]。

如果你想让你的分配器做一些簿记，那就太乱了。就个人而言，我认为这种情况并没有被语言很好地实现，特别是因为数组初始化没有很好地实现。在这种情况下，总会有一个额外的步骤来执行构建或破坏，或者一些全局可访问的数据。

2）如果我想使用placement new并在数组中的每个元素上调用它，为什么我会得到上面提到的错误？

如果您要创建一个不通过operator new / operator new[]的分配器，则需要显式构造元素。扩展上面的例子，你需要一个名为delete[]的destroy方法，然后告诉this释放/重用内存（而不是使用上面的free）。

如果你只是想要一个快速解决方案，你需要使用分配或分配器来获取析构函数，大小和元素数。在该情况下，您不使用new[] / delete[]。

修改

如果你想自己管理这些书，这里有一种方法（可以有很多方向）：

#include <cassert> #include <stdio.h> #include <new> #include <cstdlib> class t_allocator { public: t_allocator() { } ~t_allocator() { } public: /** tracks an array allocation's data. acts as a scope container for the allocation/types. */ class t_array_record { public: typedef void (*t_destructor)(void* const); template<typename T> t_array_record(T*& outObjects, t_allocator& allocator, const size_t& count) : d_mem(allocator.allocate(sizeof(T), count)), d_destructor(t_allocator::t_array_record::Destruct<T>), d_size(sizeof(T)), d_count(count), d_allocator(allocator) { assert(this->d_mem); /* mind exceptions */ char* const cptr(reinterpret_cast<char*>(this->d_mem)); for (size_t idx(0); idx < this->d_count; ++idx) { /* assignment not required here: */ new (&cptr[this->d_size * idx]) T(); } outObjects = reinterpret_cast<T*>(this->d_mem); } ~t_array_record() { assert(this->d_mem); char* const cptr(reinterpret_cast<char*>(this->d_mem)); for (size_t idx(0); idx < this->d_count; ++idx) { const size_t element(this->d_count - idx - 1U); this->d_destructor(& cptr[this->d_size * element]); } this->d_allocator.free(this->d_mem); } private: template<typename T> static void Destruct(void* const ptr) { T* const obj(reinterpret_cast<T*>(ptr)); obj->~T(); } private: void* const d_mem; t_destructor d_destructor; const size_t d_size; const size_t d_count; t_allocator& d_allocator; public: t_array_record(const t_array_record&); t_array_record& operator=(const t_array_record&); }; public: void* allocate(const size_t& size, const size_t& count) { return malloc(size * count); } void free(void* const mem) { ::free(mem); } };

演示：

class SomeClass { public: SomeClass() { printf("Constructed\n"); } virtual ~SomeClass() { printf("Destructed\n"); } virtual void greet() { printf("hi: %p\n", this); } private: SomeClass(const SomeClass&); SomeClass& operator=(const SomeClass&); }; class SomeDer : public SomeClass { static int& N() { static int a(0); return ++a; } public: SomeDer() : d_number(N()) { printf("Ctor-%i\n", this->d_number); } virtual ~SomeDer() { printf("~Der%i-", this->d_number); } virtual void greet() { printf("Der%i-", this->d_number); SomeClass::greet(); } private: const int d_number; /* << so we have different sized types in the example */ }; template<typename T> void TryIt(const size_t& count) { t_allocator allocator; T* things(0); t_allocator::t_array_record record(things, allocator, count); for (size_t idx(0); idx < count; ++idx) { things[idx].greet(); } } int main() { TryIt<SomeClass>(3); TryIt<SomeDer>(9); return 0; }

如何在可能使用placement new时创建数组

2 个答案: