C++模板元编程详细教程（之七）

已于 2023-02-09 13:26:38 修改
阅读量2.3k 收藏 13
点赞数 10
分类专栏： C++代码 文章标签： c++ 开发语言
于 2023-02-06 13:57:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fl2011sx/article/details/128864369
版权

前序文章请看：
C++模板元编程详细教程（之一）
C++模板元编程详细教程（之二）
C++模板元编程详细教程（之三）
C++模板元编程详细教程（之四）
C++模板元编程详细教程（之五）
C++模板元编程详细教程（之六）

前面我们介绍了一些基础的静态数值计算和类型处理，这一篇开始将会介绍一些进阶型的内容，做更加复杂的逻辑判断和类型处理。

函数类型的处理

如果我希望处理出一个函数类型的返回值，要怎么办呢？请看例程：

template <typename T>
struct GetRet {
};

template <typename R, typename... Args>
struct GetRet<R(Args...)> {
  using type = R;
};

template <typename T>
using GetRet_t = typename GetRet<T>::type;

// 以下是示例
int f() {return 0;}
void Demo() {
  GetRet_t<decltype(f)> a;
  std::cout << std::is_same_v<std::decay_t<decltype(a)>, int>; // true
}

我们注意到，此时的偏特化，用到了前面章节模板基础知识中的「函数类型」，也就是说，只有符合R(Args...)形式的参数才会入到这个偏特化中。那么在这种情况下，「函数类型」和「函数指针类型」就是截然不同的。也就是说下面的代码不能正确解析：

void Demo() {
  GetRet_t<decltype(f)> a; // f是函数类型，可以正确推导
  GetRet_t<decltype(&f)> b; // &f是函数指针类型，不能命中偏特化，而是会用通用模板，又因为通用模板不含type成员，因此这里报错
}

同样，仿函数类型、lambda类型、函数对象类型、成员函数类型都无法命中，进而无法取出返回值。因此，我们如果希望支持所有的情况，那就还要考虑支持其他的类型。对于仿函数和lambda类型来说，我们就要去取出它的operator ()方法的返回值类型，对于函数对象类型来说也是一样的。所以我们代码可以改造成：

template <typename T>
struct GetRet {
 private:
  using DT = std::decay_t<T>;
 public:
  // 如果内部含有operator()就取它的类型
  using type = typename GetRet<decltype(&DT::operator())>::type;
};

// 对于函数类型
template <typename R, typename... Args>
struct GetRet<R(Args...)> {
  using type = R;
};

// 对于函数指针类型
template <typename R, typename... Args>
struct GetRet<R(*)(Args...)> {
  using type = R;
};

// 对于非静态成员函数类型
template <typename T, typename R, typename... Args>
struct GetRet<R(T::*)(Args...)> {
  using type = R;
};
template <typename T, typename R, typename... Args>
struct GetRet<R(T::*)(Args...) const> {
  using type = R;
};

template <typename T>
using GetRet_t = typename GetRet<T>::type;

// 测试用例
int f() {return 0;}
struct T1 {
  int m();
};

struct T2 {
  int operator()();
};

void Demo() {
// 函数类型
  GetRet_t<decltype(f)> a;
  // 函数指针类型
  GetRet_t<decltype(&f)> b;
  // 仿函数类型
  GetRet_t<T2> c;
  // lambda类型
  GetRet_t<decltype([]()->int{return 0;})> d;
  // 非静态成员函数类型
  GetRet_t<decltype(&T1::m)> e;
  // 函数对象类型
  GetRet_t<std::function<int()>> g;
  
  std::cout << std::is_same_v<std::decay_t<decltype(a)>, int>; // true
  std::cout << std::is_same_v<std::decay_t<decltype(b)>, int>; // true
  std::cout << std::is_same_v<std::decay_t<decltype(c)>, int>; // true
  std::cout << std::is_same_v<std::decay_t<decltype(d)>, int>; // true
  std::cout << std::is_same_v<std::decay_t<decltype(e)>, int>; // true
  std::cout << std::is_same_v<std::decay_t<decltype(g)>, int>; // true
}

这样做确实可以解决问题，但是有点太「老实巴交」了，踏踏实实去适配所有情况肯定是比较保守的做法，只不过对于当前这个需求，我们还有一种更简单的做法：

template <typename T>
struct GetRet {
  // 直接invoke这个类型的成员，推导返回值
  using type = decltype(std::declval<std::decay_t<T>>()());
};

// 对于非静态成员函数类型（这个还是要单独适配）
template <typename T, typename R, typename... Args>
struct GetRet<R(T::*)(Args...)> {
  using type = R;
};
template <typename T, typename R, typename... Args>
struct GetRet<R(T::*)(Args...) const> {
  using type = R;
};

这里需要解释一下declval的功能。在类型变换中，我们是没有实际数据的，换句话说，不会真的去定义一个T类型的变量，而仅仅是需要它来参与类型的变换。但假如这时T不含有无参构造的话，就会失败：

struct Test {
  Test(int); // 没有无参构造
  void method();
};

template <typename T>
struct XXX {
  using type = decltype(T{}.method()); // 这里构造T{}的时候会失败
};

这里我们为了调用非静态成员函数method，就不得不构造一个T类型的对象，但这个对象只在静态分析的时候才有，并不需要真的构造，所以它的构造函数是怎么样的不重要，但上面这种情况又会让编译器去匹配构造函数的问题，从而产生错误。

为了解决这个「仅需要类型，而不想做构造检测」的问题，我们只能想其他的方法，例如这样：

template <typename T>
struct XXX {
  // 通过指针转换，避开构造检测机制
  using type = decltype((static_cast<T *>(nullptr))->method());
};

而STL中就提供了declval工具，用来避开构造检测而生成一个纯类型的对象，实现如下：

template <typename T>
T declval() {
// 不需要实现，因为它不会真正被调用，仅仅用于静态处理获取类型
}

所以，刚才的例子我们就可以改写成：

struct Test {
  Test(int); // 没有无参构造
  void method();
};

template <typename T>
struct XXX {
  using type = decltype(declval<T>().method()); // 这样就不会构造失败了
};

再回头看一开始的例子：

template <typename T>
struct GetRet {
  // 直接invoke这个类型的成员，推导返回值
  using type = decltype(std::declval<std::decay_t<T>>()());
};

前面std::declval<std::decay_t<T>>()用于生成这个纯类型的对象，再后面一个()就表示invoke行为（对于函数、函数指针会进行调用；对于仿函数、lambda、函数对象类型则会调用其operator()函数），再对调用行为进行一次decltype即可获取到返回值类型。

那，如果我们想获取参数类型呢？比如说，我想获取函数的第二个参数的类型，要怎么做？这时，由于不像返回值那样可以直接invoke来判断，参数类型的获取就只能用传统的方法了，效果如下：

template <typename T>
struct Get2ndArg {
 private:
  using DT = std::decay_t<T>;
 public:
  // 如果内部含有operator()就取它的类型
  using type = typename Get2ndArg<decltype(&DT::operator())>::type;
};

template <typename R, typename Arg1, typename Arg2, typename... Args>
struct Get2ndArg<R(Arg1, Arg2, Args...)> {
  using type = Arg2;
};

template <typename R, typename Arg1, typename Arg2, typename... Args>
struct Get2ndArg<R(*)(Arg1, Arg2, Args...)> {
  using type = Arg2;
};

template <typename T, typename R, typename Arg1, typename Arg2, typename... Args>
struct Get2ndArg<R(T::*)(Arg1, Arg2, Args...)> {
  using type = Arg2;
};

template <typename T, typename R, typename Arg1, typename Arg2, typename... Args>
struct Get2ndArg<R(T::*)(Arg1, Arg2, Args...) const> {
  using type = Arg2;
};

template <typename T>
using Get2ndArg_t = typename Get2ndArg<T>::type;

如果要获取第一个参数，或者第N个参数的类型，那么都是相同的道理，这里就不再啰嗦了。

自定义类型的处理

单一的类型处理我们已经体验过了，那对于复杂类型呢？比如说，判断类型T中是否存在一个名为f的成员？

