C++ 自定义内存分配器设计

我有一个内存分配器，它为一个对象分配内存，并用任何给定的参数调用它的构造函数，见下文

    // 0 args to constructor
    template <class T>
    inline T* AllocateObject() { return new (InternalAllocate(sizeof(T), alignof(T))) T(); }

    // 1 args to constructor
    template <class T, typename arg0>
    inline T* AllocateObject(const arg0& a0) { return new (InternalAllocate(sizeof(T), alignof(T))) T(a0); }

    template <class T, typename arg0>
    inline T* AllocateObject(arg0& a0) { return new (InternalAllocate(sizeof(T), alignof(T))) T(a0); }

    // 2 args to constructor
    template <class T, typename arg0, typename arg1>
    inline T* AllocateObject(arg0& a0, arg1& a1) { return new (InternalAllocate(sizeof(T), alignof(T))) T(a0,a1); }

    template <class T, typename arg0, typename arg1>
    inline T* AllocateObject(const arg0& a0, arg1& a1) { return new (InternalAllocate(sizeof(T), alignof(T))) T(a0,a1); }

    template <class T, typename arg0, typename arg1>
    inline T* AllocateObject(arg0& a0, const arg1& a1) { return new (InternalAllocate(sizeof(T), alignof(T))) T(a0,a1); }

    template <class T, typename arg0, typename arg1>
    inline T* AllocateObject(const arg0& a0, const arg1& a1) { return new (InternalAllocate(sizeof(T), alignof(T))) T(a0,a1); }

    //.........

//0个参数到构造函数
模板
内联T*AllocateObject（）{return new（InternalAllocate（sizeof（T），alignof（T）））T（）；}
//1参数到构造函数
模板
内联T*AllocateObject（const arg0&a0）{返回新的（InternalAllocate（sizeof（T），alignof（T）））T（a0）；}
模板
内联T*AllocateObject（arg0&a0）{返回新的（InternalAllocate（sizeof（T），alignof（T）））T（a0）；}
//2个参数到构造函数
模板
内联T*AllocateObject（arg0&a0，arg1&a1）{返回新的（内部分配（sizeof（T），alignof（T）））T（a0，a1）；}
模板
内联T*AllocateObject（const arg0&a0，arg1&a1）{返回新的（InternalAllocate（sizeof（T），alignof（T）））T（a0，a1）；}
模板
内联T*AllocateObject（arg0&a0，const arg1&a1）{返回新的（InternalAllocate（sizeof（T），alignof（T）））T（a0，a1）；}
模板
内联T*AllocateObject（常量arg0和a0，常量arg1和a1）{返回新的（内部分配（sizeof（T），alignof（T）））T（a0，a1）；}
//.........

正如您所看到的，调用的数量随着参数数量的增加而快速增长。对于每个参数，我必须交替使用“const”和“non-const”，以确保它与我传递的任何参数都能很好地配合。（特别是，能够通过引用和通过值进行传递）

有没有比重复这个方案更好的方法来完成同样的任务？基本上我看到的是8-10个最大参数，我觉得这不太可行

---

谢谢

您可以使用可变模板

template <class T, class... Args>
inline T* AllocateObject(Args&&... args) {
    return new (InternalAllocate(sizeof(T), alignof(T)))
               T(std::forward<Args>(args)...);
}

模板
内联T*分配对象（Args&&…Args）{
返回新的（内部分配（sizeof（T）、alignof（T）））
T（标准：正向（参数）…）；
}

std:：forward

调用将保留所有引用和

const

ness

---

---

注意，这需要C++11。最新的编译器已经支持可变模板（不过我不确定微软是否支持）。

您可以使用可变模板

template <class T, class... Args>
inline T* AllocateObject(Args&&... args) {
    return new (InternalAllocate(sizeof(T), alignof(T)))
               T(std::forward<Args>(args)...);
}

模板
内联T*分配对象（Args&&…Args）{
返回新的（内部分配（sizeof（T）、alignof（T）））
T（标准：正向（参数）…）；
}

std:：forward

调用将保留所有引用和

const

ness

---

---

注意，这需要C++11。大多数最新的编译器已经支持可变模板（不过我不确定Microsoft是否支持）。

不是模板解决方案，而是可变参数

#define

可以帮助您解决此问题。
确切的格式取决于您的编译器，但在MSVC中是这样的：

#define ALLOCATE_OBJECT(TYPE, ...) \
    ( new( InternalAllocate(sizeof(TYPE), alignof(TYPE)) ) TYPE(__VA_ARGS__) )

---

不是模板解决方案，而是变量参数

#define

可以帮助您解决此问题。
确切的格式取决于您的编译器，但在MSVC中是这样的：

#define ALLOCATE_OBJECT(TYPE, ...) \
    ( new( InternalAllocate(sizeof(TYPE), alignof(TYPE)) ) TYPE(__VA_ARGS__) )

---

---

如果您从不更改参数，只需使用

consttype&

一次处理所有4个版本。C++11适合您吗？它包含了针对这一特定问题的语言更新。编辑：你使用的是

alignof

，我真为没有仔细阅读而感到羞愧。：）FireRain的答案正是我所指的。不幸的是，C++11不是一个选项。你能举个例子吗？chris？还有-如果对象的C构造函数可能会更改参数，那该怎么办？如果你从不更改参数，只需使用

const type&

一次处理所有4个版本。C++11适合你吗？它包含了针对这一特定问题的语言更新。编辑：你使用的是

alignof

，我真为没有仔细阅读而感到羞愧。：）FireRain的答案正是我所指的。不幸的是，C++11不是一个选项。你能举个例子吗？chris？还有-如果对象的C构造函数可能会更改参数，那么这将如何工作？如果你需要强制执行最大数量的参数，

static\u cast

结合

sizeof args…

将很好地完成这项任务。可惜，目前还没有任何编译器真正支持它。（我认为gcc的一个非常新的版本确实有点新）@BobFincheimer，我在gcc上使用可变模板已经有一段时间了。它不是早在4.6.1版本吗？@BobFincheimer-clang和gcc-supports-iffully@BobFincheimerGCC和clang支持可变模板。我只是不确定MSVC，它确实有问题。现在可能已经解决了，但我不使用Windows。如果您需要强制执行最大数量的参数，

static\u cast

结合

sizeof args…

将很好地解决这个问题。遗憾的是，现在还没有任何编译器真正支持它。（我认为gcc的一个非常新的版本确实有点新）@BobFincheimer，我在gcc上使用可变模板已经有一段时间了。它不是早在4.6.1版本吗？@BobFincheimer-clang和gcc-supports-iffully@BobFincheimerGCC和clang支持可变模板。我只是不确定MSVC，它确实有问题。现在可能已经修好了，但我不使用Windows。