variant (C++ 模板元编程)

_lifehappy_2023-11-05 16:25

std::variant

可以理解为一个会自动清除空间的union，保证了赋值时内存的正确性，能够自动进行析构。

通过get可传入下标或者type来获取值，但是不安全，如果传入类型于当前类型不一致时会引发错误。

可以通过get_if传入下标或者值和variant指针来安全获得值。

有类模板variant_alternative来获取第几个属性的type，以及类模板variant_size来获取variant中存放了多少个属性。

  • variant
  • get< type >
  • get< N >
  • variant_alternative
  • variant_size
  • operator =
cpp 复制代码 
int main() {
  std::variant<int, float> a;
  a = 1;
  auto int_value = std::get<int>(a);
  std::cout << int_value << "\n";

  try {
    auto float_value = std::get<float>(a);
  } catch (const std::bad_variant_access &e) {
    std::cout << e.what() << "\n";
  }
  std::cout << std::holds_alternative<int>(a) << " "
      << std::holds_alternative<float>(a) << "\n";

  a = 1.1f;
  std::cout << std::holds_alternative<int>(a) << " "
            << std::holds_alternative<float>(a) << "\n";

  std::cout << std::get<float>(a) << " " << std::get<1>(a) << "\n";
  // std::cout << std::get<int>(a) << " " << std::get<0>(a) << "\n";

  std::cout << std::get_if<0>(&a) << " " << std::get_if<int>(&a) << "\n";
  std::cout << std::get_if<1>(&a) << " " << std::get_if<float>(&a) << "\n";
  std::variant_alternative<1, decltype(a)>::type f = 1.2;
  std::cout << f << "\n";
  std::cout << std::variant_size_v<decltype(a)> << "\n";
  return 0;
}

sample::variant

存储结构

union模板一层一层嵌套，即可得到我们的variant存储结构，整体的内存占用情况为sizeof(largestType<Ts...>)：

cpp 复制代码 
template<typename ...Ts> union __union;

template<typename T, typename ...Ts>
union __union<T, Ts...> {
  using type = __union;
  using rest_type = __union<Ts...>;
  using value_type = T;

  T value_;
  rest_type rest_;

  template<typename Tv>
  requires std::is_same_v<std::decay_t<Tv>, T>
  __union(Tv&& value) : value_(std::forward<Tv>(value)) {}

  template <typename Tv>
  __union(Tv&& rest) : rest_(std::forward<Tv>(rest)) {}

  __union() {}
  ~ __union() {}
};

template<typename T>
union __union<T> {
  using type = __union;
  using value_type = T;

  T value_;

  template<typename Tv>
  requires std::is_same_v<std::decay_t<Tv>, T>
  __union(Tv&& value) : value_(std::forward<Tv>(value)) {}

  __union() {}
  ~ __union() {}
};

简单测试访问一下看看：

cpp 复制代码 
int a = 114;
auto u1 = __union<short int, int, unsigned int, long long, float, double>(a);
std::cout << u1.value_ << " " << u1.rest_.value_ << " " << u1.rest_.rest_.value_ << " "
          << u1.rest_.rest_.rest_.value_ << " " << u1.rest_.rest_.rest_.rest_.value_ << " "
          << u1.rest_.rest_.rest_.rest_.rest_.value_ << "\n";

const double b = 115.514;
auto u2 = __union<short int, int, unsigned int, long long, float, double>(b);
std::cout << u2.value_ << " " << u2.rest_.value_ << " " << u2.rest_.rest_.value_ << " "
          << u2.rest_.rest_.rest_.value_ << " " << u2.rest_.rest_.rest_.rest_.value_ << " "
          << u2.rest_.rest_.rest_.rest_.rest_.value_ << "\n";

std::string str = "lifehappy";
auto u3 = __union<int, double, std::string>(std::move(str));
std::cout << u3.value_ << " " << u3.rest_.value_ << " " << u3.rest_.rest_.value_ << " : __union\n";
std::cout << str << " : str\n";

114 114 114 4294967410 1.59748e-43 2.122e-314

-30409 1614907703 1614907703 4637828992051808567 5.5783e+19 115.514

1701210476 4.06896e+233 lifehappy : __union

: str

variant

cpp 复制代码 
template<typename ...Ts>
struct variant {
  using type = variant;
  using data_type = __union<Ts...>;
  
  __union<Ts...> data_;

  template<typename Tv>
  variant(Tv&& data) : data_(std::forward<Tv>(data)) {}

  variant() {}
  ~ variant() {}
};

variant_alternative

cpp 复制代码 
template<int N, typename ...Ts> struct variant_alternative {};

template<int N, typename ...Ts>
struct variant_alternative<N, variant<Ts...>>
    : variant_alternative<N, typename variant<Ts...>::data_type> {};

template<int N, typename ...Ts>
struct variant_alternative<N, __union<Ts...>>
    : variant_alternative<N - 1, typename __union<Ts...>::rest_type> {};

template<typename ...Ts>
struct variant_alternative<0, __union<Ts...>> {
  using type = __union<Ts...>::value_type;
};

template<int N, typename ...Ts>
using variant_alternative_t = variant_alternative<N, Ts...>::type;

variant_size

cpp 复制代码 
template<typename ...Ts> struct variant_size {};

template<typename ...Ts>
struct variant_size<variant<Ts...>>
    : std::integral_constant<int, sizeof...(Ts)> {};

template<typename ...Ts>
constexpr static int variant_size_v = variant_size<Ts...>::value;

get< type > 、get< N >

这里的实现并不会像std::variant一样，即可以把我们的实现认为就是一个union：

get< N >

cpp 复制代码 
template<int N, typename T>
struct get_impl {
  static auto&& get(T &data) {
    return get_impl<N - 1, typename T::rest_type>::get(data.rest_);
  }
};

template<typename T>
struct get_impl<0, T> {
  static T::value_type& get(T &data) {
    return data.value_;
  }
};

template<int N, typename T>
static auto&& get(T &var) {
  return get_impl<N, typename T::data_type>::get(var.data_);
}

get< type >

cpp 复制代码 
template<typename T, typename Tv>
struct get_type_impl {
  static auto&& get(Tv &data) {
    return get_type_impl<T, typename Tv::rest_type>::get(data.rest_);
  }
};

template<typename Tv>
struct get_type_impl<typename Tv::value_type, Tv> {
  static Tv::value_type& get(Tv &data) {
    return data.value_;
  }
};

template<typename T, typename Tv>
static auto&& get(Tv &var) {
  return get_type_impl<T, typename Tv::data_type>::get(var.data_);
}

operator =

这里也是variant最重要的功能了，能够在赋值的时候自动析构原来保存的值。

先看不加析构函数的版本:

cpp 复制代码 
template<typename Tv>
variant& operator = (Tv&& data) {
  new (&data_) data_type(std::forward<Tv>(data));
  return *this;
}

TEST

cpp 复制代码 
struct Test {
  ~ Test() {
    std::cout << "~ Test()\n";
  }
};

Test a, b;
variant<int, long long, Test> variant_test(a);
std::cout << "OK\n";
variant_test = b;
std::cout << "OK\n";

OK

OK

~ Test()

~ Test()

只有最后a、b的两次析构，缺少了赋值时和销毁variant时的析构调用。

要能够析构，那么势必我们需要保存当前的type，为了方便，这里直接使用一个int变量来保存type所对应的下标，

同时实现一个类模板，获取当前值在列表中的位置。

cpp 复制代码 
template<typename Tu, typename T> struct type_index_impl
    : std::integral_constant<int, type_index_impl<typename Tu::rest_type, T>::value + 1> {};

template<typename Tu>
struct type_index_impl<Tu, typename Tu::value_type>
    : std::integral_constant<int, 0> {};

template<typename Tu, typename T>
constexpr static int type_index = type_index_impl<Tu, T>::value;

得到所有类型的析构函数，由于variant的类型是动态加载的，考虑将所有类型的destructor存下来，按需调用：

cpp 复制代码 
std::function<void(void *)> destructors[sizeof...(Ts)] =
    { [](void *ptr) { static_cast<Ts*>(ptr)->~Ts(); }... };

接着稍微修改一下operator =、~variant()：

cpp 复制代码 
template<typename Tv>
variant& operator = (Tv&& data) {
  if (~type_) {
    destructors[type_](&data_);
  }
  new (&data_) data_type(std::forward<Tv>(data));
  type_ = type_index<data_type, std::decay_t<Tv>>;
  return *this;
}

~ variant() {
  if (~type_) {
    destructors[type_](&data_);
  }
}

TEST

cpp 复制代码 
struct Test1 {
  ~ Test1() {
    std::cout << "~ Test1()\n";
  }
}a;

struct Test2 {
  ~ Test2() {
    std::cout << "~ Test2()\n";
  }
}b;

variant<int, long long, Test1, Test2> variant_test(a);
std::cout << "OK\n";
variant_test = b;
std::cout << "OK\n";

:
Test1()

OK

:
Test2()
:
Test2()
:
Test1()

Code

cpp 复制代码 
#include <iostream>
#include <string>
#include <type_traits>
#include <functional>

template<typename ...Ts> union __union;

template<typename T, typename ...Ts>
union __union<T, Ts...> {
  using type = __union;
  using rest_type = __union<Ts...>;
  using value_type = T;

  T value_;
  rest_type rest_;

  template<typename Tv>
  requires std::is_same_v<std::decay_t<Tv>, T>
  __union(Tv&& value) : value_(std::forward<Tv>(value)) {}

  template <typename Tv>
  __union(Tv&& rest) : rest_(std::forward<Tv>(rest)) {}

  __union() {}
  ~ __union() {}
};

template<typename T>
union __union<T> {
  using type = __union;
  using value_type = T;

  T value_;

  template<typename Tv>
  requires std::is_same_v<std::decay_t<Tv>, T>
  __union(Tv&& value) : value_(std::forward<Tv>(value)) {}

  __union() {}
  ~ __union() {}
};

template<typename Tu, typename T> struct type_index_impl
    : std::integral_constant<int, type_index_impl<typename Tu::rest_type, T>::value + 1> {};

template<typename Tu>
struct type_index_impl<Tu, typename Tu::value_type>
    : std::integral_constant<int, 0> {};

template<typename Tu, typename T>
constexpr static int type_index = type_index_impl<Tu, T>::value;

template<typename ...Ts>
struct variant {
  using type = variant;
  using data_type = __union<Ts...>;

  __union<Ts...> data_;

  int type_{-1};

  std::function<void(void *)> destructors[sizeof...(Ts)] =
      { [](void *ptr) { static_cast<Ts*>(ptr)->~Ts(); }... };

  template<typename Tv>
  variant(Tv&& data) : data_(std::forward<Tv>(data)),
                       type_(type_index<data_type, std::decay_t<Tv>>) {}

  template<typename Tv>
  variant& operator = (Tv&& data) {
    if (~type_) {
      destructors[type_](&data_);
    }
    new (&data_) data_type(std::forward<Tv>(data));
    type_ = type_index<data_type, std::decay_t<Tv>>;
    return *this;
  }

  variant() {}
  ~ variant() {
    if (~type_) {
      destructors[type_](&data_);
    }
  }
};

template<int N, typename ...Ts> struct variant_alternative {};

template<int N, typename ...Ts>
struct variant_alternative<N, variant<Ts...>>
    : variant_alternative<N, typename variant<Ts...>::data_type> {};

template<int N, typename ...Ts>
struct variant_alternative<N, __union<Ts...>>
    : variant_alternative<N - 1, typename __union<Ts...>::rest_type> {};

