C++ 模板实参类型限制

有时间我们编写一个模板，希望用户使用我们盼望的类型来实例化它，就须要对实参进行检查，限制不满足条件的实例化版本，同时给出便于理解的编译时信息
对于 C++20 后的版本，可以将条件包装为concept：
折叠代码

1. template<typename T>
2. concept check = requires(T t)
3. {
4.   T{};//可以默认构造
5.   typename T::value_type;//定义了value_type类型名
6.   t.x;//具有名为x的成员变量
7.   t.set(1);//具有名为set的成员函数，并且可以使用(int)1调用
8. };
10. struct A//完全满足所有要求
11. {
12.   typedef float value_type;
13.   value_type x;
14.   void set(value_type _x){}//concept检查接口调用时接受int到float的隐式转换
15. };
17. struct B//无默认构造函数
18. {
19.   typedef int value_type;
20.   value_type x;
21.   B(int _x):x(_x){}
22.   void set(value_type _x){}
23. };
25. struct C//没有定义value_type类型名
26. {
27.   int x;
28.   void set(int _x){}
29. };
31. struct D//没有名为x的数据成员
32. {
33.   typedef int value_type;
34.   void set(value_type _x){}
35. };
37. struct E//没有名为set的成员函数
38. {
39.   typedef int value_type;
40.   value_type x;
41. };
43. template<check T>
44. struct tp1{};
46. tp1<A> a;//OK
47. tp1<B> b;//错误，无默认构造函数可用
48. tp1<C> c;//错误，value_type未定义
49. tp1<D> d;//错误，x不是D的成员
50. tp1<E> e;//错误，set不是E的成员

复制代码

通过concept可以方便的包装条件，并且在编译时给出相对易于理解的错误信息，但是假如我们的编译环境不支持 C++20，这些检查的实现就会颇为复杂：折叠代码

1. #define DETECT_TYPE_DEFINITION(name)                                                                                                                                \
2. template<typename T, typename = void>                                                                                                                                \
3. struct detect_type_definition_##name##_impl:std::false_type {};                                                                                \
4. template<typename T>                                                                                                                                                                \
5. struct detect_type_definition_##name##_impl<T, std::void_t<typename T::name>>:std::true_type {};        \
6. template<typename T>                                                                                                                                                                \
7. constexpr bool has_type_definition_##name()                                                                                                                        \
8. {                                                                                                                                                                                                        \
9.   return detect_type_definition_##name##_impl<T>::value;                                                                                        \
10. }
12. //《C++ Templates》中讲到的方法，impl函数利用 SFINAE 特性，只用作返回值类型推导，无需函数体
13. #define DETECT_MEMBER(name)                                                                                                                                                        \
14.   template <typename T>                                                                                                                                                            \
15.   auto detect_member_##name##_impl(int) -> decltype(std::declval<T>().name, std::true_type{});            \
16.   template <typename>                                                                                                                                                                \
17.   auto detect_member_##name##_impl(...) -> std::false_type;                                                                                    \
18.   template <typename T>                                                                                                                                                            \
19.   constexpr bool has_member_##name()                                                                                                                                \
20.   {                                                                                                                                                                                                    \
21.     return decltype(detect_member_##name##_impl<T>(0))::value;                                                                            \
22.   }
24. #define DETECT_MEMBER_FUNC(name)                                                                                                                                        \
25.   template<typename T, typename... Args>                                                                                                                        \
26.   auto detect_member_func_##name##_impl(int) ->                                                                                                            \
27.     decltype(std::declval<T>().name(std::declval<Args>()...), std::true_type{});                                    \
28.   template<typename, typename...>                                                                                                                                        \
29.   auto detect_member_func_##name##_impl(...) -> std::false_type;                                                                        \
30.   template<typename T, typename... Args>                                                                                                                        \
31.   constexpr bool has_member_func_##name()                                                                                                                        \
32.   {                                                                                                                                                                                                    \
33.     return decltype(detect_member_func_##name##_impl<T, Args...>(0))::value;                                            \
34.   }
36. //使用宏可以方便地扩展到不同名称的成员检测上，便于复用
37. DETECT_TYPE_DEFINITION(value_type);//生成对名为value_type的类型定义的检测模板
38. DETECT_MEMBER(x);//生成对名为x的成员变量的检测模板
39. DETECT_MEMBER_FUNC(set);//生成对名为成员函数set的检测模板
41. //辅助检测基类
42. template<typename T>
43. struct check
44. {
45.   static_assert(std::is_default_constructible<T>::value, "no default constructor");//是否可以默认构造
46.   static_assert(has_type_definition_value_type<T>(), "no definition of 'value_type'");//是否定义了value_type类型名
47.   static_assert(has_member_x<T>(), "no member named 'x'");//是否有名为x的成员
48.   static_assert(has_member_func_set<T, int>(), "no member function named 'set' or "
49.     "the member function 'set' can not be called with an integer");//是否有名为set，并且可用int调用的成员函数
50. };
52. template<typename T /*, typename trigger_check = check<T>若tp2内未使用check<T>，check<T>的实例化将会被跳过*/>
53. struct tp2: check<T>//继承自check以保证check被实例化
54. {
55.   //using trigger_check = check<T>;//同默认模板实参一样，可能由于惰性实例化而跳过
56. };
58. //类A、B、C、D、E为先前的定义
59. tp2<A> a;//OK
60. tp2<B> b;//错误，no default constructor
61. tp2<C> c;//错误，no definition of 'value_type'
62. tp2<D> d;//错误，no member named 'x'
63. tp2<E> e;//错误，no member function named 'set' or the member function 'set' can not be called with an integer

复制代码

通过继续（代码注释中已解释为什么不用默认模板实参和类型别名）可以将检查条件封装于基类中，使用静态断言，可在发生编译错误时提供可读性更高的错误提示。在多个模板类都须要相同的实参约束条件时，将约束条件收集到基类中可以增加代码复用性，减少搬砖性子的劳动。例如在编写几何类库时，很多类都要求使用算术类型来实例化：折叠代码

1. template<typename T>
2. struct arithmetic_check
3. {
4.   static_assert(std::is_arithmetic<T>::value, "instanciation requires arithmetic types");
5. };
7. template<typename T>
8. class point : arithmetic_check<T> {...};
9. template<typename T>
10. class rect : arithmetic_check<T> {...};
11. template<typename T>
12. class line_segment : arithmetic_check<T> {...};
13. ...

复制代码

若通用条件无法满足需求，可以通过继续扩充条件约束：折叠代码

1. //不仅需要算术类型，还要求是有符号
2. template<typename T>
3. struct singed_check : arithmetic_check<T>
4. {
5.   static_assert(std::is_signed<T>::value, "instanciation requires signed arithmetic types");
6. };
7. template<typename T>
8. class real_point : singed_check {...};

复制代码

上述简单例子有些故意为之，但是足以展示编码思路。由于所有的条件约束类都不存在非静态数据成员，编译器可以针对它们启用空基类优化策略（EBCO，Empty Base Class Optimization），不会增加内存占用。
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。