这个需求里，最主要的思路就是，我们要「尝试」来推导一下T::f的类型，如果这个东西存在，那么就能够推导出来（尽管推导出来的类型是什么我们并不关心）；而如果不存在T::f这个东西，那么就会实例化失败，从而触发SFINAE继续匹配通用模板。

判断T是否含有一个类型为int的成员f

首先我们先来简化一下问题，这里我们要求T::f必须是int类型的静态成员，那么代码如下：

template <typename T, typename V = int> // V是辅助参数
struct HasMemberF : std::false_type {}; // 判断T中是否函数f成员

template <typename T>
struct HasMemberF<T, decltype(T::f)> : std::true_type {};

template <typename T>
constexpr inline bool HasMemberF_v = HasMemberF<T>::value;

// 以下是Demo
struct T1 {
  static int f; // 符合条件
};

struct T2 {
 static double f; // 含有f但类型不匹配
};

struct T3 {}; // 不含f

void Demo() {
  std::cout << HasMemberF_v<T1> << std::endl; // 1
  std::cout << HasMemberF_v<T2> << std::endl; // 0
  std::cout << HasMemberF_v<T3> << std::endl; // 0
  std::cout << HasMemberF_v<int> << std::endl; // 0
}

着重解释一下这里的写法，首先，通用模板中含有2个参数，但是第二个参数V是用做辅助参数的，我们给它默认参数为int。之后，其实我们是要给HasMemberF<T, int>来绑定true_type的。但仅当T::f的类型是int时才生效。

例如，当传入的参数是T1时，decltype(T1::f)是int，因此，下面的偏特化便存在，也就是模板会变成：

template <typename T, typename V = int>
struct HasMemberF : std::false_type {};

template <typename T>
struct HasMemberF<T, int> : std::true_type {}; // 当T是T1时，decltype(T::f)变成int，所以偏特化存在

而又因为通用模板中，V默认就是int，所以HasMemberF<T1>就是HasMemberF<T1, int>，显然是命中了偏特化的，因此value为true。

