确保仅构建智能指针

Make sure only Smartpointers are build

本文关键字：指针 智能 构建 确保      更新时间：2023-10-16

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

为了创建对象，我构建了这个"可构建"策略：

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">

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

错误原因

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

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();
设计

问题的一个简单解决方案是将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 转发构造函数参数。

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

最后，使用返回基类的(智能(指针的函数是非解决方案。客户端代码必须将其强制转换的位置。它以自己的方式真的很不好，但我提到它是为了完整性。

你可以从QEnableSharedFromThis继承(有关更多详细信息，请参阅此处(。
举个例子：

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

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

相关文章：