确保只构建智能指针

Question

我想确保只有智能指针是从我的类中构建的，所以我保护了所有构造函数。

为了创建对象，我构建了这个“可构建”-策略：

template <typename T>
class Buildable
{
public:
    template<typename ...Args>
    static QSharedPointer<T> buildObject(Args&&... all) 
{
        return QSharedPointer<T>( new T(std::forward<Args>(all)...) );
}

};

如果我在基类中使用此策略，一切顺利。 但是当我在基类和派生类中使用它时：

class A : public Buildable<A> {}
class B : A, public Buildable<B>{}

编译器认为：错误：在多个不同类型的基类中发现成员“buildObject”

我不知道如何解决这个问题。有什么想法吗？

Answer 1

错误原因

这是因为这里的多重继承：

class B : A, public Buildable<B>{};

它会导致类 B 继承自 Buildable<A> 和 Buildable<B>，两者都包含 buildObject() 重载。不幸的是，这两个重载仅在返回类型上有所不同。这是不允许的。

设计问题

不幸的是，您无法避免这种情况，除非您可以向buildObject() 走私一个附加参数，这可以允许编译器使用正确的类型派生来解决避免歧义。

但是你真的打算在你的设计中使用多重继承吗？如果你的类是多态的，你能不能使用如下定义的 B 类：

class B :  public A {};  // inherits from Buildable A 
...
QSharedPointer<A> b = B::buildObject();   //

另类设计

替代方法是将建筑类放在派生的底部，以避免冲突。保护 A 类和 B 类的构造函数，并使用此模板类：

// (I used here shared_ptr instead of QSharedPointer for testing purpose)    
template <typename T>
class Builder : public T
{
public:
    Builder() = delete; 
    Builder (const Builder&) = delete; 
    template<typename ...Args>
    static shared_ptr<T> buildObject(Args&&... all) 
    {
        return make_shared<T>(std::forward<Args>(all)...) ;
    }
};

class A { };    
class B : public A {};  // Normal class hierarchy.  
                        // can't be instantiated if ctor are protected.

shared_ptr<A> a = Builder<A>::buildObject(); 
shared_ptr<B> b = Builder<B>::buildObject(); 

Answer 2

设计问题的一个简单解决方案是使buildObject 成为一个独立的函数模板，即为每个用户类创建一个friend。

为了简化friend 声明，您可能希望将该函数模板放在一个类中。

那么它很像你现有的代码，除了没有从工厂类继承：

#include <memory>       // std::shared_ptr
#include <utility>      // std::forward

namespace my{
    using std::forward;
    using std::shared_ptr;

    template< class Class >
    struct Make_
    {
        template< class... Args >
        static auto instance( Args&&... args )
            -> shared_ptr<Class>
        { return shared_ptr<Class>( new Class( forward<Args>( args )... ) ); }
    };

    class A
    {
    template< class > friend struct Make_;
    protected:
        A( int ) {}
    };

    class B
        : public A
    {
    template< class > friend struct Make_;
    protected:
        B( int x ): A( x ) {}
    };

}  // namespace my

auto main() -> int
{
    using namespace my;
    auto p = Make_<B>::instance( 42 );
}

---

提供协变函数而不重复其定义的直接技术问题的一般解决方案包括：

• 宏（扩展为函数定义）。
  这是我推荐的，如果你觉得它绝对必须是一个成员函数。这是宏的少数合法用途之一。

• 中间人继承。
  本质上不是直接从Base 和mixin 继承，而是从mixin 继承并要求它从Base 继承。您需要从 mixin 转发构造函数参数。

• 在虚拟继承层次结构中占主导地位。
  一个非常丑陋和复杂的解决方案。不要去那里。但这是技术上的可能性。

---

最后，使用返回指向基类的（智能）指针的函数是无法解决的。客户端代码必须将其丢弃的地方。它以自己的方式确实很糟糕，但为了完整起见，我提到它。

Answer 3

您可以从QEnableSharedFromThis 继承（有关详细信息，请参阅here）。
举个例子：

class C: public QEnableSharedFromThis<C> {
    C() = default;
    // all the other constructors

public:
    template<typename ...Args>
    static QSharedPointer<C> create(Args&&... all) {
        // refers one of the available constructors
        return QSharedPointer<C>(new C{std::forward<Args>(all)...});
    }

    QSharedPointer<C> getSharedFromThis() {
        return sharedFromThis();
    }
};

您可以将其用作层次结构的基类。