我需要实现一个容器来容纳一定数量的元素，并且出于某种原因，它必须在没有任何堆分配的情况下工作。另一个要求是，容器元素不应以任何方式复制或移动。它们必须直接构建到容器分配的内存中。
为此，我决定使用placement new并将内存管理完全委托给容器实现（在以下位置找到了一些有关placement new的有用信息）drdobbs).
找到一个运行示例here。
（请注意，使用new uint8_t[size] and std::queue只是为了保持示例简单。我的真实代码有更复杂、无堆的实现。）
到目前为止，这完全有效，因为客户端代码必须通过以下调用将元素放入容器中：
executer.push(new (executer) MyRunnable("Hello", 123));
现在我想要删除重复写入的需要executer在这份声明中。我宁愿写一些类似的东西：
executer.pushNew(MyRunnable("Hello", 123));
or
executer.pushNew(MyRunnable, "Hello", 123);
也许可以通过提供适当的模板，但我未能编写模板（请不要使用预处理器宏）。
我发现了一些有用的信息std::allocator这里在drdobbs但不知道如何将其应用于我的问题（此外，该文章是 2000 年的文章，因此不要利用可能的 C++11 优势）。
有人可以帮助我找到一种方法，不再需要给予executer twice?
Edit:审核成功后Jarod42的答案，我更新了我的运行示例代码here.
对于历史，这里是我最初问题的原始示例代码：
#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();
}
