Question

我想确保只从我的类构建智能指针，所以我使所有构造函数都受到保护。

要创建对象，我构建了这个“可构建的”-Policy：

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

};

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

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 );
}

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

宏（扩展为函数定义）这就是我的建议， if 你觉得它绝对必须是一个成员函数。它是宏的少数合法用途之一。
中间人继承。
基本上不是直接从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();
    }
};

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

确保只构建Smartpointers

3 个答案: