devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

c++—可变参数、强枚举、多类型存储（variant）、动态类型（any）、和类型（optional）_std::monostate

作者：我家自动化 | 2024-02-27 21:56:58

赞

踩

std::monostate

1. 可变参数

    （1）C语言中的可变参数，其原理是利用所有的参数在找空间的保存位置是连续的；内部的程序主要是有va_list指针；

    （2）c++的可变参数，就是指initializer_list列表初始化，本质是一个表示某种特定类型的值的数组，可以理解为一个不可扩充的容器；

        ①初始化的区别：这就是为什么很多c++书籍喜欢用{}进型初始化的原因，因为检查严格；

  1. int c = 3.3;  //符合，因为系统内会隐式转换，去尾，C语言风格
  2. int b = {3.3};  //不符合，因为这里默认的是initializer_list<double>,无法实现double到int的转换；
  3. int a {4.5};    //不符合，因为这里默认的是initializer_list<double>,无法实现double到int的转换；

        ②优点：有严格的类型检查，不会允许不同类型之间的隐式转换，这一点不同于C语言；

        ③用处：主要用在构造函数，把初始化列表当做参数，示例如下：

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. class A
  6. {
  7. public:
  8.     A(int num):m_num(num)  
  9.     {
  10.     }
  11.  
  12.     A(const initializer_list<int> v)  //这里是自定义的，与系统默认生成的带可变参数的构造函数相同，不同的是自定义的可以传多个参数，而系统默认的则只能根据属性（m_t的个数）传递；
  13.     {
  14.         for(auto temp : v)
  15.         {
  16.             cout<<temp<<endl;
  17.         }
  18.     }
  19.  
  20.     int m_num; 
  21. };
  22.  
  23. void func1(initializer_list<int> t)    //传进来的是一个可变参数列表，需要通过迭代器遍历
  24. {
  25.     //cout<<t<<endl;
  26.     auto it = t.begin();
  27.     for(; it != t.end(); it++)
  28.     {
  29.         cout<<*it<<endl;
  30.     }
  31. }
  32.  
  33. int main(int argc, char **argv)
  34. {
  35.     initializer_list<int>init_list = {1,3,5,7,9};
  36.     auto it = init_list.begin();    //可变参数列表不支持[],需要利用迭代器
  37.     for(; it!= init_list.end(); it++)
  38.     {
  39.         cout<<*it<<endl;
  40.     }
  41.  
  42.     func1({2,4,6,8,10});
  43.  
  44.     A a(1);
  45.     A a1{200};  //此时，类A中默认生成含有初始化列表的默认构造函数；当没有自定义的initializer_list时，这里的200相当于给m_num赋值，当有时，则不是赋值；
  46.     cout<<a1.m_num<<endl;
  47.     A a2{3,5,7,9};
  48.     cout<<a2.m_num<<endl;
  49.  
  50.     int count = {3};      //带{}的，系统内转化成了initializer_list<int>
  51.     // int len = {3.14};  //initializer_list<double> v = 3.14,无法将double赋给int
  52.     // int m_count {3.3};  //同样会报错，存在double到int的不合适转化，这里不同于C语言的隐式转换
  53.  
  54.     return 0;
  55. }

2. 强枚举类型

    （1）和C语言的枚举类型相比，优势：

        ①强作用域：使用类型成员的时候必须前缀上所属的枚举类型的名字；

        ②可以执行底层类型：枚举类型后面使用了冒号以及类型关键字来执行枚举中的枚举值的类型

        ③转换限制（本质原因是强枚举是一种类型，成员尽管设置成int，但还是该枚举类型下的int，与外部的int不同）：强类型枚举成员的值不可以与整型变量进行转换（隐式与显式都不可以）、不能将其与整数数字进行比较、不能对不同的枚举类型的枚举值进行比较、相同类型的枚举值可以比较；示例如下

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. enum RET1{OK=1,NO=2};
  6. enum class RET2:int{OKK=1,NOO=2};  //表示了指定底层类型的优点
  7.  
  8. RET2 test(int num)  //返回值的类型似乎enum枚举类型，这里不能写作int
  9. {
  10.     if(num == 5)
  11.     {
  12.         return RET2::OKK;
  13.     }
  14.     else
  15.     {
  16.         return RET2::NOO;
  17.     }
  18. }
  19.  
  20. int main(int argc, char **argv)
  21. {
  22.     RET2 n = test(7);  //注意枚举也是一种数据类型，这里不能用作int
  23.     if(n == RET2::OKK) //表示了强作用域的优点，需要前缀枚举类型名称;相同的枚举类型之间可以比较；
  24.     {
  25.         cout<<"等于"<<endl;
  26.     }
  27.     else
  28.     {
  29.         cout<<"不等于"<<endl; 
  30.     }
  31.  
  32.     // int n = RET2::OKK;  //不能利用强枚举类型的成员与整型进行转换，隐式与显式的都不可以
  33.  
  34.     return 0;
  35. }

3. 多类型存储（variant）(一个类型安全的类)

    （1）variant 产生的原因是C语言中的union，其成员只能是同一种类型；而variant则优化了该问题， 是一个类型安全的联合体，本质是一个类模板；其特点是①当前值的类型总是已知的（有成员函数方法判断）；②可以有任何指定类型的成员；③因为其是一个类，所以可以派生类；

    （2）注意事项

        ①variant不容许保有引用、数组，或类型void;

        ②variant容许保有同一类型多于一次，而且保有同一类型的不同cv限定版本；

        ③默认构造的variant保有其首个选项的值，除非该选型不是可默认构造的？？；

    （3）当vatiant作为参数传递时，如何知道此时共用体varitant此时保存的是什么类型的成员？可以利用std::holds_allterative<int>(v),如果此时传来的共用体保存的是int类型的成员，那么该语句就是true，示例如下：

  1. #include <iostream>
  2. #include <variant>
  3.  
  4. using namespace std;
  5.  
  6. class A
  7. {
  8. public:
  9.     A() = default;
  10.     A(int len):m_len(len)
  11.     {
  12.  
  13.     }
  14.     friend ostream& operator<<(ostream &out, const A &a);
  15.     int m_len;
  16. };
  17.  
  18. ostream& operator<<(ostream & out, const A &a)
  19. {
  20.     out<<a.m_len;
  21.     return out;
  22. }
  23.  
  24. using namespace std;
  25.  
  26. using p_type = std::variant<int ,string, double>;
  27.  
  28. void print(p_type &v)
  29. {
  30.     if(std::holds_alternative<int>(v))  //利用std::holds_alternative<>判断传来的共用体里面是什么类型的值
  31.     {
  32.         // cout<<v.emplace()<<endl;
  33.         cout<<v.index()<<" ";  //输出当前类型的索引号
  34.         cout<<std::get<int>(v)<<endl;
  35.     }
  36.     if(std::holds_alternative<string>(v))
  37.     {
  38.         cout<<v.index()<<" ";
  39.         cout<<std::get<string>(v)<<endl;
  40.     }
  41.     if(std::holds_alternative<double>(v))
  42.     {
  43.         cout<<v.index()<<" ";
  44.         cout<<std::get<double>(v)<<endl;
  45.     }
  46. }
  47.  
  48. int main(int argc, char **argv)
  49. {
  50.     p_type v;
  51.     v = 7;
  52.     print(v);
  53.  
  54.     v = "hello";
  55.     print(v);
  56.  
  57.     v = 3.14;
  58.     print(v);
  59.  
  60.     //std::variant<A,int ,string, double> v2;  //无法引用 "std::variant<A, int, std::string, double>" 的默认构造函数 -- 它是已删除的函数C/C++(1790)
  61.     //std::variant<std::monostate,A,int ,string, double> v2; //若第一个共用体成员是类型，则要求该类型需要有默认构造函数，因为类型A没有了默认构造函数，所以需要std::monostate占位符，同时不会影响共用体varitant的内部结构，单纯站位，避免报错
  62.     std::variant<A,int ,string, double> v2;
  63.     cout<<"-----"<<endl;
  64.     v2.emplace<0>(A(7));
  65.     cout<< get<A>(v2) <<endl;  //方式一：采用内部类型方式，且重载了<<运算符
  66.     cout<< get<0>(v2).m_len <<endl;  //方式二：采用了索引方式，且在这里直接访问的类成员
  67.  
  68.  
  69.     v2.emplace<2>("world");
  70.     cout<<get<2>(v2)<<endl;
  71.  
  72.     return 0;
  73. }

    （3）常用方法（成员函数与非成员函数）

        成员函数：

        ①index()：输出当前共用体成员在variant共用体中的索引（0-n）；

        ②emplace()：原地构造函数，即相当于给variant里面的共用体某种成员赋值初始化；上图有例子；

        非成员函数：

        ①std::monostate，主要应用场景是，当varitant的第一个成员是类型时，比如A，当A没有默认无参构造函数时（默认无参构造函数没有指明default，另外有自定义有参构造函数，此时系统默认的无参构造函数将不会创建），就会报错，如上图；此时需要用std::monostate占位符，它会默认成为一个有默认构造函数的替代类型，从而满足varitant对于第一个成员类型的要求；

        ②std::holds_alternative，是用来检查当前共用体里面存储的是什么类型，通用用于varitant传参后，与if和else配合使用，针对不同的类型进行不同的操作；

        ③std::get，用以访问varitant内部的成员，有两种方式，一种是索引，一种是类型名，如上图所示；

        ④std::visit，主要应用于方位varitant变量，根据它的当前类型做不同的操作，像上图是利用的holds_alternative和if_else配合进行判断的，稍显复杂；而std::visit则是一个专门配合varitant的访问器，可以以函数式的方法访问std::variant变量；

        std::visit的参数列表是不定长的，可以传入多个varitant变量；使用示例如下：