template<typename ...Ts>
struct variant_alternative<0, __union<Ts...>> {
  using type = __union<Ts...>::value_type;
};

template<int N, typename ...Ts>
using variant_alternative_t = variant_alternative<N, Ts...>::type;

template<typename ...Ts> struct variant_size {};

template<typename ...Ts>
struct variant_size<variant<Ts...>>
    : std::integral_constant<int, sizeof...(Ts)> {};

template<typename ...Ts>
constexpr static int variant_size_v = variant_size<Ts...>::value;

template<int N, typename T>
struct get_n_impl {
  static auto&& get(T &data) {
    return get_n_impl<N - 1, typename T::rest_type>::get(data.rest_);
  }
};

template<typename T>
struct get_n_impl<0, T> {
  static T::value_type& get(T &data) {
    return data.value_;
  }
};

template<int N, typename T>
static auto&& get(T &var) {
  return get_n_impl<N, typename T::data_type>::get(var.data_);
}

template<typename T, typename Tv>
struct get_type_impl {
  static auto&& get(Tv &data) {
    return get_type_impl<T, typename Tv::rest_type>::get(data.rest_);
  }
};

template<typename Tv>
struct get_type_impl<typename Tv::value_type, Tv> {
  static Tv::value_type& get(Tv &data) {
    return data.value_;
  }
};

template<typename T, typename Tv>
static auto&& get(Tv &var) {
  return get_type_impl<T, typename Tv::data_type>::get(var.data_);
}

