ITNOA

我的问题是如何在可变参数模板部分模板特化场景中使用 std::enable_if？

例如，我有一个类使用如下所示的可变参数模板部分特化

        /**
         *  Common case.
         */
        template<typename... Args>
        struct foo;

        /**
         *  Final superclass for foo.
         */
        template<>
        struct foo<>{ void func() {} };

        /**
         *  Regular foo class.
         */
        template<typename H, typename... T>
        struct foo<H, T...> : public foo<T...> {
            typedef super foo<T...>;
            void func() {
                cout << "Hi" << endl;
                this->super::template func();
            }
        }

它工作正常，但如果 H 是整数类型，我想要特定的部分特化，所以我添加如下新代码

        enum class enabled {_};
        template<typename H, typename... T>
        struct foo<H, typename std::enable_if<std::integral_type<H>::value,enabled>::type = enabled::_, T...> : public foo<T...> {
            typedef super foo<T...>;
            void func() {
                cout << "Hooray Inegral" << endl;
                this->super::template func();
            }
        }

但上面的代码不起作用，我的问题是如何像上面那样做？

最佳答案

enable_if<bool b, T=void>是定义 type=T 的类模板如果b==true .所以，enable_if<b>::type仅当 b==true 时才是有效表达式. SFINAE 声明替换失败不是错误。恕我直言not_disable_if会更合适的名字。

部分特化通过针对当前已解析类型的模式匹配模板来工作。您不能向其中添加新的模板参数，因为它会匹配不同的内容。 struct foo<H,std::enable_if_t<...,void>>只匹配foo<H,void>如果... 从H中扣除 并评估为 true .

struct foo<std::enable_if_t<std::is_integral_v<H>,H>>不能工作只是因为没有办法推断 H来自例如foo<int> .它必须以某种方式推断出 enable_if 的语义。和 is_integral看看如果 H=int , 然后它准确地解析为 foo<int>这当然不能在一般情况下完成。

SFINAE 只能应用于那些在重载解析期间被考虑的部分。第一个和您使用的那个是类模板参数，但正如我上面所说的那样，它会改变它实际匹配的内容。另一个选项是模板参数本身。但是 C++ 不允许通常用于类特化的默认模板参数。函数中没有返回值。 SFINAE 不使用类主体或其基类中的任何内容。我不认为你想要的是你当前的设置。

我将提供一个轻微的重新设计:

#include <iostream>
#include <type_traits>

// Only specifies behaviour for the head part - one T
// Ts... can be ignored, but are required.
//  - I left them because I'm not sure whether you want to use them in the real code.
//  - But they are required because `foos` use them as base classes and they must be unique.
template<typename T,bool is_integral,typename...Ts>
struct foo_impl;

template<typename T,typename...Ts>
struct foo_impl<T,true,Ts...>
{
    void func() {
        std::cout << "Hooray Inegral" << std::endl;
    }
};

template<typename T,typename...Ts>
struct foo_impl<T,false,Ts...>
{
    void func() {
        std::cout << "Hi" << std::endl;
    }
};

template<typename T,typename...Ts>
using foo = foo_impl<T,std::is_integral<T>::value,Ts...>;

template<typename...Ts>
struct foos;

template<typename H,typename...Ts>
struct foos<H,Ts...> : private foo<H,Ts...>, public foos<Ts...>
{
   using head = foo<H,Ts...>;
   using tail = foos<Ts...>;
   //Only named differently for clarity, feel free to rename it back to 'func'
   void rec_func()
   {
       //If we inherited from foo<H> so this was only this->foo<H>::func() then
       //foos<int,int> would have two foo<int> base classes and this call would be ambigious.
       this->head::func();
       this->tail::rec_func();
   }
};

template<> struct foos<>{
    void rec_func(){}
};

int main()
{
    foos<int,int,char,double> x;
    x.rec_func();
}

foo只处理一个T并且需要特化。您可以提取 foo<T,false> 之间的任何常见行为和 foo<T,true>到一个共同的基类。当前 foo 之间存在重复和 foos应用程序接口(interface)。但是foo ' API 可以被视为私有(private)的并且可以是不同的，所以我不会说这是缺点。正如我解释的 Ts...在 foo_impl是必须的。如果您不需要它们，可以通过 - 例如通过简单地从 std::tuple<foo<Ts>...> 导出和一些折叠表达式(C++17)/魔术(C++14)来调用func职能。如果您愿意，我可以添加。

关于带有 std::enable_if 的 C++ 可变参数模板部分模板特化，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/56103846/