简单用法，配合函数对象：

  1. #include <iostream>
  2. #include <variant>
  3.  
  4. using namespace std;
  5.  
  6. struct PrintVisitor  //将函数封装成类，利用函数对象进行处理
  7. {
  8.     void operator()(int i)  //重载了函数运算符，然后是分别是三种类型的函数重载，(int i)(double d)(string s),分别对应varitant中的三种类型
  9.     {
  10.         cout<<"int: "<<i<<endl;
  11.     }
  12.  
  13.     void operator()(double d)
  14.     {
  15.         cout<<"double: "<<d<<endl;
  16.     }
  17.  
  18.     void operator()(const std::string &s)
  19.     {
  20.         cout<<"str: "<<s<<endl;
  21.     }
  22. };
  23.  
  24. int main(int argc, char** argv)
  25. {
  26.     std::variant<int,double,string>value = 1.0;
  27.     std::visit(PrintVisitor(),value);
  28.  
  29.     return 0;
  30. }

        复杂用法,配合lanbda表达式：（求圆形、长方形的面积和周长）

  1. // 值多态,适用于新增方法，已经定义好了类，要在里面增加计算周长，原先是计算面积；
  2. #include <variant>
  3. #include <iostream>
  4. using namespace std;
  5.  
  6. constexpr double pi = 3.14;
  7. struct Shape2  //抽象类
  8. {
  9.    virtual void getName() = 0;
  10. };
  11.  
  12. struct Circle :  public Shape2
  13. {
  14.    Circle()
  15.    {
  16.    }
  17.  
  18.    Circle(double r) : r(r)
  19.    {
  20.    }
  21.  
  22.    void getName()
  23.    {
  24.        cout << "Circle" << endl;
  25.    }
  26.     double r;
  27. };
  28. double getArea(const Circle& c) 
  29. {
  30.     return pi * c.r * c.r;
  31. }
  32. double getPerimeter(const Circle& c) 
  33. {
  34.     return 2 * pi * c.r;
  35. }
  36.  
  37. struct Rectangle :public Shape2
  38. {
  39. public:
  40.     Rectangle(double w, double h) : w(w), h(h)
  41.     {
  42.     }
  43.  
  44.     void getName()
  45.     {
  46.         cout << "Rectangle" << endl;
  47.     }
  48.     double w;
  49.     double h;
  50. };
  51. double getArea(const Rectangle& c) 
  52. {
  53.     return c.h * c.w;
  54. }
  55. double getPerimeter(const Rectangle& c) 
  56. {
  57.     return 2 * (c.h + c.w);
  58. }
  59.  
  60. using Shape = std::variant<Circle, Rectangle>;  //重命名，variant可存储的类型这里是这3种
  61. double getArea(const Shape& v) 
  62. {
  63.     return std::visit([](const auto & data) {return getArea(data); }, v);
  64. }
  65. double getPerimeter(const Shape& v) 
  66. {
  67.     return std::visit([](const auto& data) {return getPerimeter(data); }, v);
  68. }
  69.  
  70. int main() 
  71. {
  72.     Shape sp = Circle(2);
  73.     std::cout<<getArea(sp) << endl;
  74.     std::cout << getPerimeter(sp) << endl;;
  75.  
  76.     sp = Rectangle(2,3);
  77.     std::cout << getArea(sp) << endl;
  78.     std::cout << getPerimeter(sp) << endl;
  79. }

        ⑤两种多态的比较

        第一种：类型多态（subtype）：由继承和虚函数实现，即用基类的指针或引用调用派生类的指针或引用，就可以调用派生类中的方法，实现多态；

        特点：（适合扩展类，不适合扩展方法），适用于新增类，不适合新增方法（因为新增方法的话，在基类和派生类都要增加，违反了扩展性原则），举例，现有基类是计算各图形的面积，两个这样的虚函数，目前已经有圆形的矩形两个类，这是类型多态适合新增一个三角形类，不适合新增计算周长的方法，因为这样基类和派生类都要新增这个方法，而新增三角形类的话，只需要新增后继承基类即可；

        第二种：值多态，是基于函数重载与varitant配合实现的；如上例中的《visit简单用法，配合函数对象》，就是利用函数的参数类型的不同实现的多态；

        特点：（适合扩展方法，不适合扩展类），为所有类新增一个方法较容易，例如在《visit简单用法，配合函数对象》中，就可以在varitant共用体中新增一个类，然后在函数对象struct printvisitor中新增对应的函数就可以了，注意修改参数类型，适配新增的类即可；