int main() {
  int a = 114;
  auto u1 = __union<short int, int, unsigned int, long long, float, double>(a);
  std::cout << u1.value_ << " " << u1.rest_.value_ << " " << u1.rest_.rest_.value_ << " "
            << u1.rest_.rest_.rest_.value_ << " " << u1.rest_.rest_.rest_.rest_.value_ << " "
            << u1.rest_.rest_.rest_.rest_.rest_.value_ << "\n";

  const double b = 115.514;
  auto u2 = __union<short int, int, unsigned int, long long, float, double>(b);
  std::cout << u2.value_ << " " << u2.rest_.value_ << " " << u2.rest_.rest_.value_ << " "
            << u2.rest_.rest_.rest_.value_ << " " << u2.rest_.rest_.rest_.rest_.value_ << " "
            << u2.rest_.rest_.rest_.rest_.rest_.value_ << "\n";

  std::string str1 = "lifehappy";
  auto u3 = __union<int, double, std::string>(std::move(str1));
  std::cout << u3.value_ << " " << u3.rest_.value_ << " " << u3.rest_.rest_.value_ << " : __union\n";
  std::cout << str1 << " : str\n";

  auto v3 = variant<int, double, std::string>();

  std::cout << std::is_same_v<int, variant_alternative_t<0, decltype(v3)>> << " "
            << std::is_same_v<double, variant_alternative_t<1, decltype(v3)>> << " "
            << std::is_same_v<std::string, variant_alternative_t<2, decltype(v3)>> << "\n";
  std::cout << std::is_same_v<int, variant_alternative_t<0, decltype(u3)>> << " "
            << std::is_same_v<double, variant_alternative_t<1, decltype(u3)>> << " "
            << std::is_same_v<std::string, variant_alternative_t<2, decltype(u3)>> << "\n";
  std::cout << std::is_same_v<variant_alternative_t<0, decltype(v3)>, variant_alternative<0, decltype(v3)>::type> << " "
            << std::is_same_v<variant_alternative_t<1, decltype(v3)>, variant_alternative<1, decltype(v3)>::type> << " "
            << std::is_same_v<variant_alternative_t<2, decltype(v3)>, variant_alternative<2, decltype(v3)>::type> << "\n";
  std::cout << std::is_same_v<variant_alternative_t<0, decltype(u3)>, variant_alternative<0, decltype(u3)>::type> << " "
            << std::is_same_v<variant_alternative_t<1, decltype(u3)>, variant_alternative<1, decltype(u3)>::type> << " "
            << std::is_same_v<variant_alternative_t<2, decltype(u3)>, variant_alternative<2, decltype(u3)>::type> << "\n";

  std::cout << variant_size<decltype(v3)>::value << " " << variant_size_v<decltype(v3)> << "\n";

  variant<int, unsigned int, long long, double, std::string> v4((int)114514);
  std::cout << get_n_impl<0, decltype(v4.data_)>::get(v4.data_) << " " << get_n_impl<1, decltype(v4.data_)>::get(v4.data_) << " "
            << get_n_impl<2, decltype(v4.data_)>::get(v4.data_) << " " << get_n_impl<3, decltype(v4.data_)>::get(v4.data_) << " "
            << get_n_impl<4, decltype(v4.data_)>::get(v4.data_) << "\n";
  std::cout << get<0>(v4) << " " << get<1>(v4) << " " << get<2>(v4) << " " << get<3>(v4) << " " << get<4>(v4) << "\n";


  std::cout << get_type_impl<int, decltype(v4.data_)>::get(v4.data_) << " " << get_type_impl<unsigned int, decltype(v4.data_)>::get(v4.data_) << " "
            << get_type_impl<long long, decltype(v4.data_)>::get(v4.data_) << " " << get_type_impl<double, decltype(v4.data_)>::get(v4.data_) << " "
            << get_type_impl<std::string, decltype(v4.data_)>::get(v4.data_) << "\n";
  std::cout << get<int>(v4) << " " << get<unsigned int>(v4) << " " << get<long long>(v4) << " " << get<double>(v4) << " " << get<std::string>(v4) << "\n";

  int int1 = 1;
  const int int2 = 1;
  int &int3 = int1;
  std::cout << variant<int, float, std::string>().type_ << " "
            << variant<int, float, std::string>(int1).type_ << " "
            << variant<int, float, std::string>(int2).type_ << " "
            << variant<int, float, std::string>(int3).type_ << " "
            << variant<int, float, std::string>(1.1f).type_ << " "
            << variant<int, float, std::string>(std::string("lifehappy")).type_ << "\n";

  struct Test1 {
    ~ Test1() {
      std::cout << "~ Test1()\n";
    }
  }ta;

  struct Test2 {
    ~ Test2() {
      std::cout << "~ Test2()\n";
    }
  }tb;

  variant<int, long long, Test1, Test2> variant_test(ta);
  std::cout << "OK\n";
  variant_test = tb;
  std::cout << "OK\n";
  return 0;
}
相关推荐
轻口味23 分钟前
命名空间与模块化概述
开发语言·前端·javascript
晓纪同学1 小时前
QT-简单视觉框架代码
开发语言·qt
威桑1 小时前
Qt SizePolicy详解：minimum 与 minimumExpanding 的区别
开发语言·qt·扩张策略
飞飞-躺着更舒服1 小时前
【QT】实现电子飞行显示器（简易版）
开发语言·qt
明月看潮生1 小时前
青少年编程与数学 02-004 Go语言Web编程 16课题、并发编程
开发语言·青少年编程·并发编程·编程与数学·goweb
明月看潮生2 小时前
青少年编程与数学 02-004 Go语言Web编程 17课题、静态文件
开发语言·青少年编程·编程与数学·goweb
Java Fans2 小时前
C# 中串口读取问题及解决方案
开发语言·c#
盛派网络小助手2 小时前
微信 SDK 更新 Sample，NCF 文档和模板更新，更多更新日志，欢迎解锁
开发语言·人工智能·后端·架构·c#
Chinese Red Guest2 小时前
python
开发语言·python·pygame
一棵星2 小时前
Java模拟Mqtt客户端连接Mqtt Broker
java·开发语言
热门推荐
01Cube-Studio：开源大模型全链路一站式中台02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问07构建高效的广告投放系统：应用架构的设计与实现08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10【一文读懂】NTN（非地面网络）技术介绍