命名构造函数和继承

Question

我正在研究 C++ 框架，并希望将自动内存管理应用于许多核心类。 到目前为止，我有标准方法，

class Foo 
{

public:

  static
  shared_ptr<Foo> init() 
  {
    return shared_ptr<Foo>(new Foo);
  }

  ~Foo() 
  {
  }

protected:

  Foo()
  {
  }

};


// Example of use
shared_ptr<Foo> f = Foo::init();

但是，当我子类化 Foo 时，上面的方法会中断，因为即使 init() 被继承，它仍然返回 shared_ptr其中包含指向 Foo 实例的指针。

有人能想出一个优雅的解决方案吗？ 我是否应该坚持使用 shared_ptr （半）手动包装类的实例？ 这也使得能够公开参数化构造函数，而无需声明新的命名构造函数......

即。

template <typename T>
shared_ptr<T> make_shared(T* ptr)
{
  return shared_ptr<T>(ptr)
}

// Example
shared_ptr<T> 
  f1 = make_shared(new Foo()),
  f2 = make_shared(new Foo(1,2));

Answer 1

我会尝试这样的事情：

template<class T>
class creator
{
  public:
    static shared_ptr<T> init()
    {
      return(shared_ptr<T>(new T));
    }
};

class A : public creator<A>
{
};

class B : public A, public creator<B>
{
  public:
    using make_shared<B>::init;
};

// example use
shared_ptr<A> a = A::init();
shared_ptr<B> b = B::init();

但是与您建议的独立模板相比，这不一定能为您节省一些东西。

编辑：我错过了之前的答案，这似乎是相同的想法。

Answer 2

我不明白这会实现什么，与简单地声明一个shared_ptr相比，使用这个init函数似乎没有获得任何额外的内存管理。

int main( void )
{
    shared_ptr<foo> a = foo::init();
    shared_ptr<foo> b( new foo );
}

有什么不同。 shared_ptr 提供内存管理，而不是 init 中的任何内容。

Answer 3

看起来目标是使类的用户无法直接调用构造函数，而仅公开返回shared_ptr的例程。

但如果你想应用这个模式，你需要在所有子类中复制它。 子类不能自动“继承”init()，因此init()仍会调用子类构造函数，因为init()不是虚拟方法，并且在没有对象的情况下调用。

我将像往常一样将构造函数暴露出来，只使用标准，

shared_ptr<X> x = new X();

这可以降低认知负担，具有可读性，并且保持灵活性。 无论如何，这就是我们在公司中使用引用计数对象进行编程的方式。

Answer 4

怎么样...

template<typename Derived>
class Foo 
{
public:

    static shared_ptr<Derived> init() 
    {
        return shared_ptr<Derived>(new Derived);
    }

    ~Foo() 
    {
    }

protected:

    Foo()
    {
    }

};


class Bar : public Foo<Bar>
{
};

int _tmain(int argc, _TCHAR* argv[])
{
    shared_ptr<Bar> b = Foo<Bar>::init(); 
    return 0;
}

Answer 5

为什么不引入带有虚拟析构函数的公共基类，从中继承所有必需的类并简单地使用 new 呢？

Answer 6

通过隐藏构造函数来强制使用 shared_ptr 创建对象通常不是一个好主意。 我是根据与一个内部公司库合作的个人经验来发言的，该库正是这样做的。 如果您想确保人们始终包装他们分配的对象，只需确保存储这些类型实例的所有参数和成员都需要 shared_ptr 或 weak_ptr 而不是裸指针或参考。 您可能还想从 enable_shared_from_this 派生这些类，因为在所有对象都是共享的系统中，在某些时候您必须将 this 指针传递给以下对象之一：这些其他对象的方法，并且由于它们被设计为仅接受 shared_ptr，因此如果您的对象没有 internal_weak_this 来确保它不存在，那么您的情况会非常糟糕被毁了。

Answer 7

您需要在整个层次结构的每种类型中使用静态工厂函数。

class Foo
{
public:
    static shared_ptr< Foo > instantiate( /* potential arguments */ )
    {
           return shared_ptr< Foo >( new Foo( /* potential arguments */ );
    }

// blah blah blah
};

class Bar : public Foo
{
public:
    static shared_ptr< Bar > instantiate( /* potential arguments */ )
    {
           return shared_ptr< Bar >( new Bar( /* potential arguments */ );
    }

// blah blah blah
};

如果您仍然有任何困惑，请在 sourceforge 上搜索 CppCodeProvider 并看看它是如何完成的。

Answer 8

顺便说一句，在大型 C++ 框架中，向编码人员隐藏“自动内存管理”是很常见的。 这让他可以编写更短、更简单的代码。 例如，在 Qt 中你可以这样做：

QPixmap foo() {
    QPixmap pixmap(10, 10);
    return pixmap;
}

void bar() {
    QPixmap a = foo(); // no copying occurs, internal refcount incremented.
    QPixmap b = a;     // ditto.
    QPainter p(&b);
    p.drawPoint(5, 5); // data can no longer be shared, so a copy is made.
    // at this point 'a' is still unchanged!
    p.end();
}

像 Qt 中的许多东西一样，这模仿了 Java 对象模型，但它通过实现 copy-on-write （它称为

这是通过d-pointer 惯用语实现的，一举两得Stone - 您提供自动内存管理，并且将您的实现与用户隔离（粉刺）。

您可以在这里查看 QPixmap 的实际实现： qpixmap.cpp, qpixmap .h。