4. 动态类型std::any（可以作为函数形参、返回值）

    （1）std::any是代替c的void*，单数any不是类模板，是一种值的类型，使用与保存任何类型的值；

        优点：可以作为形参，接收任何类型的值；

        缺点：频繁的获取空间、释放空间；降低了程序的运行效率；且当传入的数据大于32字节时，any会创建堆内存，额外new一次存储空间，将之前保存的数据复制过来，但是之前的空间并不释放，将导致内存泄漏问题；

    （2）定义与访问内部值：要访问包含的值，需要使用std::any<类型>（变量名），来访问该变量内部的值；示例如下：

  1. #include <iostream>
  2. #include <any>
  3.  
  4. using namespace std;
  5.  
  6. int main(int argc, char **argv)
  7. {
  8.     std::any n1 = 7;
  9.     cout<< std::any_cast<int>(n1) <<endl;  //使用std::any_cast<类型>(变量名) 提取内部值
  10.  
  11.     std::any n2 = string("hello,world");   //注意，需要加string进行转化，因为单独的“hello world”是const char *
  12.     cout<< std::any_cast<std::string>(n2) <<endl;
  13.  
  14.     return 0;
  15. }

    （3）可以作为函数形参、返回值，且可以利用type()和typeid()判断当前any存储的类型，示例如下：

  1. #include <iostream>
  2. #include <any>
  3.  
  4. using namespace std;
  5.  
  6. std::any test(std::any &n)
  7. {
  8.     if(n.type() == typeid(int))  //判断any当前的类型值
  9.     {
  10.         cout<< std::any_cast<int>(n) <<endl;
  11.     }
  12.     if(n.type() == typeid(std::string))
  13.     {
  14.         cout<< std::any_cast<std::string>(n) <<endl;
  15.     }
  16.  
  17.     std::any ret = (std::string)"well done!";
  18.     return ret;
  19. }
  20.  
  21. int main(int argc, char **argv)
  22. {
  23.     std::any n1 = 7;
  24.     test(n1);
  25.  
  26.     std::any n2 = string("hello,world");   //注意，需要加string进行转化，因为单独的“hello world”是const char *
  27.     cout<< std::any_cast<std::string>( test(n2) ) <<endl;  //打印test(n2)的返回值
  28.  
  29.     return 0;
  30. }

