非不能也，是不为也

• 前言
• 1. std::variant
• 2. std::visit
• 3. std::optional
• 4. std::any
• Ref

前言

学习记录现代C++新标准，主要为C++17, 20及最新标准。每天1个新语法，每周最少7个知识点，学深用浅。

• 日期：2022-03-20 ~ 2022-03-26

1. std::variant

• Intro
  std::variant是c++17加入的新容器，variant主要是为了提供类型安全的union，正常情况下不可能为空

• How to Use variant

  1. 定义一个variant变量

  std::variant<int, double, std::string> x{1}; /* def and initialize */
  

  2. 赋值

  x = 3.0;
  x = "Michael & Jenny"; /* overwrite */
  

  3. 获取当前使用的type在variant声明中的索引

  auto index = x.index();
  

  4. 获取variant中的值
     你可以使用std::get<type>(x) or std::get<index>(x)来获取variant中所包含的值

  auto d = std::get<double>(x);
  auto s = std::get<2>(x);
  

  当variant中当前存储的不是对应type或者index的值, 则会抛出std::bad_variant_access类型的异常，所以可以 使用下面的方式访问variant变量

  try {
    auto i = std::get<string>(x);
  } catch (std::bad_variant_access e) {
    std::cerr << e.what() << std::endl;
  }
  

  5. 更加安全的做法
     除了会引发异常的std::get<>(), 你也可以使用无异常的std::get_if<>()方法

  auto* p = std::get_if<int>(&x);
  if (p == nullptr) {
    std::assert("error type or index");
  } else {
    /* do s.th */
  }
  

2. std::visit

• Intro

  除了上面的方式访问variant变量，你还可以使用std::visit来访问variant变量。

  template<class Visitor, class... Variants>
  constexpr auto visit(Visitor&& visitor, Variants&&... v);
  

  std::visit函数的返回类型是被调用的visitor的返回类型。 如果给定的variant变量为空，则抛出 std::bad_variant_access 异常。

• How to use

  1. 访问单个variant变量

  std::variant<std::string, int> v1 = { "Hello world!" }, v2 = 42;
  
  // A simple visitor.
  auto myVisitor = [](auto&& value) { std::cout << value << std::endl; };
  std::visit(myVisitor, v1); // Hello world!
  std::visit(myVisitor, v2); // 42
  

  2. 访问多个variant变量

     A type-matching visitor should have a handler for all combinations of the alternative types in the variants.

  struct MyVisitor {
      auto operator()(int, int) const { return "Two ints."; }
      auto operator()(const std::string&, const std::string&) const { return "Two strings."; }
      auto operator()(const std::string&, int) const { return "A string and an int."; }
      auto operator()(int, const std::string&) const { return "An int and a string."; }
  };
  
  // A string and an int.
  std::cout << std::visit(MyVisitor{}, v1, v2) << std::endl;
  

  注意，上面需要定义出所以的类型组合的operator()函数，这里是4种。

• Self Define overloaded

  在cppreference网站上提供了一种更为简单的方式使用std::visit, 看示例代码

  // helper type for the visitor #4
  template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
  
  // explicit deduction guide (not needed as of C++20)
  template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
  

  这里用到了三个关键语法，不定参模板，C++17using展开，构造函数自动推导模板参数。

  std::variant<double, bool, std::string> v;
  std::visit(overloaded {
       [](auto arg) { std::cout << arg << ' '; },
       [](double arg) { std::cout << std::fixed << arg << ' '; },
       [](const std::string& arg) { std::cout << std::quoted(arg) << ' '; }
  }, v);
  

  这里，我们使用overloaded来访问多个变量，和之前的MyVistor相比，看看有什么变化

  std::visit(overloaded{[](auto&& v1, auto&& v2) {}}, v1, v2);
  

  这里我们可以全部使用auto&&型别直接推导，不需要把所有的组合全部写出来。当然，你可以指定其中特定的一种，如

  std::visit(overloaded{
      [](auto&& v1, auto&& v2) {},
      [](int v1, const string& v2) {},
  }, v1, v2);
  

  其实，我们可以更简便的写法

  std::visit([](auto&& v1, auto&& v2) {}, v1, v2);
  

3. std::optional -- c++17

• Intro

  std::optional一样是c++17加入的新容器，顾名思义，std::optional<T> 可以保存 T 类型的值，也可以什么都不保存，通过状态位判断。

• How to Use

  1. has_value()

  std::optional<double> divide(double n, double d) {
    if (d != 0.0) return n / d;
    else return {};
  }
  int main() {
    auto result = divide(12, 3);
    if (result.has_value()) // or: if (result)
    std::cout << "result is: " << result.value(); // or: ... << *result
  }
  

  2. 读取optional种的值

     你可以通过value(), value_or()来获取option中的值， value_or()可以传入一个默认值，当optional为空的时候使用传入的默认值。也可以使用*直接获取值；

     auto result = divide(12, 3);
     
     /* 当位空的时时候调用该方法将 throws std::bad_optional_access 异常 */
     std::cout << "result is: " << result.value();
     
     /* 当位空的时时候调用该方法是未定义行为 */
     std::cout << "result is: " << *result;
     
     std::cout << "result is: " << result.value_or(0.0);
     

• std::nullopt_t

  与std::nullptr_t一样, 只有一个值, std::nullopt, optional在没有设置值的情况下类型就是std::nulopt_t, 值为std::nullopt

• Methods Functions

  这里觉得英文原文蛮好的，直接放到这里

  
  
  std::optional mem func

4. std::any -- c++17

• Intro

  std::any比较简单，std::any 的实例可以保存任何类型的值，或者根本没有值。 由于它能够保存任何类型的类型，因此无法知道任何实例的具体大小。

• How to Use

  std::any是一种值类型，它能够更改其类型，同时仍然具有类型安全性。也就是说，对象可以保存任意类型的值，但是它们知道当前保存的值是哪种类型。在声明此类型的对象时，不需要指定可能的类型。

  1. 判断对象是否有值has_value

     std::any a; // empty
     std::cout << a.has_value() << std::endl; // 0
     

  2. 获取对象type

     a = 42;
     std::cout << a.type().name() << std::endl; // int
     

  3. 读取对象的值

     使用std::any_cast<>将其转化位对应的类型，转换失败的话就会抛出std::bad_any_cast异常

     a = "Michael && Jenny";
     std::cout << a.type().name() << std::endl; // const char*
     std::cout << std::any_cast<const char*>(a) << std::endl; // Michael && Jenny
     

  4. 修改内容

     除了上面直接使用=赋值运算符之外，我们还可以使用emplace内置成员函数

     std::any a;
     a = 42;
     a.emplace<string>("Michael");
     

  5. 工厂函数 std::make_any

     auto v = std::make_any<int>(123);
     

Ref

• cppreference-variant
• cppreference-visit