带有模板组合的 CRTP 编译检测

Question

几天以来我一直遇到模板问题，您一次解决了我的每一个问题，所以提前感谢您。

所以我有一个模板 (tl1) 关心 uml composition，另一个模板 (tl2) 就是 uml composed
因此，如果composed 对象不是tl2 的derived 并且typename D 不是tl1 derived，我的目标是不编译。

按照post 和one 的帮助，我得到了以下代码：

#include <type_traits>
#include <list>
#include <string>

template <typename T, typename C>
class tl2 ;

template <typename D, typename T>
class tl1 {
private:
    static_assert(std::is_base_of<tl2<T, D>, T>::value, "T should     inherit from tl2");
    std::list<T> mTs ;
    tl1() {} ;
    friend D ;
public:
    T & getTbyName() const ;
};

template <typename T, typename C>
class tl2 {
    //static_assert(std::is_base_of<tl1<C, T>, C>::value, "D should inherit from Database");
public:
    std::string getName() { return mName ; }
private:
    C & mC ;
    std::string mName ;
};

class cl1 ;

class cl2 : public tl2<cl2, int>  {

};
class cl1 : public tl1<int, cl2>  {

};

我的问题是这个编译得很好，我不想。 我不想编译，因为来自tl1<D, T> 的D 必须来自tl1 的derived。
实际上class cl1 : public tl1<int, cl2> 不正确，但它可以编译。那为什么呢？
如果我将cl1 更改为：

class cl1 : public tl1<int, cl2>  {    
    cl1() {}
};

我明白为什么更改后它不编译，但我不明白为什么它之前编译。

事实上tl1 和tl2 将在库中，所以我想在库中执行所有检查。我无法控制派生，所以我想确定implementation 是tlX derived。

再次感谢您的光临。
昆汀

Answer 1

做你想做的事情的问题是循环依赖。据我所知，std::is_base_of 需要一个完整的类型才能工作。

您的代码在 tl1..中有两个限制。

• T 必须继承自 tl2
• D 必须继承自 tl1

最后，它看起来像：

tl1<T, D> 其中 D 继承 tl1<T, D> 其中 D 继承 tl1<T, D>

换句话说，D 永远不会被定义，因为 Tl1 需要将 D 定义为模板参数，但 D 必须从需要它的 Tl1 继承。

现在，如果您取消对 D 的限制，那么以下代码将按应有的方式编译，因为满足了第一个限制。但是，如果您取消注释 tl1 中的 static_assert，它将永远不会编译，因为 D 的定义取决于 tl1 的定义，而 tl1 的定义又取决于 D 的定义等等..等等..

您会收到如下错误：

invalid use of incomplete type 'class cl1'
     struct is_base_of
            ^
note: forward declaration of 'class cl1'

代码：

#include <type_traits>
#include <list>
#include <string>

template <typename T, typename C>
class tl2 ;

template <typename D, typename T>
class tl1 {
private:
    static_assert(std::is_base_of<tl2<T, D>, T>::value, "T should     inherit from tl2");
    //static_assert(std::is_base_of<tl1, D>::value, "D should inherit from tl1");
    std::list<T> mTs ;
    friend D ;
public:
    tl1() {}
    T & getTbyName() const ;
};

template <typename T, typename C>
class tl2 {
    //static_assert(std::is_base_of<tl1<C, T>, C>::value, "D should inherit from Database");
public:
    std::string getName() { return mName ; }
private:
    //C & mC ;
    std::string mName ;
};


class cl1;

class cl2 : public tl2<cl2, cl1>  {
    public:
        cl2() {}
};

class cl1 : public tl1<cl1, cl2>  {
    public:
        cl1() {}
};

int main() {
    cl1 a;
    cl2 b;
    return 0;
}

如果您将std::is_base_of 替换为：

template<class B, class D>
struct is_base_of
{
  template<typename T> struct dummy {};
  struct Child : D, dummy<int> {};

  static B* Check (B*);
  template<class T> static char Check (dummy<T>*);

  static const bool value = (sizeof(Check((Child*)0)) == sizeof(B*));
};

它会给你错误：

recursively required by substitution of 'template<class T> static char is_base_of<B, D>::Check(is_base_of<B, D>::dummy<T>*) [with T = <missing>]'

在我看来，这对于正在发生的事情要清楚得多。

TLDR：你不能。

Answer 2

您的代码可以编译，因为静态断言没有任何问题。

cl1 用

专门化 tl1

T = cl2 继承自 tl2<cl2, int> D = int

然后你验证一下

std::is_base_of<tl2<T, D>, T>::value == true

所以让我们在这里替换T 和D：

std::is_base_of<tl2<cl2, int>, cl2>::value == true

这是正确的。

换句话说，您的静态断言可能没有检查它应该检查的内容。截至目前，我有点困惑你想要实现什么。我会回答你以前的问题，但你应该认真考虑让你的名字更清楚。这将有助于理解您打算实现的目标。

根据@Brandon 的反馈，我猜您可能正在寻找这个：http://ideone.com/H4hm3O