C++之std::enable_if

相关系列文章

C++之std::is_object

C++之std::decay

C++模板函数重载规则细说

C++之std::declval

C++之std::move(移动语义)

C++之std::forward(完美转发)

C++之std::enable_if

C++之std::is_pod(平凡的数据)

目录

1.概述

2.函数返回值场景

3.函数参数场景

4.作为类模板或函数模板参数

1.概述

std::enable_if是C++11引入的模板结构体，在VS2019中文件定义，它的原型是：

  1. template <bool _Test, class _Ty = void>
  2. struct enable_if {}; // no member "type" when !_Test
  3.  
  4. template <class _Ty>
  5. struct enable_if<true, _Ty> { // type is _Ty for _Test
  6.     using type = _Ty;
  7. };
  8.  
  9. template <bool _Test, class _Ty = void>
  10. using enable_if_t = typename enable_if<_Test, _Ty>::type;

        _Test如果是true, std::enable_if的type为_Ty；如果是false, type没有定义，这种情况在程序编译的时候就会报错，此元函数是活用 SFINAE ，基于类型特性条件性地从重载决议移除函数，并对不同类型特性提供分离的函数重载与特化的便利方法。 std::enable_if 可用作额外的函数参数（不可应用于运算符重载）、返回类型（不可应用于构造函数与析构函数），或类模板或函数模板形参。

        因此std::enable_if可以以多种形式使用，它的作用主要有：

        1)通过函数的返回值，控制不同的条件下，选择不同的模板

        2)通过函数的参数，控制不同的条件下，选择不同的模板

        3)作为类模板或函数模板参数，控制不同的数据类型，选择不同的类模板或函数模板

下面就举例一一用示例说明它们的具体用法

2.函数返回值场景

  1. #include 
  2. #include 
  3.  
  4. template <typename T>
  5. typename std::enable_if ::value, T>::type  addT(T value)
  6. {
  7. 	return value + 10;
  8. }
  9.  
  10. template <typename T>
  11. typename std::enable_if ::value, T>::type  addT(T value)
  12. {
  13. 	return value + 5.0;
  14. }
  15.  
  16. int main()
  17. {
  18.     int d = 10;
  19. 	double f = 20;
  20. 	d = addT(d);  //d = 20
  21. 	f = addT(f);  //f = 25.000000000
  22.     return 0;
  23. }

3.函数参数场景

示例1：

  1. template <typename T>
  2. T  addT(T  value, typename std::enable_if::value, T>::type* = nullptr)
  3. {
  4. 	return value + 10;
  5. }
  6.  
  7. template <typename T>
  8. T  addT(T value, typename std::enable_if::value, T>::type* = nullptr)
  9. {
  10. 	return value + 5;
  11. }
  12.  
  13. int  main()
  14. {
  15.     int d = 10;
  16. 	double f = 20;
  17. 	d = addT(d);
  18. 	f = addT(f);
  19.     return 0;
  20. }

示例2：

  1. #include 
  2.  
  3. // enabled via a parameter
  4. template<class T>
  5. void destroy(T *,
  6.     typename std::enable_if::value>::type * = 0) {
  7.   std::cout << "destroying trivially destructible T\n";
  8. }
  9.  
  10. // enabled via a non-type template parameter
  11. template<class T, typename std::enable_if{} &&
  12.             (std::is_class{} || std::is_union{}),bool>::type = true>
  13. void destroy(T* t)
  14. {
  15.   std::cout << "destroying non-trivially destructible T\n";
  16. }
  17.  
  18. int main() {
  19.   int nValue = 1;
  20.   std::string test = "hell";
  21.   destroy(&nValue);
  22.   destroy(&test);
  23.   return 0;
  24. }
  25.  
  26. 输出如下：
  27. destroying trivially destructible T
  28. destroying non-trivially destructible T

示例3：

