CRTP：基于派生类内容启用基类中的方法

有没有办法从 CRTP 基类查询派生类的内容，与 SFINAE 一起使用来启用或禁用基类方法？

我想要完成的事情可能如下所示：

template<typename Derived>
struct base
{
    struct foo {};
    struct bar {};

    void dispatch(int i)
    {
        switch (i) {
        case 0: dispatch(foo{}); break;
        case 1: dispatch(bar{}); break;
        default: break;
        }
    }

    // catch all for disabled methods
    template<typename T> void dispatch(T const&) {}

    std::enable_if</* magic that checks if there is in fact Derived::foo(foo) */>
      dispatch(foo f)
    {
        static_cast<Derived*>(this)->foo(f);
    }
    std::enable_if</* magic that checks if there is in fact Derived::bar(bar) */>
      dispatch(bar b)
    {
        static_cast<Derived*>(this)->bar(b);
    }
};

struct derived: public base<derived>
{
    // only foo in this one
    void foo(foo) { std::cout << "foo()\n"; }
};

只是尝试使用Derived::foo inside enable_if导致错误，引用不完整类（派生类）的无效使用。

有没有办法从 CRTP 基类查询派生类的内容，与 SFINAE 一起使用来启用或禁用基类方法？

是的。它遵循一个最小的工作示例：

#include<iostream>

template<typename D>
class base {
    template<typename T = D>
    auto dispatch(int) -> decltype(std::declval<T>().foo(), void()) {
        static_cast<T*>(this)->foo();
    }

    void dispatch(char) {
        std::cout << "base" << std::endl;
    }

public:
    void dispatch() {
        dispatch(0);
    }
};

struct derived1: base<derived1> {
    void foo() {
        std::cout << "derived1" << std::endl;
    }
};

struct derived2: base<derived2> {};

int main() {
    derived1 d1;
    derived2 d2;
    d1.dispatch();
    d2.dispatch();
}

添加要转发的参数很简单，我更喜欢让示例尽可能简单。
看到它正在运行wandbox http://melpon.org/wandbox/permlink/RYGSpwrzxRQnYmIX.

从上面的代码片段中可以看出，基本思想是使用标记分派和重载方法来启用或禁用基类中的方法，并使用派生类中的方法（如果存在）。

简单地尝试在enable_if内部使用Derived::foo会导致错误，引用不完整类（派生类）的无效使用。

那是因为Derived当你尝试使用它时实际上是不完整的。标准说：

在类说明符的结束}处，类被视为完全定义的对象类型（或完整类型）。

在您的情况下，派生类有一个基类模板，并且出于明显的原因，在后者的实例化过程中，前者不是完整的类型。
而且，Derived不是你的 sfinae 表达式中的实际类型并且（让我说）sfinae 不起作用在这种情况下。这就是我在示例中执行以下操作的原因：

template<typename T = D>
auto dispatch(int) -> decltype(std::declval<T>().foo(), void()) {
    static_cast<T*>(this)->foo();
}

当然，decltypesfinae 表达式也以这种方式使用。你可以做类似的事情std::enable_if_t如果你更喜欢。我发现这个版本更容易阅读和理解。

话虽这么说，您可以通过虚拟方法获得相同的结果。如果您没有充分的理由不这样做，请使用它。

为了完整起见，您的示例已更新为上述技术：

#include<iostream>

template<typename Derived>
struct base
{
    struct foo {};
    struct bar {};

    void dispatch(int i)
    {
        switch (i) {
        case 0: dispatch(0, foo{}); break;
        case 1: dispatch(0, bar{}); break;
        default: break;
        }
    }

    template<typename T>
    void dispatch(char, T const&) {}

    template<typename D = Derived>
    auto dispatch(int, foo f)
    -> decltype(std::declval<D>().foo(f), void())
    {
        static_cast<D*>(this)->foo(f);
    }

    template<typename D = Derived>
    auto dispatch(int, bar b)
    -> decltype(std::declval<D>().bar(b), void())
    {
        static_cast<D*>(this)->bar(b);
    }
};

struct derived: public base<derived>
{
    void foo(foo) { std::cout << "foo" << std::endl; }
};

int main() {
    derived d;
    d.dispatch(0);
    d.dispatch(1);
}

看到它wandbox http://melpon.org/wandbox/permlink/tZroWbTpLimF4Krd.