我需要实现一个容器来容纳大量元素，并且由于某种原因，它必须在没有任何堆分配的情况下工作。另一个要求是，不应以任何方式复制或移动容器元素。它们必须直接构建到容器分配的内存中。
为此，我决定使用placement new 并将内存管理完全委托给容器实现（在drdobbs找到了一些关于placement new 的有用信息）。
在这里可以找到一个运行示例。（请注意，使用new uint8_t[size]andstd::queue只是为了保持示例简单。我的真实代码具有更复杂、无堆的实现。）
到目前为止，这非常有效，因为客户端代码必须通过以下调用将元素放入容器中：
executer.push(new (executer) MyRunnable("Hello", 123));
现在我想删除executer此语句中重复写入的需要。我宁愿写一些类似的东西，例如：
executer.pushNew(MyRunnable("Hello", 123));
或者
executer.pushNew(MyRunnable, "Hello", 123);
也许通过提供适当的模板，但我没有写一个（请不要使用预处理器宏）。
std::allocator我在drdobbs找到了一些有用的信息，但不知道如何将其应用于我的问题（此外，这篇文章是 anno 2000 的，所以不要利用可能的 C++11 优势）。
有人能帮我找到一种不再需要executer两次的方法吗？
编辑：成功批准Jarod42的答案后，我在这里更新了我正在运行的示例代码。
对于历史，这里是我最初问题的原始示例代码：
#include <iostream>
#include <queue>
class Runnable {
// Runnable should be uncopyable and also unmovable
Runnable(const Runnable&) = delete;
Runnable& operator = (const Runnable&) = delete;
Runnable(const Runnable&&) = delete;
Runnable& operator = (const Runnable&&) = delete;
public:
explicit Runnable() {}
virtual ~Runnable() {}
virtual void run() = 0;
};
class MyRunnable: public Runnable {
public:
explicit MyRunnable(const char* name, int num): name(name), num(num) {}
virtual void run() override {
std::cout << name << " " << num << std::endl;
}
private:
const char* name;
int num;
};
class Executer {
// Executer should be uncopyable and also unmovable
Executer(const Executer&) = delete;
Executer& operator = (const Executer&) = delete;
Executer(const Executer&&) = delete;
Executer& operator = (const Executer&&) = delete;
public:
explicit Executer() {
}
void* allocateEntry(size_t size) {
// this heap allocation is just to keep this example simple
// my real implementation uses it's own memory management instead (blockpool)
return new uint8_t[size];
}
void push(Runnable* entry) {
queue.push(entry);
}
template <typename R> // this don't works
void pushNew(R) {
push(new (*this) R);
}
inline friend void* operator new(size_t n, Executer& executer) {
return executer.allocateEntry(n);
}
void execute() {
while (queue.size() > 0) {
Runnable* entry = queue.front();
queue.pop();
entry->run();
// Now doing "placement delete"
entry->~Runnable();
uint8_t* p = reinterpret_cast<uint8_t*>(entry);
delete[] p;
}
}
private:
// this use of std::queue is just to keep this example simple
// my real implementation uses it's own heap-less queue instead
std::queue<Runnable*> queue {};
};
int main() {
Executer executer;
executer.push(new (executer) MyRunnable("First", 1));
executer.push(new (executer) MyRunnable("Second", 2));
executer.push(new (executer) MyRunnable("Third", 3));
// but want to use it more like one this
//executer.pushNew(MyRunnable("Fifth", 5)); // how to implement it?
//executer.pushNew(MyRunnable, "Sixth", 6); // or maybe for this usage?
executer.execute();
}