c++ - 没有 "new"的多态性

Question

假设我有如下内容:

class A { virtual void g() = 0 }

class B : public A { virtual void g() { ... } }
class C : public A { virtual void g() { ... } }

... f(bool x)
{
  if (x) { return B(); } else { return C(); }
}

bool get_boolean();

int main()
{
  bool b = get_boolean();
  ... x = f(b);
  x.g();
}

有没有办法在不调用 new 的情况下执行上述操作，即仅在堆栈上？

Answer 1

避免动态分配的一个简单方法是使用静态分配，这与动态分配尽可能相反。然而，必须小心完成，因为即使使用非线程程序，也可能会无意中陷入这样一种情况，即代码的两个或多个部分都认为它们“拥有”某个静态分配的对象。更糟糕的是，这些本质上全局变量(即使伪装成单例，或在下面的代码中作为局部静态)本质上充当意大利面条通信的中心枢纽，其中引发困惑的信息在你无法想象、完全不受你控制的地方之间自由传播。

所以，静态分配方案有一些缺点……:-)

但让我们从这里开始:

// Using static allocation.

#include <iostream>
using namespace std;

struct A { virtual void g() = 0; };

struct B : A { virtual void g() override { wcout << "A\n"; } };
struct C : A { virtual void g() override { wcout << "B\n"; } };

A& f( bool const x )
{
    static B    theB;
    static C    theC;

    if( x ) { theB = B(); return theB; } else { theC = C(); return theC; }
}

bool get_boolean() { return false; }

int main()
{
    bool const b = get_boolean();
    A& x = f( b ); 
    x.g();
}

为避免静态分配方案的错误所有权缺点，您​​可以使用 C++ 自动分配 在堆栈上提供存储(C++ 自动分配根据定义是堆栈，一种后进先出分配方案).但这意味着将存储传递给函数。然后该函数可以返回对相关对象的引用:

// Using automatic storage (the stack)

#include <iostream>
using namespace std;

struct A { virtual void g() = 0; };

struct B : A { virtual void g() override { wcout << "A\n"; } };
struct C : A { virtual void g() override { wcout << "B\n"; } };

A& f( bool const x, B& b, C& c )
{
    if( x ) { b = B(); return b; } else { c = C(); return c; }
}

bool get_boolean() { return false; }

int main()
{
    bool const b = get_boolean();
    B   objBStorage;
    C   objCStorage;
    A&  x   = f( b, objBStorage, objCStorage ); 
    x.g();
}

但即使我们选择忽略诸如带有副作用的构造等问题，即当我们愉快地假设类 B 和 C 被设计为可以工作时对于这样的方案，上述会浪费存储空间。如果 B 和 C 实例很大，因此可以考虑使用 C++ 的工具在预先存在的存储中构造对象，称为 placement new。由于内存对齐问题，在 C++03 中很难正确地做到这一点，但 C++11 提供了更好的支持，如下所示:

#include <iostream>
#include <memory>           // unique_ptr
#include <new>              // new
#include <type_traits>      // aligned_storage
using namespace std;

typedef unsigned char Byte;

struct A { virtual void g() = 0; };

struct B : A { virtual void g() override { wcout << "A\n"; } };
struct C : A { virtual void g() override { wcout << "B\n"; } };

A* f( bool const x, void* storage )
{
    return (x? static_cast<A*>( ::new( storage ) B() ) : ::new( storage ) C());
}

bool get_boolean() { return false; }

void destroyA( A* p ) { p->~A(); }

int main()
{
    enum{ enoughBytes = 
        (sizeof( B ) > sizeof( C ))? sizeof( B ) : sizeof( C ) };
    typedef aligned_storage< enoughBytes >::type StorageForBOrC;

    bool const b = get_boolean();
    StorageForBOrC storage;
    A* const pX = f( b, &storage );
    unique_ptr<A, void(*)(A*)> const cleanup( pX, destroyA );
    pX->g();
}

现在，我会选择以上哪一个？

我会选择严格限制但简单即时的静态分配，还是会选择浪费内存的自动分配，或者……优化但有些复杂的就地对象构造？

答案是，我一个都不选!

我不会关注微观效率，而是关注清晰度 和正确性，因此只考虑动态分配的性能影响。为了正确起见，我会为函数结果使用智能指针。如果事实证明这真的会减慢速度，我可能会考虑使用专用的小对象分配器。

总而言之，不要为小事烦恼! :-)