C++之std::holds_alternative、std::get、std::variant应用实例(二百一十九)

已于 2023-09-17 14:20:17 修改
阅读量1.8k 收藏 7
点赞数 1
分类专栏： C++进阶系列 文章标签： c++ 开发语言
于 2023-09-16 22:54:45 首次发布
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/u010164190/article/details/132927656
版权

简介： CSDN博客专家，专注Android/Linux系统，分享多mic语音方案、音视频、编解码等技术，与大家一起成长！

优质专栏：Audio工程师进阶系列【原创干货持续更新中……】🚀

人生格言： 人生从来没有捷径，只有行动才是治疗恐惧和懒惰的唯一良药.

更多原创,欢迎关注：Android系统攻城狮

欢迎关注Android系统攻城狮

1.前言

本篇目的：理解C++之std::get用法。

1.在C++中，std::holds_alternative是一个模板函数，用于检查给定的std::variant对象是否包含指定类型的值。它返回一个bool值，指示给定类型是否存在于std::variant中。
2.在C++中，std::get是用于从std::tuple和std::variant等类型中获取值的函数模板。它接受一个索引作为参数，并返回相应位置的值。
3.在C++中，std::variant是C++17标准引入的一种通用多态类型。它能够在一个单一的变量中存储不同的类型。std::variant的作用是提供了一种类型安全的方式来处理多个可能的类型。

std::variant可以存储一组预定义的类型之一，这些预定义类型称为“可选类型列表”。当创建一个std::variant对象时，你需要指定可选类型列表。这样，你就可以在这个std::variant对象中存储这些类型中的任意一个。

使用std::variant时，你可以使用std::get来获取存储在std::variant中的值，或者使用std::visit来对std::variant中的值进行多态处理。此外，还可以使用std::holds_alternative来检查std::variant中是否存储了特定的类型。

2.应用实例

<1>.v1.0: std::variant应用实例

#include <variant>
#include <iostream>
#include <string>

int main() {
    std::variant<int, std::string> var;

    var = 42; // 存储一个int类型的值
    std::cout << std::get<int>(var) << std::endl; // 输出: 42

    var = "Hello"; // 存储一个std::string类型的值
    std::cout << std::get<std::string>(var) << std::endl; // 输出: Hello

    return 0;
}

<2>.v2.0：std::holds_alternative用法

#include <iostream>
#include <variant>
#include <string>

int main() {
    std::variant<int, double, std::string> myVariant = "Hello";

    // 使用std::holds_alternative检查指定类型是否存在于variant中
    bool isInt = std::holds_alternative<int>(myVariant);
    bool isDouble = std::holds_alternative<double>(myVariant);
    bool isString = std::holds_alternative<std::string>(myVariant);

    std::cout << "isInt: " << isInt << std::endl;            // 输出：isInt: 0
    std::cout << "isDouble: " << isDouble << std::endl;      // 输出：isDouble: 0
    std::cout << "isString: " << isString << std::endl;      // 输出：isString: 1

    return 0;
}

<3>.v3.0: 对于std::tuple，std::get的用法。

#include <iostream>
#include <tuple>

int main() {
  std::tuple<int, std::string, double> myTuple(42, "Hello", 3.14);

  // 使用std::get获取tuple中的值
  int intValue = std::get<0>(myTuple);
  std::string stringValue = std::get<1>(myTuple);
  double doubleValue = std::get<2>(myTuple);

  std::cout << intValue << std::endl;        // 输出：42
  std::cout << stringValue << std::endl;     // 输出："Hello"
  std::cout << doubleValue << std::endl;     // 输出：3.14

  return 0;
}

<4>.v4.0: 对于std::variant，std::get的用法。

#include <iostream>
#include <variant>
#include <string>

