C++静态多态性 (CRTP） 并使用派生类中的 typedef

当您将其用作模板参数以base其基类列表中时，derived是不完整的。

常见的解决方法是使用特征类模板。 这是你的例子，特征化。 这显示了如何通过特征使用派生类中的类型和函数。

// Declare a base_traits traits class template:
template <typename derived_t> 
struct base_traits;
// Define the base class that uses the traits:
template <typename derived_t> 
struct base { 
    typedef typename base_traits<derived_t>::value_type value_type;
    value_type base_foo() {
        return base_traits<derived_t>::call_foo(static_cast<derived_t*>(this));
    }
};
// Define the derived class; it can use the traits too:
template <typename T>
struct derived : base<derived<T> > { 
    typedef typename base_traits<derived>::value_type value_type;
    value_type derived_foo() { 
        return value_type(); 
    }
};
// Declare and define a base_traits specialization for derived:
template <typename T> 
struct base_traits<derived<T> > {
    typedef T value_type;
    static value_type call_foo(derived<T>* x) { 
        return x->derived_foo(); 
    }
};

您只需为用于模板参数derived_t base的任何类型专门化base_traits，并确保每个专用化都提供base所需的所有成员。

使用特征的一个小缺点是必须为每个派生类声明一个特征。您可以编写一个不那么冗长和令人讨厌的解决方法，如下所示：

template <template <typename> class Derived, typename T>
class base {
public:
    typedef T value_type;
    value_type foo() {
        return static_cast<Derived<T>*>(this)->foo();
    }
};
template <typename T>
class Derived : public base<Derived, T> {
public:
    typedef T value_type;
    value_type foo() {
        return T(); //return some T object (assumes T is default constructable)
    }
};
int main() {
    Derived<int> a;
}

在 C++14 中，您可以删除typedef并使用返回类型推导auto函数：

template <typename derived_t>
class base {
public:
    auto foo() {
        return static_cast<derived_t*>(this)->foo();
    }
};

这是有效的，因为返回类型的base::foo的扣除会延迟到derived_t完成。

需要较少样板的类型特征的替代方法是将派生类嵌套在保存 typedefs（或使用）的包装类中，并将包装器作为模板参数传递给基类。

template <typename Outer>
struct base {
    using derived = typename Outer::derived;
    using value_type = typename Outer::value_type;
    value_type base_func(int x) {
        return static_cast<derived *>(this)->derived_func(x); 
    }
};
// outer holds our typedefs, derived does the rest
template <typename T>
struct outer {
    using value_type = T;
    struct derived : public base<outer> { // outer is now complete
        value_type derived_func(int x) { return 5 * x; }
    };
};
// If you want you can give it a better name
template <typename T>
using NicerName = typename outer<T>::derived;
int main() {
    NicerName<long long> obj;
    return obj.base_func(5);
}

这基本上是您发现并且不喜欢的解决方法，但我想记录它，并说它基本上是此问题的当前解决方案。

我一直在寻找一种方法来做到这一点，但从未找到一个好的解决方案。事实上，这是不可能的，这就是为什么最终，像boost::iterator_facade<Self, different_type, value_type, ...>这样的东西需要许多参数的原因。

当然，我们希望这样的东西可以工作：

template<class CRTP> 
struct incrementable{
    void operator++(){static_cast<CRTP&>(*this).increment();}
    using ptr_type = typename CRTP::value_type*; // doesn't work, A is incomplete
};
template<class T>
struct A : incrementable<A<T>>{
    void increment(){}
    using value_type = T;
    value_type f() const{return value_type{};}
};
int main(){A<double> a; ++a;}

如果可能，派生类的所有特征都可以隐式传递到基类。我发现获得相同效果的习语是将特征完全传递给基类。

template<class CRTP, class ValueType> 
struct incrementable{
    void operator++(){static_cast<CRTP&>(*this).increment();}
    using value_type = ValueType;
    using ptr_type = value_type*;
};
template<class T>
struct A : incrementable<A<T>, T>{
    void increment(){}
    typename A::value_type f() const{return typename A::value_type{};}
//    using value_type = typename A::value_type;
//    value_type f() const{return value_type{};}
};
int main(){A<double> a; ++a;}

https://godbolt.org/z/2G4w7d

缺点是派生类中的特征必须使用限定typename访问或通过 using 重新启用。