5. 和类型std::optional

    （1）如何处理无参返回或者返回多个返回值的问题？

        方法一：bool func1(int  param1,  int * param2)；这种方式浪费存储空间，无论是否有返回值，都需要按照有返回值做准备；

        方法二：采用pair对组和tuple元组；

        pair对组：

        ①pair称为对组，可以将两个值视为一个单元；

        ②pair<T1,T2>存放的这两个值的类型不一样，如T1是int，T2是string，也可以是自定义类型；

       ③pair.first代表pair里面的第一个值，pair.second代表pair里面的第二个值；

        示例如下

  1. #include <iostream>
  2. #include <optional>
  3.  
  4. using namespace std;
  5.  
  6. struct Out
  7. {
  8.     string out1{""};
  9.     string out2{""};
  10. };
  11.  
  12. pair<bool,Out>func(const string & in)
  13. {
  14.     Out o;
  15.     if(in.size() == 0)
  16.     {
  17.         return {false,o};
  18.     }
  19.     o.out1 = "hello";
  20.     o.out2 = "world";
  21.     return {true,o};
  22. }
  23.  
  24. int main(int argc, char **argv)
  25. {
  26.     if(auto[status,o] = func("hi");status)  //前面是对对组初始化，后面的status是判断false还是true？
  27.     {                                       //对组的初始化使用[]，如上面的auto
  28.         cout<<status<<endl;  //status为true；
  29.         cout<<o.out1<<endl;
  30.         cout<<o.out2<<endl;
  31.     }
  32.  
  33.     pair<int, double>p1;   //定义p1
  34.     p1 = make_pair(3,6.7); //初始化p1
  35.  
  36.     cout<<p1.first<<endl;  //输出第一个成员
  37.     cout<<p1.second<<endl; //输出第二个成员
  38.  
  39.     return 0;
  40. }

        tuple元组

        ①tuple容器（元组）是一种容器，是不包含任何结构的、快速而低质的，用于函数返回多个值，在主函数利用auto [ ]接收对应的元组返回值即可，注意[ ]中的类型与函数返回值的类型保持一致；

        ②两种初始化方式、一种获取元素个数方式、两种访问元素方式、一种获取元素类型方式，示例如下：

  1. #include <iostream>
  2. #include <tuple>
  3.  
  4. using namespace std;
  5.  
  6. tuple<bool,string,string> func(int num)  //返回值是元组类型
  7. {
  8.     if(num != 7)
  9.     {
  10.         return make_tuple(false,"the num ","not equal 7");  
  11.     }
  12.     else
  13.     {
  14.         return make_tuple(true,"the num ","equal 7");
  15.     }
  16. }
  17.  
  18. int main(int argc, char **argv)
  19. {
  20.     if(auto[status,out1,out2] = func(7);  status)  //if在c++20中的新功能，可以这里初始化变量，这里是元素变量
  21.     {
  22.         cout<<out1<<out2<<endl;
  23.     }
  24.  
  25.     //两种初始化的方式：
  26.     auto t1 = make_tuple<int,string,double>(7,std::string("name"),5.66); //方式一：利用make_tuple
  27.  
  28.     tuple<int,string,double> t2(9,"tel",7.98); //方式二：直接初始化
  29.     
  30.     //一种获取元素个数的方式：
  31.     int n = std::tuple_size<decltype(t2)>::value;  //获取元组t2内部的元素个数,注意模板里面替换t2即可，dectype和value都是模板，不用改变
  32.     cout<<"t2 has "<<n<<" elements"<<endl;
  33.  
  34.     //两种获取元组内部值的方式：
  35.     cout<<"the elements is ";  //方式一：通过索引
  36.     cout<<get<0>(t2)<<" ";
  37.     cout<<get<1>(t2)<<" ";
  38.     cout<<get<2>(t2)<<endl;
  39.  
  40.     int num; 
  41.     string s1;
  42.     double dou;
  43.     std::tie(num,s1,dou) = t2; //方式二：通过tie解包，需要提前定义所有符合元组类型的单独的变量，不可或缺
  44.     cout<<"the elements is "<< num << " " << s1 <<" "<< dou <<endl;
  45.  
  46.     //一种获取元素类型的方式：
  47.     std::tuple_element<2,decltype(t2)>::type temp;  //获取索引2的类型，此时temp为double类型的变量
  48.     temp = std::get<2>(t2);  //获取实际的元素值
  49.     cout<<"temp = "<<temp<<endl;
  50.  
  51.     return 0;
  52. }