int main() {
  std::variant<int, std::string, double> myVariant = 42;

  // 使用std::get获取variant中存储的值
  int intValue = std::get<int>(myVariant);
  std::cout << intValue << std::endl;        // 输出：42

  // 尝试使用std::get获取不匹配的类型，会抛出std::bad_variant_access异常
  try {
    std::string stringValue = std::get<std::string>(myVariant);
  } catch(const std::bad_variant_access& e) {
    std::cout << "Error: " << e.what() << std::endl;  // 输出：Error: std::bad_variant_access
  }

  return 0;
}

<5>.v5.0： std::holds_alternative、 std::variant实例

#include <iostream>
#include <variant>
#include <string>
#include <utility>

using namespace std;

using Elem = std::variant<std::monostate, int32_t, int64_t, double, std::string, std::pair<int64_t, int64_t>>;

int main() {
    Elem e1 = 42;
    Elem e2 = "Hello, world!";
    Elem e3 = 3.14;
    Elem e4 = std::make_pair(10, 20);

    if (std::holds_alternative<int32_t>(e1)) {
        int32_t value = std::get<int32_t>(e1);
        cout << "e1 is an int32_t: " << value << endl;
    }

    if (std::holds_alternative<std::string>(e2)) {
        std::string value = std::get<std::string>(e2);
        cout << "e2 is a string: " << value << endl;
    }

    if (std::holds_alternative<double>(e3)) {
        double value = std::get<double>(e3);
        cout << "e3 is a double: " << value << endl;
    }

    if (std::holds_alternative<std::pair<int64_t, int64_t>>(e4)) {
        std::pair<int64_t, int64_t> value = std::get<std::pair<int64_t, int64_t>>(e4);
        cout << "e4 is a pair: (" << value.first << ", " << value.second << ")" << endl;
    }

    return 0;
}

<6>.v6.0 综合应用实例

#include <iostream>
#include <string>
#include<typeinfo>
#include <variant>
#include <map>

using namespace std;

class Item {
public:

  template<typename S, typename T>
  Item &set(S key, T value) {
    printf("xxx---------->%s(), line = %d, key = %s, vlaue = %d\n",__FUNCTION__,__LINE__,key,value);
    //findOrAllocateProp函数返回Prop对象然后,然后调用员函数set(),最终key值设置到mName, value设置到mElem中.
    findOrAllocateProp(key).set(value);
    return *this;
  }

  Item &setInt32(const char *key, int32_t value) {
    printf("xxx---------->%s(), line = %d, key = %s, vlaue = %d\n",__FUNCTION__,__LINE__,key,value);
    return set(key, value);
  }

  class Prop {
  public:
    using Elem = std::variant<std::monostate, int32_t, int64_t, double, std::string, std::pair<int64_t, int64_t>>;

    //1.设置key值给mName
    void setName(const char *name) {
      printf("xxx---------->%s(), line = %d, name = %s\n",__FUNCTION__,__LINE__,name);
      mName = name;
    }

    //2.将valuec传给mElem.
    template <typename T> void set(const T& value) {
      printf("xxx---------->%s(), line = %d, value = %d\n",__FUNCTION__,__LINE__,value);
      mElem = value;

      //获取mElem中的value值.
      int32_t val = std::get<int32_t>(mElem);
      printf("xxx---------->%s(), line = %d,val = %d\n",__FUNCTION__,__LINE__,val);
    }

  public:
    std::string mName;
    Elem mElem;
  };

  //findOrAllocateProp函数返回Prop对象然后,然后调用员函数set()
  Prop &findOrAllocateProp(const char *key) {
    auto it = mProps.find(key);//开始key对应的value为空.

    if (it != mProps.end()){//不走此分支.
      return it->second;
    }

    Prop &prop = mProps[key];
    prop.setName(key);
    printf("xxx---------->%s(), line = %d, key = %s, nName = %s\n",__FUNCTION__,__LINE__,key,prop.mName.c_str());
    return prop;
  }

  std::map<std::string, Prop> mProps;
};

int main(){
  Item it;
  it.setInt32("Tom", 18);


}

<7>.v7.0

#include <iostream>
#include <string>
#include<typeinfo>
#include <variant>
#include <map>

