我对我的 new 宏有一个#define，以使用我自己的分配器，例如 MYNEW(Type, Allocator) 我将在其中分配一些原始内存使用 malloc，然后使用 placement new 在原始内存上分配类型，例如

#define MYNEW(Type, Allocator) Allocator->Alloc<Type>(sizeof(Type));`
template<typename Type>
Type* Alloc(unsigned int size) // Allocator::Alloc<Type>
{
    return (Type*)new(malloc(reportedSize)) Type;
}

但是，当 Type 没有默认构造函数时，我遇到了问题。我尝试过的一种情况是执行诸如 MYNEW_1(Type, Allocator, ConVar1) 之类的操作，其中 ConVar1 将被传递，例如

#define MYNEW_1(Type, Allocator, ConVar1) Allocator->Alloc<Type>(sizeof(Type), ConVar1);`
template<typename Type, typename ConVarType>
Type* Alloc(unsigned int size, ConVarType Convar1) // Allocator::Alloc<Type>
{
    return (Type*)new(malloc(reportedSize)) Type(Convar1);
}

这种方法的问题在于，对于我的自定义 Vector，我还使用 MYNEW 来分配内存。但是，对于用于我的 Vector 的某些 Type，没有默认构造函数，而且我不知道构造函数可能需要多少变量。

有没有人知道如何解决这个问题？ (当然不用说使用 std::类型而不是我自己的类型。我这样做是为了了解更多信息)。我不希望只是重载 operator new 因为我在那里有内存跟踪，因为我不希望内存被跟踪两次(Alloc 有更多的内部跟踪，但我展示的是简化的示例)并且宁愿只使用 malloc。

最佳答案

看起来您不仅在做自己的自定义分配器，而且您也不一定要尝试定义与 STL 兼容的分配器。然而，我认为认识到 STL 分配器的所有缺点是有用的，它们是为处理这种情况而设计的。 Allocation与 construction 分开:

Notice that [allocator::construct] does not allocate space for the element, it should already be available at p (see member allocate to allocate space).

It is equivalent to [call to placement new that copies an existing object].

一般来说，我相信您有两个选择:(1) 重载 operator new 来处理内存分配并让系统处理构造，或者 (2) 让您的分配器接口(interface)更像STL 分配器接口(interface)。

“重载 operator new”通常用于表示两件事:(1) 替换它，或 (2) 添加 new 的新版本。当我最初回答时，我使用的是第一个意思(实际上应该称为“替换operator new”或“覆盖operator new”)；但仔细考虑一下，我确定真正重载 operator new 会满足您的要求。

我应该提一下，调用重载的operator delete 的语法非常糟糕，许多人仅仅因为这个原因就避免使用这种技术。您可以创建一个函数(例如，deallocate)并使用它，而不是重载 delete。

这种方法的值(value)在于，您遵循将内存分配与对象构造分开的语言标准，而让编译器为您处理对象构造。您不必担心转发运算符，或没有默认构造函数的类，或任何这些问题。

重载operator new/operator delete(当然，我要靠你来充实track和release):

#include <new>
#include <cstdlib>

struct Allocator {
    void track(void* p, const void* container) const;
    void release(void* p, const void* container) const;
};

void* operator new (size_t size, const Allocator& alloc, const void* container)
{
    void* allocated_memory = std::malloc(size);
    if (!allocated_memory) {
        throw std::bad_alloc();
    }

    alloc.track(allocated_memory, container);
    return allocated_memory;
}

void operator delete(void* p, const Allocator& alloc, const void* container)
{
    alloc.release(p, container);
    std::free(p);
}

int main()
{
    Allocator alloc;
    int* i = new (alloc, NULL) int;
    operator delete(i, alloc, NULL);
}

重载 operator new 并使用函数 deallocate:

#include <new>
#include <cstdlib>

struct Allocator {
    void track(void* p, const void* container) const;
    void release(void* p, const void* container) const;
};

void* operator new (size_t size, const Allocator& alloc, const void* container)
{
    void* allocated_memory = std::malloc(size);
    if (!allocated_memory) {
        throw std::bad_alloc();
    }

    alloc.track(allocated_memory, container);
    return allocated_memory;
}

template<typename T> void deallocate(T* p, const Allocator& alloc, const void* container)
{
    p->~T();
    alloc.release(p, container);
    std::free(p);
}

int main()
{
    Allocator alloc;
    int* i = new (alloc, NULL) int;
    deallocate(i, alloc, NULL);
}

您应该考虑的一种情况是当new 成功但构造对象失败时该怎么办。也就是说，当有足够的内存，但由于某些其他原因无法创建对象时。系统实际上足够聪明，可以调用正确的delete(嗯，具有系统认为应该具有的签名的delete)来释放分配的内存；但前提是存在带有该签名的 delete。您可能希望重载operator delete 并提供一个deallocate 函数，其中一个是根据另一个定义的:

void operator delete(void* p, const Allocator& alloc, const void* container)
{
    alloc.release(p, container);
    std::free(p);
}

template<typename T> void deallocate(T* p, const Allocator& alloc, const void* container)
{
    p->~T();
    operator delete(p, alloc, container);
}

关于c++ - 处理自定义分配器中没有默认构造函数，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/10338466/