Question

简介：

我想确保派生类实现父CRTP类中函数所需的成员函数。

详情：

我有一些像这样的代码

class Base
{
public:
    class Params
    {
    public:
        virtual ~Params() {}
    };

    virtual void myFunc( Params& p ) = 0;
};

template< typename T >
class CRTP : public Base
{
public:
    virtual void myFunc( Base::Params& p ) override
    {
        typename T::Params& typedParams = dynamic_cast<typename T::Params&>( p );
        static_cast<T*>( this )->myFunc( typeParams );
    }

};

class Imp : public CRTP<Imp>
{
public:
    class Params : public CRTP<Imp>::Params
    {
    public:
        virtual ~Params() {}

        int x, y, z;
    };

    virtual void myFunc( Imp::Params& p );
};

目的是我可以让多个Imp子类在myFunc中执行不同的操作并接受他们自己的必需参数。然后由Base提供的接口由更高级别的函数使用，这些函数只需要具有类型Base::Params和Base的指针/引用。我的问题是确保任何Imp提供专门的myFunc。为避免无限递归，Imp必须实现myFunc。

我的第一次尝试是向CRTP

添加纯虚函数

virtual void myFunc( typename T::Params& p ) = 0;

但是这不起作用，因为Imp在定义CRTP时尚未完全定义。 This question使用static_assert，这让我想到static_assert内的CRTP::myFunc做同样的事情。除了我不确定静态断言中非静态函数的表达式应该是什么。

我可以根据需要使用static_assert吗？
这是确保派生类具有所需功能的最佳/最干净的方法吗？
我的班级设计是否被废弃了？有更好的办法吗？

感谢。

Answer 1

为什么不为该功能使用不同的名称？然后，对于没有和实现的CRTP类的每个派生，您将有一个编译错误。考虑一下：

class Base
{
public:
    class Params
    {
    public:
        virtual ~Params() {}
    };

    virtual void myFunc( Params& p ) = 0;
};

template< typename T >
class CRTP : public Base
{
public:
    virtual void myFunc( Base::Params& p ) final override
    {
        typename T::Params& typedParams = dynamic_cast<typename T::Params&>( p );
        static_cast<const T*>( this )->myFuncImp( typedParams );
    }

};

class Imp : public CRTP<Imp>
{
public:
    class Params : public CRTP<Imp>::Params
    {
    public:
        virtual ~Params() {}

        int x, y, z;
    };
};

int main(int argc, char** argv)
{
    Imp imp;
}

编译失败，因为myFuncImp未提供Imp。

Answer 2

您可能会破坏动态多态并切换到静态多态：

#include <iostream>
#include <type_traits>

class Base
{
    public:
    class Params
    {
        public:
        virtual ~Params() {}
    };

    virtual ~Base() {}
    virtual void myFunc(Params& p) = 0;
};


namespace Detail {
    // Helper for the static assertion
    // Omit this if "‘void CRTP<T>::myFunc(Base::Params&) [with T = Imp]’ is private" is good enough
    struct is_MyFunc_callable_implementation
    {
        template<typename Object, typename Params>
        static decltype(std::declval<Object>().myFunc(std::declval<Params&>()), std::true_type())
        test(int);

        template<typename Object, typename Params>
        static std::false_type
        test(...);
    };

    template<typename Object, typename... A>
    using is_MyFunc_callable = decltype(is_MyFunc_callable_implementation::test<Object, A...>(0));

    // Helper function to break recursion
    template<typename Object, typename Params>
    inline void invokeMyFunc(Object& object, Params& params) {
        static_assert(is_MyFunc_callable<Object, Params>::value, "The derived class is missing 'MyFunc'");
        object.myFunc(params);
    }
} // namespace Detail

template<typename T>
class CRTP: public Base
{
    private:
    // Make this final!
    virtual void myFunc(Base::Params& p) override final
    {
        static_assert(std::is_base_of<Base, T>::value, "T must derive from CRTP");
        typename T::Params& typeParams = dynamic_cast<typename T::Params&>(p);
        Detail::invokeMyFunc(static_cast<T&>(*this), typeParams);
    }
};

class Imp: public CRTP<Imp>
{
    public:
    class Params: public CRTP<Imp>::Params
    {
        public:
        int x = 1;
        int y = 2;
        int z = 3;
    };

    // Without this function:
    // error: static assertion failed: The derived class is missing 'MyFunc'
    // error: ‘void CRTP<T>::myFunc(Base::Params&) [with T = Imp]’ is private
    #if 0
    void myFunc(Params& p) {
        std::cout << p.x << p.y << p.z << '\n';
    }
    #endif
};

int main()
{
    Imp imp;
    Base* base = &imp;
    Imp::Params params;
    base->myFunc(params);
}

但是，我认为：基类设计失败了，上面的代码只是一个解决方法。

Answer 3

为派生类的成员使用不同的名称的想法（如在Rudolfs Bundulis的回答中）是好的。但是，我会将其设为protected方法，以便用户不会尝试使用它。

此外，在CRTP基础中使用Derived::Params会引发其他并发症（因为Derived=Imp在CRTP<Imp>}中使用Base::Params时尚未完全声明，所以最好保留struct Base // public user interface { struct Params { virtual ~Params() {} }; virtual void myFunc( Params& ) = 0; }; namespace details { // deter clients from direct access template< typename Derived > struct CRTP : Base { virtual void myFunc( Params& p ) final // cannot be overridden { static_cast<Derived*>( this )->myFuncImp(p); } }; class Imp : public CRTP<Imp> { struct Params : CRTP<Imp>::Params { int x, y, z; }; void myFuncImpDetails( Params* ); protected: // protected from clients void myFuncImp( Base::Params& p ) { auto pars=dynamic_cast<Params*>(&p); if(pars) myFuncImpDetails(pars); else throw std::runtime_error("invalid parameter type provided to Imp::myFunc()"); } }; } // namespace details作为整个函数参数。

echo %DATE:~10,4%-%DATE:~7,2%-%DATE:~4,2% %TIME:~0,2%:%TIME:~3,2%:%TIME:~6,2%

确保从父CRTP类派生的类实现函数

3 个答案: