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

已于 2023-02-14 13:50:41 修改
阅读量1.7k 收藏 7
点赞数 6
分类专栏： C++代码 文章标签： c++
于 2023-02-13 13:31:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fl2011sx/article/details/128967835
版权
文章介绍了如何使用模板元编程在C++中实现一个简易版的多选一数据结构variant，讨论了union的局限性，提出了基于内存复用的实现思路，详细阐述了构造、析构、拷贝构造和拷贝赋值等关键操作的实现，并提供了完整的代码示例。
摘要由CSDN通过智能技术生成

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

多选一结构

这一章我们来看看如何编写一个多选一的结构，STL中提供了std::variant，我们就来实现一个简易版。（注意下面我们实现的variant与STL中的是有区别的，但大体思路是相同的，请读者不要以本节的代码参考使用std::variant）。

我们的诉求是，创建一个数据结构，「可能」存放多种类型，但同一时间只能有一种，并且可以在运行期变化为另一种。这里比较容易想到的做法就是用共合体类型存储数据，再加一个用于表示当前哪种数据是生效的index。请看代码：

template <typename T1, typename T2>
class variant {
public:
  // 针对每种情况的构造
  variant(const T1 &t1);
  variant(const T2 &t2);
private:
  union {
    T1 t1;
    T2 t2;
  } data;
  int index; // 当前生效的数据序号
};

只不过这样我们很快就会发现很多严重的问题：

  1. 对于任意个数的参数，无法映射到union结构中；
  2. 如果数据类型不含无参构造函数，union结构的构造会报错；
  3. variant的构造函数依赖数据类型的拷贝构造，对于不可拷贝类型来说无法创建。

因此，我们必须换一个思路。既然一开始我们想到用union，主要也是为了内存空间的复用，所以我们只需要自己来维护一片数据空间就好了，以参数类型中长度最大的为准，创建一个缓存空间即可。

template <typename... Types>
class variant {
 private:
  void *data = std::malloc(std::max(sizeof(Types)...)); // 计算出最长的Type
  int index; // 当前生效的数据序号
};

接下来的任务就是，构造函数。由于这里的Types是变参，所以无法穷举，与此同时，我们希望可以就地构造，跳过「拷贝构造」这个阶段，以支持不可拷贝类型的数据，因此必须有一个Index来标识，后面跟变参：

template <typename... Types>
class variant {
 public:
  template <size_t Index, typename... Args>
  variant(Args &&... args); // 大概是这个意思
 private: 
  void *data = std::malloc(std::max(sizeof(Types)...)); // 计算出最长的Type
  int index; // 当前生效的数据序号
};

然而，出于语法限制，构造函数用模板生成的话，是无法手动实例化的，例如：

variant<1, int> va; // <1, int>会识别为类型的模板参数，而不是构造函数的模板参数

因此，构造函数的模板参数只能依赖于自动推导，所以，我们就需要提供一个工具，用来「传递」这个Index。

template <size_t Index>
struct in_place_index_t {}; // 单纯的静态工具，用于传递Index，没有运行期意义

template <size_t Index>
constexpr inline in_place_index_t<Index> in_place_index; // 对应in_place_index_t类型的实例

template <typename... Types>
class variant {
 public:
  template <size_t Index, typename... Args>
  variant(const in_place_index_t<Index> &, Args &&... args);
 private:
  void *data = std::malloc(std::max(sizeof(Types)...)); 
  int index;
};

然后，构造时，也同样通过in_place_index来构造，传递这个Index：

 // 用于测试的类型
struct Test1 {
  Test1(int, double);
};
struct Test2 {
  Test1(char, int);
};

void Demo() {
  variant<Test1, Test2> var{in_place_index<0>, 1, 1.5}; // 用于构造Test1类型
  variant<Test1, Test2> var{in_place_index<1>, 'A', 1}; // 用于构造Test2类型
}

那么接下来的问题就是如何解析了，variant本身的参数是一组typename列表，但构造传进来的是一个Index序号，如何对应呢？相信读者到现在应该已经建立初步的感觉了，没错，递归大法好！

template <size_t Index, typename Head, typename... Args>
struct get_type_by_index : get_type_by_index<Index - 1, Args...> {};

template <typename Head, typename... Args>
struct get_type_by_index<0, Head, Args...> {
  using type = Head;
};

// 验证Demo
void Demo() {
  std::cout << std::is_same_v<typename get_type_by_index<2, int, double, char, void *>::type , char> << std::endl; // 1
}

有了这个工具，我们就可以从类型列表里通过Index取出对应的类型了，以此来完成variant的构造函数：

// 实现构造函数
template <typename... Types>
template <size_t Index, typename... Args>
variant<Types...>::variant(const in_place_index_t<Index> &, Args &&... args): index(Index) {
  // 先把需要构造的类型拿出来
  using data_type = typename get_type_by_index<Index, Args...>::type;
  // 在data处进行就地构造
  new(data) std::decay_t<data_type>(std::forward<Args>(args)...);
}

最难的构造已经完成了，我们先实现一下周边功能，析构、拷贝构造和赋值函数先放一放，给出一个阶段性的代码：

template <size_t Index>
struct in_place_index_t {}; // 单纯的静态工具，用于传递Index，没有运行期意义

template <size_t Index>
constexpr inline in_place_index_t<Index> in_place_index; // 对应in_place_index_t类型的实例

template <size_t Index, typename Head, typename... Args>
struct get_type_by_index : get_type_by_index<Index - 1, Args...> {};

template <typename Head, typename... Args>
struct get_type_by_index<0, Head, Args...> {
  using type = Head;
};

template <typename... Types>
class variant {
 public:
  template <size_t Index, typename... Args>
  variant(const in_place_index_t<Index> &, Args &&... args);
  
  // 获取当前序号
  int index() const;

  // 取出数据
  template <size_t Index>
  auto get() const -> std::add_lvalue_reference_t<std::decay_t<typename get_type_by_index<Index, Types...>::type>>;
  
 private:
  void *data_ = std::malloc(std::max(sizeof(Types)...)); // 计算出最长的Type
  int index_; // 当前生效的数据序号
};

// 实现构造函数
template <typename... Types>
template <size_t Index, typename... Args>
variant<Types...>::variant(const in_place_index_t<Index> &, Args &&... args): index_(Index) {
  // 先把需要构造的类型拿出来
  using data_type = typename get_type_by_index<Index, Args...>::type;
  // 在data处进行就地构造
  new(data_) std::decay_t<data_type>(std::forward<Args>(args)...);
}

// 获取序号
template <typename... Types>
int variant<Types...>::index() const {
  return index_;
}

// 取出数据（这个功能在std::variant中其实实现在std::get中）
template <typename... Types>
template <size_t Index>
auto variant<Types...>::get() const -> std::add_lvalue_reference_t<std::decay_t<typename get_type_by_index<Index, Types...>::type>> {
  using data_type = std::decay_t<typename get_type_by_index<Index, Types...>::type>;
  return *static_cast<data_type *>(data_);
}

接下来我们要攻克的，就是析构、拷贝构造、拷贝赋值这几个问题了，它们的难点在于，没有静态的Index参数可供使用，但还要找到现在数据的类型。就拿析构来说，析构函数并没有静态的Index参数，只有一个运行时的index成员，但我们要找到此时index_成员表示的data_所指向数据的实际类型，然后调用这个类型的析构函数。拷贝构造、拷贝赋值也同样需要先析构现有数据，所以面临同样的问题。

这种情况怎么办呢？类比前面章节介绍的元组的动态get方法，我们这里也采取「静态穷举生成所有可能情况代码」的方法。

以析构为例，在析构时，要根据index_去判断当前保存的数据是哪一种类型的，然后去调用对应类型的析构函数。因此，我们需要在静态期就提供每一种类型的析构方法，然后将它们和类型的Index关联起来，这样在运行时就可以调用了。

template <typename... Types>
class variant {
 public:
  // 无关代码暂时省略 
  ~variant(); // 析构函数

 private:
  void *data_ = std::malloc(std::max(sizeof(Types)...));
  int index_; // 当前生效的数据序号
  
  // 生成每一个Type下对应类型的析构方法
  template <typename Type>
  void destory_data();
};

template <typename... Types>
template <typename Type>
void variant<Types...>::destory_data() {
  // 用data_指针按照对应的类型调用析构函数
  static_cast<std::add_pointer_t<Type>>(data_)->~Type();
}

// 实现析构函数
template <typename... Types>
variant<Types...>::~variant() {
  // 析构函数中，把所有的index对应的destory_data保存下来（编译期完成这样一个映射表）
  std::array<void (variant<Types...>::*)(), sizeof...(Types)> destory_functions {
    &variant<Types...>::destory_data<Types>... // 按照类型参数展开，把对应的destory_data实例的函数指针保存下来
  };
  
  // 到了运行期，根据当前实际的index_值，选择对应的析构方法
  if (data_ != nullptr) {
    (this->*destory_functions.at(index_))();
    std::free(data_);
  }
}

对于拷贝构造、拷贝赋值来说，首先把原来的内容析构调，然后再根据被复制方的index_，来调用对应的构造函数。于是，我们还需要补充一个index_与构造函数的映射表，思路和析构完全相同：

template <typename... Types>
class variant {
 public:
  // 无关代码先省略
  variant(const variant &va);
 private:
  void *data_ = std::malloc(std::max(sizeof(Types)...));
  int index_; // 当前生效的数据序号
  
  // 生成每一个Type下对应类型的析构方法
  template <typename Type>
  void destory_data();
  
  // 生成每一个Type下对应类型的构造方法
  // 注意，由于我们要把生成的所有方法保存在数组中，因此函数类型需要一致，所以参数用泛型指针
  template <typename Type>
  void create_data(const void *obj);
};

template <typename... Types>
template <typename Type>
void variant<Types...>::create_data(const void *obj) {
  // 用data_指针按照对应的类型调用拷贝构造
  new(data_) Type(*static_cast<const Type *>(obj));
}

template <typename... Types>
variant<Types...>::variant(const variant &va): index_(va.index_) {
  // 静态期保存所有类型的构造函数
  std::array<void (variant<Types...>::*)(const void *), sizeof...(Types)> create_functions {
    &variant<Types...>::create_data<Types>...
  };
  // 动态时根据index_调用对应的构造
  (this->*create_functions.at(index_))(va.data_);
}

有了这样的思路，那么我们就可以完善所有的代码了，拷贝赋值函数可以按照相同的方法写出来了（只不过需要先析构，再重新构造）。下面给出整个项目的完整代码：

// 辅助工具
template <size_t Index>
struct in_place_index_t {}; // 单纯的静态工具，用于传递Index，没有运行期意义

template <size_t Index>
constexpr inline in_place_index_t<Index> in_place_index; // 对应in_place_index_t类型的实例

template <size_t Index, typename Head, typename... Args>
struct get_type_by_index : get_type_by_index<Index - 1, Args...> {};

template <typename Head, typename... Args>
struct get_type_by_index<0, Head, Args...> {
  using type = Head;
};

// variant结构的声明
template <typename... Types>
class variant {
 public:
  template <size_t Index, typename... Args>
  variant(const in_place_index_t<Index> &, Args &&... args);
  
  variant(const variant &va);
  variant(variant &&va);
  
  ~variant();
  
  variant &operator =(const variant &va);
  variant &operator =(variant &&va);
  
  // 获取当前序号
  int index() const;
  
  // 取出数据
  template <size_t Index>
  auto get() const -> std::add_lvalue_reference_t<std::decay_t<typename get_type_by_index<Index, Types...>::type>>;
  
  
 private:
  void *data_ = std::malloc(std::max(sizeof(Types)...));
  int index_; // 当前生效的数据序号
  
  // 生成每一个Type下对应类型的析构方法
  template <typename Type>
  void destory_data();
  
  // 生成每一个Type下对应类型的构造方法
  template <typename Type>
  void create_data(const void *obj);
};

// 实现构造函数
template <typename... Types>
template <size_t Index, typename... Args>
variant<Types...>::variant(const in_place_index_t<Index> &, Args &&... args): index_(Index) {
  using data_type = typename get_type_by_index<Index, Args...>::type;
  new(data_) std::decay_t<data_type>(std::forward<Args>(args)...);
}

// 实现析构函数
template <typename... Types>
variant<Types...>::~variant() {
  // 析构函数中，把所有的index对应的destory_data保存下来（编译期完成这样一个映射表）
  std::array<void (variant::* const)(), sizeof...(Types)> destory_functions {
    &variant::destory_data<Types>...
  };
  
  // 到了运行期，根据当前实际的index_值，选择对应的析构方法
  if (data_ != nullptr) {
    (this->*destory_functions.at(index_))();
    std::free(data_);
  }
}

// 实现拷贝构造函数
template <typename... Types>
variant<Types...>::variant(const variant &va): index_(va.index_) {
  // 静态期保存所有类型的构造函数
  std::array<void (variant<Types...>::*)(const void *), sizeof...(Types)> create_functions {
    &variant<Types...>::create_data<Types>...
  };
  // 动态时根据index_调用对应的构造
  (this->*create_functions.at(index_))(va.data_);
}

// 实现拷贝赋值函数
template <typename... Types>
variant<Types...> &variant<Types...>::operator =(const variant &va) {
  // 先析构现有数据
  std::array<void (variant<Types...>::*)(), sizeof...(Types)> destory_functions {
    &variant<Types...>::destory_data<Types>...
  };
  (this->*destory_functions.at(index_))();
  
  // 再重新构造
  std::array<void (variant<Types...>::*)(const void *), sizeof...(Types)> create_functions {
    &variant<Types...>::create_data<Types>...
  };
  (this->*create_functions.at(index_))(va.data_);
  
  return *this;
}

// 实现移动构造函数
template <typename... Types>
variant<Types...>::variant(variant &&va): index_(va.index_), data_(va.index_) {
  // 上面直接浅拷贝即可，然后把被移动的data_置空
  va.data_ = nullptr;
  va.index_ = -1; // 标记为不合法值
}

// 实现移动赋值函数
template <typename... Types>
variant<Types...> &variant<Types...>::operator =(variant &&va) {
  // 先析构现有数据
  std::array<void (variant<Types...>::*)(), sizeof...(Types)> destory_functions {
    &variant<Types...>::destory_data<Types>...
  };
  (this->*destory_functions.at(index_))();
  
  // 再浅拷贝
  data_ = va.data_;
  index_ = va.index_;
  
  // 把被移动的data_置空
  va.data_ = nullptr;
  va.index_ = -1; // 标记为不合法值
  
  return *this;
}

// 私有方法的实现
template <typename... Types>
template <typename Type>
void variant<Types...>::create_data(const void *obj) {
  // 用data_指针按照对应的类型调用拷贝构造
  new(data_) Type(*static_cast<const Type *>(obj));
}

template <typename... Types>
template <typename Type>
void variant<Types...>::destory_data() {
  // 用data_指针按照对应的类型调用析构函数
  static_cast<std::add_pointer_t<Type>>(data_)->~Type();
}

// 公有方法的实现
// 获取序号
template <typename... Types>
int variant<Types...>::index() const {
  return index_;
}

// 取出数据（这个功能在std::variant中其实实现在std::get中）
template <typename... Types>
template <size_t Index>
auto variant<Types...>::get() const -> std::add_lvalue_reference_t<std::decay_t<typename get_type_by_index<Index, Types...>::type>> {
  using data_type = std::decay_t<typename get_type_by_index<Index, Types...>::type>;
  return *static_cast<data_type *>(data_);
}

小结

这一篇以一个「多选一」结构为例，带大家体验了一下模板元编程的实际使用方式，当然，这还没完，下一篇我们会针对这个多选一结构写一个「成员访问器」，会用到更多模板元编程的技巧。

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

borehole打洞哥
关注
专栏目录
C++ 模板元编程
weixin_37910058的博客
08-07 1363
C++ 模板元编程 英文：C++ template metaprogramming meta: “元”， 元数据（meta data) metaprogramming可以理解为对程序语言自身的某种特性，对程序语句进行编程， 更简洁的说，对编程的编程--元编程。元编程有两种手段，一种是使用宏，另一种是使用模板。 今天聊的是模板元编程。 C++的模板元编程（TMP）主要是利用模板的特化和偏特化机制...
C++之模板元编程
w1012747007的专栏
07-27 1164
关于模板原编程知识强烈推荐：http://blog.jobbole.com/83461/，非常好！ 这篇文章通过举例详细介绍了模板的模板参数，模板特例化，模板实例化以及编译链接等模板基础知识。 本文主要分析文章中的模板元编程例子： 首先复述一下模板元编程，以下标红或者加粗的地方是模板元编程的精髓： 从编程范型（programming paradigm）上来说，C++
我的C++实践(7)：模板元编程实战
chuifuhuo6864的博客
07-29 214
（1）计算整数的幂。 //pow.hpp：计算N的M次幂 #ifndef POW_HPP #define POW_HPP template<int N,int M> class Pow{ //计算N的M次方的基本模板 public: enum{ resu...
【C++】模板详解
最新发布
2301_77954967的博客
07-27 2502
C++模板作为C++语言的强大特性，具有不可忽视的重要性和显著的优势。其重要性体现在，极大地提高了代码的复用性，减少了重复代码的编写；通过编译时的类型检查保障了代码的类型安全；为泛型编程、容器类、算法库等提供了坚实的基础，使代码更具通用性和可扩展性。本篇博文对C++模板做了一个较为详细的介绍，不知道对你有没有帮助呢觉得博主写得还不错的三连支持下吧！会继续努力的~
C++模板元编程
10-14 1870
C++模板元编程 转载自荣耀先生网站 摘要 本文简述了模板元编程技术的起源、概念和机制， 并介绍了模板元编程技术在Blitz++和Loki程序库中的应用。   关键字 编译期计算  模板元编程  Blitz++  Loki   导言   1994年，C++标准委员会在圣迭哥举行的一次会议期间Erwin Unruh展示了一段可以产生质数的代码。这段代码的特别之处在于质数产生于编译期而非运行期，在编译
C++模板元编程 入门简介
weixin_30807677的博客
06-04 330
最近一直在看STL和Boost，源码里边好多涉及到模板元编程技术，简单了解一下，备忘（Boost Python中的涉及模板元的部分重点关注一下）。 范例引入 // 主模板 template<int N> struct Fib { enum { Result = Fib<N-1>::Result + Fib<N-2>::Result }; ...
C++ 中的模板元编程
07-23 839
程序计算“2的8次幂（或2^8）”。事实上，结构体funStruct可用于计算任何已知n（或常数n）的2^n。上述程序的特殊之处在于计算是在编译时完成的。因此，计算2^8是编译器完成的。预测以下C++程序的输出。...
《 C++模板》和《C++模板元编程》两本
03-20
C++模板元编程（Template Metaprogramming，TMP）则是利用模板在编译期间进行计算的一种技术。《C++模板元编程》这本书则专注于这一主题，介绍了如何编写能在编译时执行逻辑的模板代码。TMP允许开发者创建编译时的...
c++模板元编程
10-16
C++ Template Metaprogramming: Concepts, Tools, and Techniques from Boost and Beyond <br>By David Abrahams, Aleksey Gurtovoy <br>副标题体应该能说明些内容,推荐<br><br>
c++模版元编程
dd523762588的博客
09-04 379
编译时计算阶乘 #include using namespace std; template class Factorial{ public: enum{ value = n * Factorial::value }; }; template<> class Factorial{ public: enum{ value = 1 }; }; int main() { cout ::v
[转]C++模板元编程
Wings的专栏
04-18 1189
导言 1994年，C++标准委员会在圣迭哥举行的一次会议期间Erwin Unruh展示了一段可以产生质数的代码。这段代码的特别之处在于质数产生于编译期而非运行期，在编译器产生的一系列错误信息中间夹杂着从2到某个设定值之间的所有质数： // Prime number computation by Erwin Unruh template  struct D { D(void*); operato
C++模板元编程深度探索
"C++模板元编程 (David著)"是一本专注于C++模板元编程领域的专业书籍，由David撰写，由机械工业出版社于2010年1月出版。该书提供对C++模板元编程的深入理解和实践指导，是学习这一高级C++技术的重要参考资料。 C++...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

borehole打洞哥

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

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

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

打赏作者

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

抵扣说明：

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

余额充值