如何防止模板类被多次派生？

Question

我有以下模板类：

template<class I>
class T : public I
{
    // ...
};

对于给定的模板参数I该模板类需要一次（并且仅一次）导出。

class A : public T<U>  {};    // ok
class B : public T<V>  {};    // ok
class C : public T<U>  {};    // compile error

模板类T可以适应于实现这样的行为（而类A ， B ， U ， V不能）; 但是， T必须对派生类A ， B ， C没有任何了解。

有没有办法防止这样的模板类被多次派生？ 理想情况下，在这种情况下发出编译错误，或者至少是链接器错误。

Answer 1

如果基类T知道其派生类的类型，则可以这样做。 这些知识可以通过CRTP或重载标记传递给它的构造函数。 这是后一种情况：

template<class I>
class T : public I
{
protected:
    template< class Derived >
    T( Derived * ) {
        static_assert ( std::is_base_of< T, Derived >::value,
            "Be honest and pass the derived this to T::T." );

然后，如果T::T( Derived * )有两个特化（具有不同的Derived ）， Derived要做一些会导致问题的事情。 朋友的功能非常棒。 根据<T, Derived>实例化一个辅助非成员类，其friend函数依赖于T而不是Derived 。

        T_Derived_reservation< T, Derived >{};
    }
};

这是辅助类。 （它的定义应该在T之前。）首先，它需要一个基类来允许在T_Derived_reservation< T, Derived >上的ADL找到一个不提及Derived的签名。

template< typename T >
class T_reservation {
protected:
    // Make the friend visible to the derived class by ADL.
    friend void reserve_compile_time( T_reservation );

    // Double-check at runtime to catch conflicts between TUs.
    void reserve_runtime( std::type_info const & derived ) {
    #ifndef NDEBUG
        static std::type_info const & proper_derived = derived;
        assert ( derived == proper_derived &&
            "Illegal inheritance from T." );
    #endif
    }
};

template< typename T, typename Derived >
struct T_Derived_reservation
    : T_reservation< T > {
    T_Derived_reservation() {
        reserve_compile_time( * this );
        this->reserve_runtime( typeid( Derived ) );
    }

    /* Conflicting derived classes within the translation unit
       will cause a multiple-definition error on reserve_compile_time. */
    friend void reserve_compile_time( T_reservation< T > ) {}
};

当两个.cpp文件声明不同的不兼容派生类时，获取链接错误会很好，但我不能阻止链接器合并内联函数。 因此， assert将触发。 （您可以设法在标头中声明所有派生类，而不用担心assert触发。）

演示 。

---

您已编辑过说T无法知道其派生类型。 好吧，在编译时你无能为力，因为这些信息根本不可用。 如果T是多态的，那么您可以将动态类型视为派生类A或B ，但不能在构造函数或析构函数中观察。 如果派生类可靠地调用了其他一些函数，你可以挂钩：

template< typename I >
class T {
protected:
    virtual ~ T() = default;

    something_essential() {
    #ifndef NDEBUG
        static auto const & derived_type = typeid( * this );
        assert ( derived_type == typeid( * this ) &&
            "Illegal inheritance from T." );
    #endif
        // Do actual essential work.
    }
};

Answer 2

我不是宏的忠实粉丝，但如果使用宏对你来说不是问题 - 你可以使用一个简单紧凑的解决方案，如下所示：

#include <iostream>

template <class>
struct prohibit_double_inheritance { };

#define INHERIT(DERIVING, BASE) \
    template<> struct prohibit_double_inheritance<BASE> { };\
    struct DERIVING: BASE


template<class I>
struct T: I
{
    // ...
    static void do_something() {
        std::cout << "hurray hurray!" << std::endl;
    }
};

struct U { };
struct V { };

INHERIT(A, T<U>) {
};

//INHERIT(B, T<U>) { // cause redetinition of the struct 
//};                 // prohibit_double_inheritance<T<U>> 

int main() {
    A::do_something();
}

[现场演示]

Answer 3

既然你提到可以将A ， B和C传递给T那么这个运行时解决方案怎么样？

#include <cassert>
#include <typeinfo>

//This class will check to see each T<X> is only instantiated with a unique Y
template <class X>
struct T_helper
{
    template <class Y>
    static void check()
    {
        if(derived_type)
            assert(*derived_type == typeid(Y));
        else
            derived_type = &typeid(Y);
    }
    static const std::type_info * derived_type;
};

template <class X>
const std::type_info * T_helper<X>::derived_type = nullptr;

template <class X, class Y>
struct T
{
    T()
    {
        T_helper<X>::template check<Y>();
    }
};

struct A : T<int, A> {};
struct B : T<int, B> {};

int main()
{
    A a1, a2, a3; // These are all okay
    B b1;         // This one will trigger the assert
}

Answer 4

我能想到的唯一答案是拥有实例化及其衍生物的注册表。 然后，您可以设计一个搜索注册表的元函数。 你传递它的基础和派生，如果你没有使用注册类型派生它返回void类型或其他东西，所以它会导致编译器错误。 根据您的要求，基地不知道派生的这是我能想到的唯一可能的答案。

您的声明将如下所示：

struct A : search_registry<T<U>, A>::type { ... };

我相信你会遇到许多难以解决的问题 - 祝你好运！

请记住，模板元程序纯粹是功能性的。 你不能以任何好的方式“添加”到注册表。 您将需要定义一次以容纳所有内容。 从好的方面来说，如果有人忘记添加到注册表中，他们就会知道，或者如果他们使用之前定义的那个...在减号上，这就像鸭子一样难看。