而当用```T2``来实例化时，下面的偏特化也存在，但是变成了：

template <typename T, typename V = int>
struct HasMemberF : std::false_type {};

template <typename T>
struct HasMemberF<T, double> : std::true_type {}; // 当T是T2时，decltype(T::f)变成double，所以偏特化存在

而又因为默认参数的存在，HasMemberF<T2>就是HasMemberF<T2, int>，并没有命中偏特化，所以value为false。

再来看T3的情况，由于T3不存在成员f，所以decltype(T3::f)就成为了不合法语句，根据SFINAE原则，这里的偏特化也就不会生成代码。所以仅仅存在一个通用模板，那么HasMemberF<T3>自然会命中通用模板，其value是false。HasMemberF<int>跟HasMemberF<T3>是相同的道理。

那如果不要求T::f是静态的，只要是int类型成员就符合呢？道理是相同的，只不过由于非静态成员不能直接通过类型来取出（T::f语句不合法），因此只能换一种方式，通过declval来取出（std::declval<T>().f）。下面是代码：

template <typename T, typename V = int>
struct HasMemberF : std::false_type {};

template <typename T>
struct HasMemberF<T, decltype(std::declval<T>().f)> : std::true_type {}; // 这里用std::declval<T>().f代替T::f

template <typename T>
constexpr inline bool HasMemberF_v = HasMemberF<T>::value;

// 以下是Demo
struct T1 {
  static int f; // 符合条件，静态int成员
};

struct T2 {
  int f; // 符合条件，非静态int成员
};

struct T3 {}; // 不含f

void Demo() {
  std::cout << HasMemberF_v<T1> << std::endl; // 1
  std::cout << HasMemberF_v<T2> << std::endl; // 1
  std::cout << HasMemberF_v<T3> << std::endl; // 0
}

这样，无论静态还是非静态，只要是int类型就符合。

但如果我要求只想筛选出非静态的怎么办？那就只能通过取地址的方式拿出成员变量了（&T::f取出成员的指针类型），代码如下：

template <typename T, typename V = int T::*> // 注意这里改成成员指针类型
struct HasMemberF : std::false_type {};

template <typename T>
struct HasMemberF<T, decltype(&T::f)> : std::true_type {};

template <typename T>
constexpr inline bool HasMemberF_v = HasMemberF<T>::value;

// 以下是Demo
struct T1 {
  static int f; // 不符合条件，静态int成员
};

struct T2 {
  int f; // 符合条件，非静态int成员
};

struct T3 {}; // 不含f

void Demo() {
  std::cout << HasMemberF_v<T1> << std::endl; // 0
  std::cout << HasMemberF_v<T2> << std::endl; // 1
  std::cout << HasMemberF_v<T3> << std::endl; // 0
}

判断T中是否含有成员f

确定类型的成员判断我们已经会了，那此时如果需求变为「判断类型T中是否含有成员f」呢？换句话说，现在我们不关心f是什么类型了，变量也好，函数也好，静态也好，非静态也好，只要它里面有一个叫f的成员就算数。这种的怎么做呢？

其实思路还是没变的，只不过我们要对推导出的类型来做多一步处理了。上一节中，通用模板的辅助参数的默认值要符合偏特化当中生成的，才能让使用时命中偏特化。但现在既然对类型不关心了，那么也就是说，无论decltype出什么类型，我们都要给它转换成一个相同的类型X，然后让通用模板的第二个参数默认值设定为X即可。示例如下：

struct X {}; // 辅助类型，仅用作静态推导，无运行期意义

// 辅助工具，用于把任意类型转为X
template <typename T>
using ToX = X;

template <typename T, typename V = X> // 注意这里改成X
struct HasMemberF : std::false_type {};

template <typename T>
struct HasMemberF<T, ToX<decltype(&T::f)>> : std::true_type {};

template <typename T>
constexpr inline bool HasMemberF_v = HasMemberF<T>::value;

// 以下是Demo
struct T1 {
  static int f; // 符合条件，含有f
};

struct T2 {
  double f; // 符合条件，含有f
};

struct T3 {}; // 不含f

struct T4 {
  int f() const; // 符合条件，含有f
  void f2();
};

void Demo() {
  std::cout << HasMemberF_v<T1> << std::endl; // 1
  std::cout << HasMemberF_v<T2> << std::endl; // 1
  std::cout << HasMemberF_v<T3> << std::endl; // 0
  std::cout << HasMemberF_v<T4> << std::endl; // 0
}

到这里大家应该能发现，其实这个辅助类型X是什么并不重要，只要通用模板的第二个参数的默认值和偏特化中映射出的类型相匹配即可完成功能。比如说我们可以把X改成int：

// 辅助工具，用于把任意类型转为int
template <typename T>
using ToInt = int;

template <typename T, typename V = int> // 注意这里改成int
struct HasMemberF : std::false_type {};

template <typename T>
struct HasMemberF<T, ToInt<decltype(&T::f)>> : std::true_type {};

template <typename T>
constexpr inline bool HasMemberF_v = HasMemberF<T>::value;

或者改成void也是一样的效果：

// 辅助工具，用于把任意类型转为void
template <typename T>
using ToVoid = void;

template <typename T, typename V = void> // 注意这里改成void
struct HasMemberF : std::false_type {};

template <typename T>
struct HasMemberF<T, ToVoid<decltype(&T::f)>> : std::true_type {};

template <typename T>
constexpr inline bool HasMemberF_v = HasMemberF<T>::value;

而STL中，提供了一个工具叫void_t，用于把任意类型（任意个数的任意类型）转换为void类型，实现如下：

template <typename... Args>
using void_t = void;

因此，我们这里就可以直接用void_t来代替自定义繁琐的工具，所以这个功能的最终版本是这样的：

template <typename T, typename V = void>
struct HasMemberF : std::false_type {};

template <typename T>
struct HasMemberF<T, std::void_t<decltype(&T::f)>> : std::true_type {};

template <typename T>
constexpr inline bool HasMemberF_v = HasMemberF<T>::value;

这就是用于判断某个类型中是否函数某个成员的模板元的编写方法。

小结

这一篇我们介绍了一些更加高级的模板元编程技巧，后面还引出了void_t工具的使用方法。下一篇将会继续介绍其他的模板元编程技巧。

C++模板元编程详细教程（之八）

borehole打洞哥
关注
专栏目录
C++模板判断类中是否存在某个名称的成员函数
tumu_C的博客
01-31 620
【代码】C++模板判断类中是否存在某个名称的成员函数。
C++模板元编程
WHEgqing的专栏
11-18 9307
所谓的元编程就是编写直接生成或操纵程序的程序，C++模板为C++语言提供了元编程的能力。模板使 C++ 编程变得异常灵活，能实现很多高级动态语言才有的特性（语法上可能比较丑陋，一些历史原因见下文）。普通用户对 C++ 模板的使用可能不是很频繁，大致限于泛型编程，但一些系统级的代码，尤其是对通用性、性能要求极高的基础库（如 STL、Boost）几乎不可避免的都大量地使用 C++ 模板，一个稍有规模的大量使用模板的程序，不可避免的要涉及元编程（如类型计算）。本文就是要剖析 C++ 模板元编程的机制。
C++ 中的模板元编程
07-23 858
程序计算“2的8次幂（或2^8）”。事实上，结构体funStruct可用于计算任何已知n（或常数n）的2^n。上述程序的特殊之处在于计算是在编译时完成的。因此，计算2^8是编译器完成的。预测以下C++程序的输出。...
C++模板元编程简介
林多
02-25 546
简介 模板元编程（Template Metaprogram）是C++11引入的编程范式（在Google Chromium源码中使用了很多模板元编程） 模板元程序在编译期执行。因此，合理利用它可以为你的程序“加速”。 模板元程序不能操作运行时变量和语（因为其在编译期执行）。 缺点：复杂，编写较为困难，维护起来也比较困难。 优点：加速你的程序，精简代码等等。 模板元的组成 模板元程序由元数...
C++中的模板元编程技术介绍
最新发布
Emmanueloldsmith的博客
04-20 366
模板元编程是C++中一种强大的编程技术，它允许程序员在编译时执行计算和生成代码，从而提供高性能和灵活的解决方案。模板元编程在C++中扮演着重要的角色，尤其是在处理复杂的数据结构和算法时，能够提供极大的灵活性和性能优化。模板元编程的关键在于利用模板的特化（specialization）和偏特化（partial specialization）机制，在编译时根据不同的类型参数生成不同的代码。此外，模板元编程还依赖于编译器的类型推导和模板实例化能力，以实现编译时的计算和代码生成。模板元编程的核心是模板。
template＜typename ... Args＞：可变参数模板的解释和使用
Major_S的博客
09-27 4089
【代码】template：可变参数模板的解释和使用。
《 C++模板》和《C++模板元编程》两本
03-20
C++模板元编程（Template Metaprogramming，TMP）则是利用模板在编译期间进行计算的一种技术。《C++模板元编程》这本书则专注于这一主题，介绍了如何编写能在编译时执行逻辑的模板代码。TMP允许开发者创建编译时的...
C++模板元编程详细教程（之一）
热门推荐
fl2011sx的博客
12-02 1万+
《C++模板元编程详细教程》系列文章的第一篇，主要介绍了模板的概念以及基本的模板语法和相关示例。
C++利用模板检测是否包含某个函数，并决定生成什么样的调用代码
余璜的技术博客
04-30 1399
// Author: // hustos@qq.com // #include <stdio.h> #include <new> template <bool c> struct BoolType { static const bool value = c; }; typedef BoolType<false> FalseType; typ...
c++模板编程- 函数对象的简单实现(类型擦除)
qq_34179431的博客
10-19 292
template<typename R, typename... Args> class FunctorBridge { public: virtual ~FunctorBridge() = default; virtual FunctorBridge *clone() const = 0; virtual R invoke(Args... args) = 0; virtual R invoke(Args... args) const = 0; };
用模板实现对任意函数计时功能
Q先森的博客
11-04 173
文章目录前言一、万能函数模板二、void返回值问题三、利用局部变量计时，解决void返回值接收问题完全版代码 前言 前面一篇文章利用了可变参宏去实现任意函数计时功能，总觉得有点挫，而且无法带返回值。突然想到可以用模板实现这个功能。下面讲一下实现思路和中间碰到的问题。 一、万能函数模板 先介绍一下万能函数模板，用下面两个函数模板，无论是全局函数，还是类成员函数，统统可以执行。原理就是万能函数指针加上可变参。省略号的位置自己体会一下。 template<typename R, typenam.
C++泛型编程：可变参数模板
oorik的博客
10-13 2064
一个可变参数模板通俗来讲就是：一个接受可变数目参数的模板函数或模板类在c++11之前，类模板和函数模板只能含有固定数量的模板参数，c++11增加了可变模板参数特性：允许模板定义中包含0到任意个模板参数。声明可变参数模板时，需要在typename或class后面加上省略号"..."。就像我上面指出的源码那样在了解其之前我们要先知道什么是参数包？可变数目的参数被称为参数包。存在两种参数包：表示零个或多个模板参数表示零个或多个函数参数怎么好理解可变参数模板呢?
C++中的类型查询(type trait)模板
m0_61629312的博客
08-10 382
2023年8月10日，周四上午C++中的类型查询(type trait)模板用于提供关于类型特征的信息，帮助在编译期间进行类型检查和类型推导。
学习c++模板元编程2
ccsdu2004的专栏
02-13 629
 今天看了下模板元编程在编译期确定变量类型的简单例子和模板的条件状态的用法如下所示:#include #include #include using namespace std;//动态确定类型 templatestruct Type{ typedef T1 GType; }; templatestruct Type{
C++模板判断类是否存在某个成员变量
双杯献酒的专栏
06-21 3271
#include <iostream> #include <type_traits> // 检查 xxxx 是否是类T的成员 template <typename T> struct has_member_xxxx { // 如果 &T::xxxx 合法, 本函数就合法 // 下面check<T>(0)优先调用本函数, 返回值是voi...
C++进阶，一文带你迅速入门c++模板元编程！
greatming666的博客
04-15 1306
模板元编程是一种利用模板在编译时进行计算和生成代码的技术，可以用于优化计算和生成通用算法。在编译时进行计算可以提高程序性能、减少运行时开销。
模板编程：C++11 可变模版参数的使用(逗号表达式、可变长数组、C#的委托实现)
qq_38409301的博客
12-25 1332
转载：泛化之美--C++11可变模版参数的妙用 - qicosmos(江南) - 博客园 (cnblogs.com) 重点： 1.template<class T>和template<typenameT> typename 和class 两者都可以用，但有时候会有差别，尽量用typename，因为用typename包括所有的问题。 每个用到T的函数或者类前面都必须加一个template<typenameT>，而不是加一个就一劳永逸。 2.逗号表达式：
c++模板元编程 和 c++ 模板 两书区别
06-15
C++模板元编程和C++模板是两本不同的书籍，尽管它们有些相似之处，但它们的主要目标、思想和内容都有所不同。 C++模板元编程着重于利用C++模板的元编程功能，用于在编译时生成代码。这本书主要介绍了C++模板元编程的基础知识和高级技术，包括如何使用模板来实现各种数据结构和算法、如何使用元编程技术来生成高效的代码以及其他一些进阶的主题。本书面向对于C++模板有一定了解以及对于元编程技巧感兴趣的读者。 相比之下，C++模板一书是更全面的C++模板专业指南。这本书介绍了各种C++模板的用法、模板类、函数库以及与STL（标准模板库）相关的概念和技术。本书采用了更加系统化的方式来讲解C++模板，包括各种语法以及大量的例子和实践应用。对于那些想要深入了解C++模板并掌握其广泛应用的读者，这本书会是一本非常有用的工具书。 总之，C++模板元编程和C++模板这两本书给读者提供了深度和广度方面的不同选择。无论你处于C++模板编程的哪个阶段，这两本书都有各自独特的价值和作用。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

borehole打洞哥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值