using namespace std;

class Item {
public:

  template<typename S, typename T>
  Item &set(S key, T value) {
    printf("xxx---------->%s(), line = %d, key = %s, vlaue = %d\n",__FUNCTION__,__LINE__,key,value);
    //findOrAllocateProp函数返回Prop对象然后,然后调用员函数set(),最终key值设置到mName, value设置到mElem中.
    findOrAllocateProp(key).set(value);

    //Or
    // Prop m_prop = findOrAllocateProp(key);
    // printf("xxx---------->%s(), line = %d, key = %s, value = %d\n",__FUNCTION__,__LINE__,m_prop.mName.c_str(),std::get<int32_t>(m_prop.mElem));
    return *this;
  }

  Item &setInt32(const char *key, int32_t value) {
    printf("xxx---------->%s(), line = %d, key = %s, vlaue = %d\n",__FUNCTION__,__LINE__,key,value);
    return set(key, value);
  }

  //key: mName; value:mElem.
  class Prop {
  public:
    using Elem = std::variant<std::monostate, int32_t, int64_t, double, std::string, std::pair<int64_t, int64_t>>;

    //1.设置key值给mName
    void setName(const char *name) {
      printf("xxx---------->%s(), line = %d, name = %s\n",__FUNCTION__,__LINE__,name);
      mName = name;
    }

    //2.将valuec传给mElem.
    template <typename T> void set(const T& value) {
      mElem = value;
      //获取mElem中的value值.
      int32_t val = std::get<int32_t>(mElem);
      printf("xxx---------->%s(), line = %d,val = %d\n",__FUNCTION__,__LINE__,val);
    }

  public:
    std::string mName;//key
    Elem mElem;//value
  };

  //findOrAllocateProp函数返回Prop对象然后,然后调用员函数set()
  Prop &findOrAllocateProp(const char *key) {
    auto it = mProps.find(key);//开始key对应的value为空.

    if (it != mProps.end()){//不走此分支.
      return it->second;
    }

    Prop &prop = mProps[key];
    prop.setName(key);    
    return prop;
  }

  std::map<std::string, Prop> mProps;
};