运行结果

        方法三：采用std::optional，其管理的是可选的容纳值；即如果函数成功执行，则返回含实例的值，如果执行失败，则返回不含实例的值；下面详述std::optional；

6. std::optional

        概述：其实optional就是一个类，只不过这个类的成员可以存在，也可以不存在；比如，当你设置optional的成员是一个tuple类时，作为返回值，那么符合条件是你可以返回有你想要的信息在里面的tuple类，此时是栈空间的；而不符合条件时，则返回nullopt，此时不占用空间；在主函数接收返回值时，可以利用auto推导类型，但是需要注意的是此时的返回值还是optional的类型，需要利用其成员函数value()取其值（可以先接受在value,也可以先对返回值value再输出），此时就得到成员tuple，然后在利用tie解包就可以看到里面的信息；同样的，成员也可以是一个自定义类，但是要注意重载<<运算符；详见下例：

        ①定义std::optional<T>，是一个满足可析构的类型；

        ②初始化：使用=用另一个T类型含值std::optional初始化、使用构造函数初始化（以nullopt_t类型值或是T类型值）、默认构造函数；

        ③判断是否含值的方式：使用bool hasValue = temp.has_value()检查是否含值；

        ④取值的方式：使用（*temp）取T，即默认为T的指针，使用temp.value()获取T值，使用temp.value_or()获取值（存在值）或者其他（不存在值）；

        ⑤返回：返回一个T对象（非指针）、nulloptl；

示例如下：

  1. #include <iostream>
  2. #include <tuple>
  3. #include <string>
  4. #include <optional>
  5. #include <set>
  6.  
  7. using namespace std;
  8.  
  9. using tu = tuple<int,string>;
  10.  
  11. optional<tu> func1(int num)  //返回值是optional类型(成员是tuple<int,string>)
  12. {
  13.     if(num == 5)
  14.     {
  15.  
  16.         return std::make_tuple(100,"ok");
  17.     }
  18.     else
  19.     {
  20.         return nullopt;
  21.     }
  22. }
  23.  
  24. class A
  25. {
  26. public:
  27.     A() = default;
  28.     A(int t):m_t(t)
  29.     {
  30.  
  31.     }
  32.     friend ostream& operator<<(ostream&out, A &a);
  33.     int m_t;
  34. };
  35. ostream& operator<<(ostream&out, A &a)
  36. {
  37.     out<<a.m_t;
  38.     return out;
  39. }
  40.  
  41. optional<A>func2(int num)  //返回值是optional类型(A)
  42. {
  43.     if(num = 7)
  44.     {
  45.         return A(567);
  46.     }
  47.     else
  48.     {
  49.         return nullopt;
  50.     }
  51. }
  52.  
  53. int main(int argc, char **argv)
  54. {
  55.     int id = 0;
  56.     string msg{};
  57.  
  58.     auto t4 = func1(5);  //方式一：先接收返回值，然后对返回值取值（value）
  59.     cout<<t4.has_value()<<endl;  //判断返回值t4是否含有值，有是1，无是0
  60.     std::tie(id,msg) = t4.value();  //因为这里的返回值是optional，而tuple是它的一个成员，所以这里需要调用optional的成员函数value(),将内部成员取出，因为该成员是tuple，所以利用tie解包
  61.     cout<< id <<" "<< msg <<endl;
  62.                                 
  63.     auto t5 = func2(7).value();  //方式二：直接对返回值取值（value），然后就可以直接操作成员了；需要利用optional的成员函数value取其值,之后就是一个A类型变量
  64.     cout<<t5<<endl;  
  65.  
  66.     return 0;
  67. }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/156139
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号