利用sprintf把数字或字符串转换为std::string, 根据格式化的不同，就用std::enable_if控制调用不同的转换函数，代码如下：

  1. //1
  2. template <int N>
  3. std::string  tToString(char(&value)[N])
  4. {
  5. 	std::string  temp;
  6. 	for (int i = 0; i < N; i++) {
  7. 		temp += value[i];
  8. 	}
  9. 	return temp;
  10. }
  11. //2
  12. template <typename T>
  13. std::string  tToString(T value, typename std::enable_if_tbool>, T>* = 0) {
  14. 	char format[64] = { 0 };
  15. 	sprintf(format, "%s", value ? "true" : "false");
  16. 	return format;
  17. }
  18. //3
  19. template <typename T>
  20. std::string  tToString(T value, typename std::enable_if_tconst char*> ||
  21. 	std::is_same_vchar*> ||
  22. 	std::is_same_v, T>* = 0) {
  23. 	return value;
  24. }
  25. //4
  26. template <typename T>
  27. std::string  tToString(T value, typename std::enable_if_t &&
  28. 	!std::is_same_v bool>, T>* = 0) { //std::is_integral_v， 整数
  29. 	char format[64] = { 0 };
  30. 	sprintf(format, "%d", value);
  31. 	return format;
  32. }
  33. //5
  34. template <typename T>
  35. std::string  tToString(T value, typename std::enable_if_t, T>* = 0) { //浮点数
  36. 	char format[64] = { 0 };
  37. 	sprintf(format, "%f", value);
  38. 	return format;
  39. }
  40. int main()
  41. {
  42.     std::string f = tToString(true);  //调用 2 版本函数
  43. 	f = tToString(100);               //调用 4 版本函数
  44. 	f = tToString("43634636");        //调用 3 版本函数
  45. 	f = tToString(88.4444);		      //调用 5 版本函数
  46. 	f = tToString(std::string("435236236")); //调用 3 版本函数
  47.  
  48. 	char testT[] = "35353535345";
  49. 	f = tToString(testT);             //调用 1 版本函数
  50.  
  51. 	char* pTest = testT;
  52. 	f = tToString(pTest);             //调用 3 版本函数
  53.  
  54. 	const char* pTest1 = "ntrnrtnr44";
  55. 	f = tToString(pTest1);            //调用 3 版本函数
  56.     
  57.     return 0;
  58. }

4.作为类模板或函数模板参数

  1. struct T {
  2.     enum { int_t,float_t } m_type;
  3.     template <typename Integer,
  4.               std::enable_if_t, int> = 0
  5.     >
  6.     T(Integer) : m_type(int_t) {}
  7.  
  8.     template <typename Floating,
  9.               std::enable_if_t, int> = 0
  10.     >
  11.     T(Floating) : m_type(float_t) {} // OK
  12. };
  1. template <typename T, typename Enable = void>
  2. class MyTestClass
  3. {
  4. 	// 默认实现，适用于所有类型
  5. public:
  6. 	MyTestClass() {
  7. 		std::cout << "default";
  8. 	}
  9. };
  10.  
  11. template <typename T>
  12. class MyTestClasstypename std::enable_if::value>::type>
  13. {
  14. 	// 整型类型的特化实现
  15. public:
  16. 	MyTestClass() {
  17. 		std::cout << "int";
  18. 	}
  19. };
  20.  
  21. template <typename T>
  22. class MyTestClasstypename std::enable_if::value>::type>
  23. {
  24. 	// 浮点型类型的特化实现
  25. public:
  26. 	MyTestClass() {
  27. 		std::cout << "float";
  28. 	}
  29. };
  30. int main()
  31. {
  32. 	MyTestClass  x1;// OK ：匹配初等模板
  33. 	MyTestClass<int>  x2;        // OK ：匹配偏特化 int 
  34. 	MyTestClass<double>  x3;     // OK ：匹配偏特化 double
  35.     return 0;
  36. }

参考

std::enable_if - cppreference.com

注：本文转载自blog.csdn.net的流星雨爱编程的文章"https://blog.csdn.net/haokan123456789/article/details/135025230"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！