int main(){
  Item it;
  it.setInt32("Tom", 18);
}
C++(17)：variant
风静如云的博客
11-27 3909
2.variant构造时，如果没有指明类型，会用第一个类型（索引为0的类型）的默认构造函数进行构造（如上例中对象d），因此第一个类型必须具有默认构造函数。如果变体类型 v 存放的数据类型下标为 Index，那么返回所存放数据的指针，否则返回空指针。如果变体类型 v 存放的数据类型下标为 Index，那么返回所存放的数据，否则抛出异常。如果变体类型 v 存放的数据类型为 T，那么返回所存放数据的指针，否则返回空指针。如果变体类型 v 存放的数据类型为 T，那么返回所存放的数据，否则抛出异常。
C++ std::holds_alternative示例
cxyhjl的博客
12-10 303
@param[out] value 寄存器数值，允许的类型有bool/int/float。* 如果要读取整个寄存器数组，value传入对应类型的vector，index值被忽略。* @brief 读取寄存器值。可读取单个寄存器，寄存器数组，或按索引读取寄存器数组。* @param[in] index 按索引读取寄存器数组中元素，从0开始。和要检查的类型作为模板参数传递给函数。以下是一个示例，演示如何在模板函数中使用。* @param[in] name 寄存器名称。在这个示例中，我们定义了一个模板函数。
C++ 的 get 和 get_if
最新发布
oRbIt 的专栏
02-13 1096
介绍 std::get 和 std::get_if 函数，以及如何让自定义对象支持这两个函数
c++基本介绍——std::holds_alternative()的基本介绍
XWWW668899的博客
10-09 942
std::holds_alternative 是一个方便的工具，允许开发者在访问 std::variant 中的值之前，安全地检查其类型，增强代码的健壮性和可读性。
C/C++：std::get
OceanStar的博客
09-28 4495
模板函数std::get()是一个辅助函数，它能够获取到容器的第n 个元素。模板参数的实参必须是一个在编译时可以确定的常量表达式，编译时会对它检查。
C++_tuple, tie, std::get＜＞
WChang的博客
08-16 4551
catalogtuple源码tie用处—简化比较 tuple源码 template <typename Head , typename... Tail> class tuple<Head, Tail> : private tuple<Tail...>{ protected: Head m_head; public: tuple(Head h , Tail... t) : m_head(h), tuple<Tail...>(t){} }; te
安全访问元组元素：std::get_if的现代C++方法
![安全访问元组元素：std::get_if的现代C++方法]... 现代C++中的std::get_if简介 现代C++语言在功能上的持续扩展，增加了许多强大的特性，使开发者能够编写更加安全、高效且易于维护的
C++ std::tuple与std::variant的结合应用：多态类型处理新策略
多态是面向对象编程的核心概念之一，它允许在运行时通过基类指针或引用来操作派生类对象。在C++中，多态的实现主要依赖于虚函数机制，它为基类提供了一种接口，使得派生类能够覆盖这些函数以提供特定的行为。 在本...
std::variant<std::monostate, bool>
09-10
`std::variant`是C++17引入的一个类模板，它代表了一个可以存储多种类型值的类型安全的联合体。`std::variant`中的每一类型称为一个“可能类型”。当创建一个`std::variant`实例时，你需要列出所有可能存储的类型，...
掌握C++新技巧：std::variant自定义类型擦除的秘诀
`std::variant` 是C++17引入的一个类型安全的联合体，它允许存储一系列类型的其中一个。这使得 `std::variant` 成为了一个强大的工具，适用于需要处理不同类型数据的场景，比如在实现编译时多态、实现状态机或者在...
C++ std::get函数实用指南：精通元组元素访问技巧
`std::get` 是C++标准库中一个强大的模板函数，它允许直接访问`std::tuple`中的元素。在C++11及其后续版本中，`std::get` 提供了一种类型安全且编译时检查的方式来提取元组中的数据。 ## 为何使用std::get `std::...
【C++基础知识——`std::get_if`其实就是`std::holds_alternatvie`和`std::get`的结合】
XWWW668899的博客
10-11 807
`std::get_if`其实就是`std::holds_alternatvie`和`std::get`的结合。
【C++基础知识——std::get配合std::holds_alternative从`std::variant` 中提取存储的值】
XWWW668899的博客
10-10 643
std::get是一个强大且灵活的函数，允许开发者安全地从中提取存储的值。正确使用std::get可以增强代码的安全性和可读性。
C++ std__get(std__tuple)
每一个不曾起舞的日子，都是对人生的辜负。
08-23 228
【代码】C++ std__get(std__tuple)
C++ 那些被遗漏的细节3 std::get
程序员Link
07-12 6538
简述 在之前的文章C++11 std::tuple 中使用std::get获取std::tuple元素的例子。 std::get除了通过索引(C++11)获取std::tuple的元素，还能通过元素类型获取元素(C++14) 语法 // 头文件 <tuple> template< std::size_t I, class... Types > typename std::tuple_element<I, tuple<Types...> >::type&am
C++17完整导引-组件之std::variant
西门吹雪
05-26 2291
std::variant as a “safer union”
std::get(std::tuple)
thefist的专栏
12-05 1218
template< std::size_t I, class… Types >typename std::tuple_element<I, tuple<Types…> >::type& get( tuple<Types…>& t ) noexcept; (1) (since C++11)(constexpr since C++14) template< std::size_t I, class… Types...
【C++】get( )函数
Hugh_215的博客
05-07 2266
分类：无参数的；有一个参数的；有3个参数的。
Modern C++ std::variant 我小看了get的速度
深山老宅的虚拟空间
02-23 2872
编译器深度优化std::get(variant)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Android系统攻城狮

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

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

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

打赏作者

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

抵扣说明：

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

余额充值