自动模板类enable_if有效参数
是C++语言中的一种模板元编程技术，用于在编译时根据条件来选择是否启用某个模板类的特定实例化。它通过使用SFINAE（Substitution Failure Is Not An Error）原则来实现。
具体来说，enable_if是一个模板类，它有一个模板参数作为条件，当该条件为true时，enable_if的内部类型成为有效类型，否则被禁用。通过在函数模板的返回类型中使用enable_if，可以根据条件选择不同的返回类型。
enable_if有效参数的应用场景包括但不限于以下几个方面：
- 函数重载：可以根据不同的条件选择不同的函数实现。
- 模板特化：可以根据不同的条件选择不同的模板特化版本。
- 模板约束：可以限制模板参数的类型范围，只有满足条件的类型才能匹配该模板。
在云计算领域中，enable_if有效参数可以用于实现一些复杂的条件判断和类型选择，以提高代码的灵活性和可复用性。
腾讯云相关产品中，没有直接与enable_if有效参数相关的产品或服务。然而，腾讯云提供了丰富的云计算产品和解决方案，如云服务器、云数据库、云存储、人工智能服务等，可以帮助开发者构建和部署各种应用和服务。
更多关于腾讯云产品的信息，可以访问腾讯云官方网站：https://cloud.tencent.com/
相关·内容
代码：
template<class T>
struct is_builtin
{
enum {value = 0};
};
template<>
struct is_builtin<char>
{
enum {value = 1};
};
template<>
struct is_builtin<int>
{
enum {value = 1};
};
template<>
struct is_builtin<double>
{
enum {value = 1};
};
浏览 6提问于2010-11-11得票数 13
回答已采纳
1回答
作为一个较大程序的特征类的一部分，我尝试创建一个静态类变量，该变量可以具有不同的值，具体取决于所包含的类模板的实例化类型。
我已经简化了相关代码，生成了我正在讨论的基本示例：
#include <iostream>
#include <string>
#include <type_traits>
template <class T, class Enable = void>
struct Foo;
template <class T>
struct Foo<T,
typename std::enable_if<
浏览 1提问于2012-04-09得票数 10
回答已采纳
2回答
我希望在以下代码中为共享公共基类的类专门化方法doIt()，如下所示
#include <iostream>
#include <boost/utility.hpp>
#include <boost/type_traits.hpp>
struct BarBase {};
struct Bar: BarBase {};
struct FooBase {};
struct Foo: FooBase {};
template <typename T>
struct Task
{
// I'd like to specialize
浏览 0提问于2012-02-23得票数 0
1回答
我正在尝试部分专门化非字符数组的特征：
template<typename T>
struct is_container : std::false_type {};
template<typename T, unsigned N>
struct is_container<T[N]>
: std::enable_if<!std::is_same<T, char>::value, std::true_type>::type {};
Visual Studio2010给了我一个C2039 (type不是enable_if的元素...)。然
浏览 1提问于2011-09-12得票数 6
回答已采纳
非常奇怪的问题，我一直在努力在过去的几个小时(在解决5-6与SFINAE的其他问题，因为我是新手)。基本上，在下面的代码中，我希望f()可以处理所有可能的模板实例化，但只有在N == 2时才能使用N == 2。
#include <type_traits>
#include <iostream>
template<typename T, int N>
class A
{
public:
void f(void);
void g(void);
};
template<typename T, int N>
inline void
浏览 3提问于2017-01-27得票数 8
回答已采纳
2回答
我试图有选择地启用模板化类中的方法，仅当元组模板参数具有特定的数量时。我一直在尝试各种组合，到目前为止还找不到一种方法来编译下面的代码。 实际上，当我用一个只有两个元素的元组实例化foo类时，我希望启用第一个"void print()“方法，而当我用一个包含三个元素的元组实例化foo时，我希望启用第二个"void print()”方法。 注意:这只是一个抽象的例子，从我试图解决的一个更复杂的问题中提炼出来。此外，我还可以使用基于两个特定元组的部分模板专门化来工作。然而，我真的很想理解"enable_if“，我希望它能让我的代码变得”更简单“。 谢谢 // g++ -s
浏览 13提问于2020-08-27得票数 1
回答已采纳
以下是守则的一部分：
// Null-delimited strings, and the like.
template < typename CharT,
typename std::enable_if <
std::is_pointer<CharT>::value &&
!std::is_array<CharT>::value &&
std::is_integral<typename std::remov
浏览 10提问于2021-06-21得票数 3
1回答
让我们考虑一下下面的代码：
template <bool c>
class A {
public:
A() = default;
// I want to enable f(int) only if c == true
template<typename Temp = typename enable_if<c>::type>
void f(int val) {
cout << val << endl;
};
};
int main() {
A<false>
浏览 2提问于2015-07-01得票数 0
回答已采纳
2回答
考虑下面的代码，这些代码试图使用SFINAE提供不同的方法实现，具体取决于模板参数。
#include <type_traits>
#include <iostream>
template<bool S>
struct C{
template<typename std::enable_if<!S>::type* = nullptr>
int foo(int i){
return i + 1;
}
template<typename std::enable_if&l
浏览 4提问于2014-05-20得票数 0
回答已采纳
4回答
编译以下代码。有谁能解释一下原因吗？我一直在挖掘这个标准，想弄清楚为什么它是合法的。
template <bool B, typename T = void> struct enable_if { };
template <typename T> struct enable_if<true, T> {
typedef T type;
};
template <typename T, typename Enable = void> struct A;
template <typename T> struct A<T, ty
浏览 0提问于2014-04-03得票数 1
这两种实现有什么区别，我应该使用哪种实现，因为如果我从main调用它们，两者的工作原理是相同的：
template<class T, typename std::enable_if<std::is_integral<T>::value, int>::type = 0>
void test( const T& t ){
printf("int\n");
}
template<class T, typename std::enable_if<std::is_floating_point<T>::value
浏览 3提问于2018-03-28得票数 3
回答已采纳
我试图在我的一个项目中增加对icc的支持，但是当有两个以上的方法时，我对SFINAE有一些问题。下面是这个问题的一个简单例子：
#include <iostream>
template<std::size_t Selector>
struct impl {
template<bool Enable = true, typename std::enable_if<Selector == 1 && Enable, int>::type = 0>
static void apply(){
std::co
浏览 3提问于2015-03-31得票数 2
回答已采纳
1回答
根据参数包的特性，我遇到了启用/禁用重载的问题。这是我想回答的另一个问题。我有一个静态go()函数，如果所有Mixins类型都有一个静态check()方法，就应该调用这个函数。同样，如果go()包没有check()方法，则应该调用另一个静态check()方法。我试图创建基于此策略启用的重载，但出于某种原因，当我调用它时，它选择了第二个重载，该重载试图调用handle()。
template<class T, class...>
using first = T;
template<class... Mixins>
struct Checker
{
public:
浏览 1提问于2014-02-22得票数 1
回答已采纳
我只是尝试使用std::enable_if在C++上使用SFINAE。我以为我理解了理论部分，直到我无法编译下面的代码。更加令人困惑的是Visual和Linux上的不同行为。只要您不取消注释(Calculator<int> cInt; )，这个粘贴的代码就会在VS上编译。然而，使用GCC给我编译错误。我已经在STL实现中看到了这样的代码，我真的期待更多的标准化实现无处不在。不管怎么说，你能检查一下并建议一下我在这里的理解中有哪些不足吗？
template<typename T>
class Calculator
{
public:
typename enable
浏览 0提问于2019-09-16得票数 3
回答已采纳
1回答
我定义了一个模板化类(DataArray<T>)，我想定义一个min()函数来计算积分类型数组的最小值(double，float，int，.)或复杂类型数组(std::complex<double>，std::complex<float>，.)。
我试图使用类型特征来选择正确的函数。尽管进行了出色的讨论，但我的代码没有编译：
DataArray和DataArray<std::complex>：没有匹配的重载函数
有什么问题吗？下面是我的代码的最小部分：
#include <iostream>
#include <vect
浏览 0提问于2018-11-26得票数 4
回答已采纳
2回答
我想创建一个form类，它基于其模板参数为一个operator()提供一个或多个参数。这是一个曲线的原型，例如线性，双线性，等等。
因此，如果表单维度是n，则运算符应该有n整数参数，因此带有formdim == 1的线性表单应该有operator()(i)，而formdim == 2 I则希望operator()(i, j)。
我认为enable_if可能会有任何帮助，但我对TMP并没有太深的兴趣，而且我有一个编译错误：
template<unsigned int formdim>
class form
{
public:
form()
{}
auto o
浏览 4提问于2017-03-24得票数 2
回答已采纳
我有两组代码，第一组按预期编译和运行，但似乎不必要地冗长：
template<point_type type, typename T>
struct point2d_base {
std::enable_if_t<std::is_arithmetic_v<T>, T> x, y;
template<point_type t2 = type>
point2d_base(std::enable_if_t<t2 == point_type::generic, T> x = 0, T y = 0) :
浏览 2提问于2016-12-15得票数 1
回答已采纳
1回答
这有什么问题吗？
我认为在使用enable if?时，这应该可以工作。
帮帮忙？
第二个构造函数不应该被排除吗？
#include <iostream>
#include <boost/type_traits.hpp>
#include <boost/utility/enable_if.hpp>
template<class T>
class integral_holder{
public:
integral_holder(T value_, typename boost::enable_if_c< boost::is_integra
浏览 2提问于2012-07-07得票数 2
回答已采纳
我有一个基于运行时返回特定设备的类。
struct ComponentDc;
struct ComponentIc;
typedef Device<ComponentDc> DevComponentDc;
typedef Device<ComponentIc> DevComponentIc;
template<class Component>
class Device{
Device<Component>* getDevice() { return this; }
void exec() { }
};
在exec()中，如果组件类型是Co
浏览 0提问于2013-03-19得票数 5
回答已采纳
1回答
我正在尝试有条件地实例化一个额外的赋值操作符。下面的代码在clang中运行良好，但在gcc 4.7中就不行了。
我遇到的问题似乎与这里提出的问题非常相似：
下面是我遇到的问题：
#include <type_traits>
template<typename T>
struct StrangerTypeRules;
template<typename T>
struct X;
template< >
struct StrangerTypeRules < unsigned > {
typedef unsigned type
浏览 1提问于2012-03-27得票数 5
回答已采纳
4回答
将有一些函数，它们的返回类型可以根据返回值推断出来。
auto function(){
return "hello world";
}
我可以将此行为应用于通过返回类型惯用法为SFINAE使用的函数吗？
例如，让我们考虑以下两个函数：
#include <type_traits>
#include <iostream>
//This function is chosen when an integral type is passed in
template<class T >
auto function(T t) -> typ
浏览 2提问于2013-12-21得票数 18
1回答
我希望启用和禁用模板类中的函数声明，这仅仅是基于模板参数是否有我使用boost/tti/has_type.hpp定义的一种类型。但是，我收到编译器的抱怨，即'enable_if‘不能用于禁用此声明。
#include <boost/tti/has_type.hpp>
#include <iostream>
#include <vector>
#include <set>
using namespace std;
BOOST_TTI_HAS_TYPE(key_type)
template <typename container&g
浏览 3提问于2020-11-05得票数 0
回答已采纳
1回答
我正在编写代码，并决定添加对标量类型的支持，以便能够在std::complex<double>和普通double之间切换。我已经把所有的数字都写好了，我用template <typename Scalar>方法给它做了模板。
我的“问题”是，对于复杂的情况，我需要提供一些在实际情况下没有意义且无法编码的额外方法。
我以前的方法是创建一个基类模板，它实现了所有常见的东西。然后，我有一个具体的类，它派生自这个基类，作为Scalar模板参数std::complex<double>。然后，我有一个模板代理/虚拟类，作为double版本和std::complex<
浏览 0提问于2013-11-07得票数 1
回答已采纳
我试着用msvc编译它，它编译得很好。另一方面，我无法用g++和clang++编译它。我得到的错误是no type named ‘type’ in ‘struct std::enable_if<false, void>’。我该如何解决这个错误？ #include <type_traits>
template <bool v>
struct a {
template <typename T = typename std::enable_if<v>::type>
void function();
};
templ
浏览 122提问于2021-01-17得票数 1
回答已采纳
根据enable_if结构的定义：
template<bool B, class T = void>
struct enable_if {};
template<class T>
struct enable_if<true, T> { typedef T type; };
我想知道如何
template<class T>
T foo(T t, typename std::enable_if<std::is_integral<T>::value >::type* = 0)
{
return t;
}
特别是：
t
浏览 1提问于2012-11-13得票数 2
回答已采纳
我试图在头文件和使用专门化的实现之间划分一个模板类，但我希望一个方法只出现在某些专门化中。
头文件：
template <typename T>
class A
{
public:
void foo();
void bar();
template<typename U = T, typename std::enable_if<std::is_convertible<int,U>::value>::type* = nullptr>
void special();
};
执行情况：
template<typename T&
浏览 0提问于2019-08-27得票数 3
回答已采纳
3回答
作为实验，我尝试让一个不带参数的void成员函数根据类模板参数改变行为：
#include <iostream>
#include <limits>
template<typename T>
class MyClass
{
public:
void MyFunc(const typename std::enable_if<std::is_fundamental<T>::value, T> dummy = T());
void MyFunc(const typename std::enable_if<!std::is_f
浏览 0提问于2012-01-05得票数 1
回答已采纳
2回答
如何为枚举值部分地专门化类模板？
、、、、
模板可以基于枚举值进行专门化吗？
#include <type_traits>
template<typename T, typename = void>
struct Specialize
{
};
template<typename T>
struct Specialize<T, typename std::enable_if<std::is_enum<T>::value>::type>
{
void convert() { }
};
enum E
{
};
int main()
{
Speci
浏览 0提问于2019-06-18得票数 2
回答已采纳
1回答
模板参数语法作为表达式
、、、、
有人知道下面的代码如何为enable_if的模板参数工作吗？
template <int n> void f(typename std::enable_if<(n < 0)>::type* = 0) {
/* ... n is negative ... */
}
template <int n> void f(typename std::enable_if<(n >= 0)>::type* = 0) {
/* ... n is positive ... */
}
具体来说，这部分(n < 0)>::type*对我来说没有意
浏览 4提问于2016-01-18得票数 1
回答已采纳
这些类之间有什么区别？正是这些方法与enable_if。
/// Alias of std::enable_if...
template <bool B, typename T = void>
using Enable_if = typename std::enable_if<B, T>::type;
Template<typename T, std::size_t N>
class A {
...
template <std::size_t NN = N,
typename = Enable_if<NN ==
浏览 0提问于2019-08-11得票数 7
回答已采纳
我找到了一篇关于这个主题的很棒的文章，在第10页，作者注意到了两件重要的事情：
当使用启用器重载函数模板时，使能器被放置在声明部分中。
不需要实现通常的dispatcher --一个分配给实现的单独接口函数。
点1可以在SO上找到这个。作者声明(打印出来的文章的第10页)，也可以使用使能器作为函数参数，这就是我要做的事情，但是在那个示例中，ADL失败了。
第2点是依赖于SFINAE和减少函数模板集。当使能器失败时，SFINAE将不会报告错误，并且当选择最适合的模板时，将导致参数的推导。
话虽如此，我还是修改了以前的：
#include <type_traits>
#
浏览 1提问于2014-03-26得票数 0
回答已采纳
在查看std::enable_if时，我看到了这个示例
template<class T,
typename = std::enable_if_t<std::is_array<T>::value> >
void destroy(T* t)
{
for(std::size_t i = 0; i < std::extent<T>::value; ++i) {
destroy((*t)[i]);
}
}
在模板参数列表中，可以放置未模板的类/结构。因此，当我们删除typename =时，上面的代码仍然是可能的。这段代码中的t
浏览 2提问于2022-11-05得票数 1
回答已采纳
我有一个带有布尔模板参数Bird的类模板can_fly。根据该值，我希望启用一个具有签名void fly();的成员函数。
这是我的密码：
#include <type_traits>
template<bool can_fly>
class Bird {
public:
template<typename void_t = typename std::enable_if<can_fly>::type>
void_t fly() { /* ... */ }
};
int main() {
Bird<true>
浏览 2提问于2016-12-11得票数 2
回答已采纳
为什么我不能在下面的上下文中使用enable_if？
我想检测我的模板对象是否有成员函数notify_exit
template <typename Queue>
class MyQueue
{
public:
auto notify_exit() -> typename std::enable_if<
has_member_function_notify_exit<Queue, void>::value,
void
>::type;
Queue queue_a;
浏览 0提问于2018-08-29得票数 15
回答已采纳
我想根据给定的类型为std::uniform_*_distribution做一个特征。例如：
distribution_traits<float>::type int_dist;
我试过以下几种方法，但它们都没有编译，我不知道为什么。
实现1
将std::enable_if与typedef一起使用：
template <typename T>
struct distribution_traits {
using type = typename std::enable_if<std::is_integral<T>::value, std::unifo
浏览 4提问于2014-03-01得票数 0
回答已采纳
为什么class A编译和class B不编译，编译器抱怨有两个声明，而不是两者都依赖SFINAE？在使用foo时，两者实际上都应该使用模板类型推断。
所以问题是，在这两个版本中有什么细微的区别，为什么class A成功地使用了sfinae.？
类A使用value-defaulted (零)匿名(不必要)非类型模板参数。
类B使用type-defaulted (与enable_if)同名的类型模板参数
守则：
template<typename T>
struct A
{
template<typename U,
type
浏览 3提问于2015-07-25得票数 2
回答已采纳
我希望创建一个模板化类test<T>，如果T可以转换为U，则可以转换为T(可能是隐式的)。我想到的最简单的想法是添加一个模板构造函数，该构造函数接受一个test<U>，其中模板参数U由enable_if控制。
#include <iostream>
#include <type_traits>
template <typename T>
class test {
int _foo;
public:
int foo() const { return _foo; }
test() : _foo(5) {}
浏览 2提问于2016-08-06得票数 2
回答已采纳
1回答
Stroustrup C++第4版第796页指出，“如果Enable_if的条件计算为false，则完全忽略它所属的整个函数声明。”还有"...we不申报任何东西“。
有人知道为什么要声明第一个f0()吗？我正确地使用了enable_if吗？
我的目标是禁用其中一个声明。我不知道两个f0()怎么会有一个返回类型，因为false版本应该缺少::type。
#include <type_traits>
using namespace std;
template<bool B, typename T>
using Enable_if = typename std::
浏览 7提问于2020-07-26得票数 2
回答已采纳
下面是我有些奇怪的代码：
template <typename T&>
class A {
public:
void b(typename std::enable_if<!std::is_pointer<T>::value, T>;::type o) {}
void b(typename std::enable_if<std::is_pointer<T>::value, T>;::type o) {}
};
template <typename T>
void b(typename
浏览 1提问于2012-06-28得票数 4
回答已采纳
我在这样的头文件中定义了一个类(尽管这是一个精简的版本)：
my_class.hpp
// header guard
template<typename T, std::size_t First, std::size_t Second, class Enable = void>
class other_class;
template<typename T, std::size_t Size, class Enable = void>
class my_class; // I have my reasons
templa
浏览 3提问于2014-05-08得票数 2
为了学习如何使用Eric Niebler的ranges v3库，并阅读源代码，我看到了这个宏定义：
#define CONCEPT_PP_CAT_(X, Y) X ## Y
#define CONCEPT_PP_CAT(X, Y) CONCEPT_PP_CAT_(X, Y)
/// \addtogroup group-concepts
浏览 3提问于2017-08-25得票数 5
回答已采纳
4回答
这可能是一个副本，但我就是找不到一个明显和我有相同问题的OP。
我有一个类，并且仅当类模板参数不是无符号类型时才尝试启用operator-。
#include <type_traits>
template<class T>
struct A {
typename std::enable_if<!std::is_unsigned<T>::value,A>::type operator-() {return {};}
};
int main() {
A<unsigned> a=a;
}
不幸的是，每当我使用如下所示的无
浏览 0提问于2014-03-27得票数 8
2回答
在下面这样的条件下我遇到了一个问题：
#include <iostream>
#include <type_traits>
#define TRACE void operator()() const { std::cerr << "@" << __LINE__ << std::endl; }
template <class T>
struct check : std::true_type {};
template <class F, class T, class Check=void>
s
浏览 1提问于2012-07-16得票数 6
3回答
这或多或少是从boost文档中粘贴的副本，我一直收到一个错误(实际上有很多错误)
我正在尝试确保模板类仅用于使用boost的数字。这是boost中的一个练习，而不是创建一个只使用数字的模板类。
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_arithmetic.hpp>
using namespace boost;
template <class T>
class A<T, typename enable_if<is_arithmetic<T&
浏览 0提问于2010-11-01得票数 0
回答已采纳
2回答
我正在编写一个类IteratorIterable，它封装了一个容器类(一个带有返回一些迭代器的begin()和end()方法的类)，以便能够在包装类的迭代器上进行迭代。这个想法是基于的。我的代码如下所示(为了简洁起见，有些方法漏掉了)：
template <class T>
class IteratorIterable
{
private:
T& container;
public:
typedef decltype(container.begin()) BackendIterator;
public:
class IteratorIterato
浏览 0提问于2014-08-20得票数 1
回答已采纳
下面是我在实际代码中遇到的问题的简化版本。
短版本：只需查看 / long version上的代码和错误: read on ;)
假设我想要一个具有模板参数setting的类和一个方法int func(int)，例如：
当setting为false时，func返回其参数
当setting是true时，func将其参数加倍。
最简单的方法是专门化类模板：
template<bool setting> struct A {
int func(x) const { return 2 * x; }
};
template<> struct A<fa
浏览 1提问于2016-02-24得票数 4
回答已采纳
我正在尝试编写一个函数，它接受给定类型的(前向)迭代器。使用SFINAE将会非常有帮助。我想出了以下(不起作用的)解决方案：
template<class ForwardIterator,
typename std::enable_if<
std::is_same<typename std::iterator_traits<ForwardIterator>::value_type, int>::value
>::type
>
inline void foo(ForwardIterator begin, Fo
浏览 11提问于2019-10-30得票数 0
回答已采纳
4回答
考虑到类模板，可以使用类型特征和虚拟启用器模板参数为特定类型的组提供模板专门化。我已经了。
现在，我需要对函数模板做同样的事情:也就是说，我有一个模板函数，并想要一组类型的专门化，例如，作为类X的子类型的所有类型。我可以用这样的类型特征来表达：
std::enable_if<std::is_base_of<X, T>::value>::type
我想过这样做：
template <typename T, typename ENABLE = void>
void foo(){
//Do something
}
template <typenam
浏览 2提问于2012-09-03得票数 6
回答已采纳
2回答
我查看了以下模板函数，并想知道当我们将enable_if类型分配给typename关键字时，幕后会发生什么情况：
template <typename T, typename = std::enable_if<std::is_pointer<T>::value>::type>
// ^^ What happens here?
void foo()
{
std::cout << "T is a pointer!" << std::endl;
}
另外，显而易见的SFINAE
浏览 1提问于2015-12-19得票数 0
回答已采纳
1回答
当我试图编写一个递归模板成员函数来迭代元组时，我遇到了一个问题。
在以下代码中：
#include <cstddef>
#include <iostream>
#include <string>
#include <tuple>
template <typename... P>
class A
{
public:
typedef std::tuple<P...> tup_t;
tup_t tup;
};
template <typename T, typename... P>
class AA :
浏览 4提问于2011-10-11得票数 3
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
云直播活动推荐
腾讯云开发者
