重载新运算符

Question

是否可以重载 new 运算符，以便不创建对象，而是返回现有对象。

如果这是可能的，那么你如何才能首先创建对象：D

我知道这听起来很奇怪。我试图向客户隐瞒一些细节。我正在 PS2 上制作游戏，我想要使用 New Foo() 语法，但想要一个可以使用的预制对象列表。

我不认为可以规避这个问题，因为 new 运算符返回指向可用内存的指针。

new Foo;

struct Foo
{
    void* operator new(std::size_t)
    {
        // return pre made obj.
    }

};

Answer 1

据我所知，您无法更改 new 它实际构造对象的这一方面。重载运算符只是返回原始内存，然后语言会在该内存中自动构造对象。你无法控制这一步。

无论如何，如果您没有获得 new 对象，那么该语法的意义何在？

Answer 2

http://www.cplusplus.com/reference/std/ new/operator%20new%5B%5D/

应该告诉你所有你需要知道的！

或者甚至可能是这个

http://www.cplusplus.com/reference/std/ new/operator%20new/

operator new 是一个可以覆盖的全局函数。

不要忘记，如果您提供了一个 new 运算符，您还需要提供一个删除运算符。

我猜您正在尝试设置一个内存池，请记住实际测量有和没有的性能，因为恕我直言，它并不总是值得麻烦。

编辑：
阅读你的问题和其他一些答案的字里行间，我的猜测是你真的想单独保留重载的 new/delete 和单例模式。相反，请采用工厂模式方法。

您的所有代码都调用

SomethingStatic::GetNewWhatsit()

函数（而不是构造对象）
它返回数组中的下一个指针。指向您在程序初始化时以正常方式创建的对象的指针数组。

 whatsit* GetNewWhatsit()
 {
  if (num_of_objects > ARRAY_SIZE(whatsit_cache))
   return 0;
  else 
   return whatsit_cache[num_of_objects++];  // post inc. on purpose 
 }

Answer 3

您可以重载operator new，但重载的运算符不会返回对象。它返回对象的内存，并且实现安排调用构造函数。

所以你不能完全做你想做的事。

相反，如果您试图避免的成本是内存分配的成本，那么您的重载可以从预分配的块中分配一些内存。显然，您需要负责跟踪哪些内容是免费的，哪些不是，您面临的挑战是比 PS2 开发套件附带的分配器更高效地完成此任务。这可能并不太难 - 如果您只处理一个类，并且假设没有人从该类派生，那么分配的大小是固定的，那么您就有不公平的优势。

如果您试图避免的成本是调用构造函数，那么operator new 不会帮助您，但是您可以编写一种包装器：

struct FooWrapper {
    Foo *foo;
    FooWrapper(): foo(choose_a_pre_existing_foo()) { }
    ~FooWrapper() {
        foo->reset(); // clear up anything that shouldn't be kept
        return_to_the_pool_for_reuse(foo);
    }
  private:
    FooWrapper(const FooWrapper &);
    FooWrapper &operator=(const FooWrapper &);
};

Foo *choose_a_pre_existing_foo() {
    // possibly some kind of synchronization needed if list is global
    // and program is multi-threaded.
    if list_of_foos.empty() {
        return new Foo();
    } else {
        Foo *f = list_of_foos.back();
        list_of_foos.pop_back();
        return f;
    }
}

Answer 4

重载 new 是充满危险的。它不仅仅是 C++ 的 malloc，它还具有对象生命周期和异常安全等重要语义。

当您调用 new 时，构造函数将被调用。您不想两次构造一个对象，因为您无法明智地销毁它两次。充其量你会泄漏资源。

您可能想要的不仅仅是一个单例，也许尝试这样的东西：

foo.h

struct Foo {
    static Foo instance_a;
    static Foo instance_b;
    enum Predefined {
        ALICE,
        BOB
    };
    static Foo & instance (Predefined);
    // ...
}

foo.cpp

Foo Foo :: instance_a (1, 2, 3);
Foo Foo :: instance_b ("alpha");

namespace {
    Foo alice;
    Foo bob (1, "x");
}

Foo & Foo :: instance (Predefined name) {
    // ...
    return alice;
}

大量的可能性。

Answer 5

如果您想要单个对象，可以使用 Singleton 模式。
如果你想要多个对象，你需要一个 对象池。

Answer 6

您不仅不能修改 operator new 来执行您想要的操作（它只是一个分配函数），您也不应该这样做。颠覆新表达式的含义将使您的代码更难理解，没有任何好处。

如果您想要全新的功能，那就编写代码！在这里，您需要的可能是一个类（我们不能告诉），或者可能只是一个函数：

template<typename T, typename... U>
std::shared_ptr<T> // for one std::shared_ptr seems appropriate
make(U&&... u);

然后客户端代码使用这个类似工厂的函数来获取它需要的对象。该函数实际上有什么作用？它是否使用享元模式缓存对象？它缓存内存而不是对象吗？客户端代码不关心并且不想。它所关心的只是获得它所要求的对象。

同时，函数中的代码会执行所需的操作。如果明天你意识到你错了，你可以更改里面的代码，希望它不会影响其余的。至少它还有战斗的机会。

Answer 7

我建议使用桥接模式。

这意味着您的客户可以像往常一样在一个简单的公共类上调用 new ，该公共类在内部选择构建或不构建什么。

所包含的类对于您的库来说可以是私有的。

Answer 8

使用operator::new的问题是，在调用new之后，编译器会自动生成一个操作码来调用构造函数，因此new本身不负责构造函数。
你想要的是一个单例：

struct Foo
{
    static Foo& NewObject()
    {
        static Foo* _foo = new Foo;
        return *_foo;
    }
}

或某种数组：

struct Foo
{
    static Foo& NewObject()
    {
        static Foo* _foo = new Foo[128];
        static int index = 0;

        if(index == 128)
            index = 0;
        return _foo[index++];
    }
}