Templates C++；11模板条件

我想写一个只对数字有条件的模板

//in header file
template <typename T,
    typename = typename std::enable_if<std::is_arithmetic<T>::value, T>::type 
>
class Foo
{
    public:
        Foo();
};

#include "Foo.inline"

//在头文件中
模板
福班
{
公众：
Foo（）；
};
#包括“Foo.inline”

及

//在内联文件中
模板<
类型名T
>
Foo：：Foo（）
{
};

---

但是，这并不编译。将模板实现放在单独文件中的语法应该如何？

第二个模板参数应在定义中使用

//in header file
template <typename T,
    typename Enable = typename std::enable_if<std::is_arithmetic<T>::value, T>::type
>
class Foo
{
    public:
        Foo();
};


//In inline file
template <typename T, typename Enable>
Foo<T, Enable>::Foo()
{
};

//在头文件中
模板
福班
{
公众：
Foo（）；
};
//在内联文件中
模板
Foo：：Foo（）
{
};

定义中应使用第二个模板参数

//in header file
template <typename T,
    typename Enable = typename std::enable_if<std::is_arithmetic<T>::value, T>::type
>
class Foo
{
    public:
        Foo();
};


//In inline file
template <typename T, typename Enable>
Foo<T, Enable>::Foo()
{
};

//在头文件中
模板
福班
{
公众：
Foo（）；
};
//在内联文件中
模板
Foo：：Foo（）
{
};

std:：enable\u如果

用于触发替换失败，那么编译器可以退回到另一个重载/专门化

如果要验证模板参数，请在

静态\u断言中放入适当的条件：

template <typename T>
class Foo
{
    static_assert(std::is_arithmetic<T>::value,
                  "T must be an arithmetic type");
public:
    Foo();
};

template <typename T>
Foo<T>::Foo()
{
}

模板
福班
{
静态_断言（std:：is_算术：：值，
“T必须是算术类型”）；
公众：
Foo（）；
};
模板
Foo：：Foo（）
{
}

或约束条件：

模板
需要std:：is_算术\u v
福班
{
// ...
};
std:：enable\u如果
用于触发替换失败，那么编译器可以退回到另一个重载/专门化

如果要验证模板参数，请在
静态\u断言中放入适当的条件：

template <typename T>
class Foo
{
    static_assert(std::is_arithmetic<T>::value,
                  "T must be an arithmetic type");
public:
    Foo();
};

template <typename T>
Foo<T>::Foo()
{
}

模板
福班
{
静态_断言（std:：is_算术：：值，
“T必须是算术类型”）；
公众：
Foo（）；
};
模板
Foo：：Foo（）
{
}

或约束条件：

模板
需要std:：is_算术\u v
福班
{
// ...
};
代码的问题是，如果第一个模板参数满足
is\u算术
，则将第二个模板参数默认为
T
。这适用于案例1，但不适用于案例2

template <typename T, 
          typename U = typename std::enable_if<std::is_arithmetic<T>::value, T>::type>
class Foo {
    public:
        Foo();
};

template <typename T, typename U>
Foo<T, U>::Foo() {
}

struct Obj {};

int main() {
    Foo<int> obj; // Fine
    // Foo<Obj> obj2 // 1) Error - as it should be
    Foo<std::string, Obj> obj3; // 2) Works fine - bad
}

代码的问题是，如果第一个模板参数满足
is\u算术
，则将第二个模板参数默认为
T
。这适用于案例1，但不适用于案例2

template <typename T, 
          typename U = typename std::enable_if<std::is_arithmetic<T>::value, T>::type>
class Foo {
    public:
        Foo();
};

template <typename T, typename U>
Foo<T, U>::Foo() {
}

struct Obj {};

int main() {
    Foo<int> obj; // Fine
    // Foo<Obj> obj2 // 1) Error - as it should be
    Foo<std::string, Obj> obj3; // 2) Works fine - bad
}

但是有了这个，我可以写Foo-Foo；类Foo有两个模板参数。即使第二个参数未命名，也无法阻止您编写
Foo
。您可以使用类型别名隐藏第二个参数；类Foo有两个模板参数。即使第二个参数未命名，也无法阻止您编写
Foo
。可以使用类型别名隐藏第二个参数。我知道，但我不知道该在那里写什么，因为坦帕尔特的第二个帕拉米特是nameless@MarcoA. 我知道，但我不知道该在那里写什么，因为坦帕尔特的第二个paarmetr没有名字谢谢你的例子和解释谢谢你的例子和解释