右值引用与完美转发、变长模板参数与折叠表达式、variant的使用、tuple的使用

已于 2024-04-02 20:22:13 修改
阅读量62 收藏
点赞数
文章标签： c++
于 2023-08-16 21:02:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43495002/article/details/132231952
版权

目录

通常字面量是右值，但字符串字面量是左值

常量左值引用的作用

常量左值引用 不仅可以引用左值，还能引用右值：const int &x = 11;
而非常量左值引用 只能引用左值

class X
{
public:
    X(){}
    X(const X&){}
    X& operator = (const X&){return *this;}
};
X make_x()
{
    return X();//返回右值，这里发生拷贝构造，恰好const X&是常量左值引用，可以引用右值
}

一旦使用常量左值引用，就无法再修改该对象的内容了

右值引用的作用

右值引用可以延长右值的生命周期。右值引用不能引用左值

使用右值引用可以减少调用拷贝构造(实际上被优化过优化都一样，加命令行参数 -fno-elide-constructors关闭优化才能看到效果)
g++ test1.cpp -fno-elide-constructors

#include <iostream>
class X
{
public:
    X(){
        std::cout<<"构造"<<std::endl;
    }
    ~X(){
        std::cout<<"析构"<<std::endl;
    }
    X(const X&){
        std::cout<<"拷贝"<<std::endl;
    }
    X& operator = (const X&){
        return *this;
    }

};

X make_x()
{
    return X();//返回右值，这里发生拷贝构造，恰好const X&是常量左值引用，可以引用右值
}

int main()
{
    //1.发生2次拷贝构造才得到了x1
    X x1 = make_x();
    //2.使用右值引用减少拷贝
    X&& x2 = make_x();
}

左值右值

  • 泛左值：左值、将亡值

  • 右值：将亡值、纯右值

  • 将亡值的产生途径

    • 使用static_cast 将 泛左值 转为 右值引用
    • 临时量实质化：已知临时对象是纯右值，当要访问该对象的成员时，该临时对象实质化为将亡值

  • 怎么将左值数据转移到另一个左值：

    前面说到，右值引用不能引用左值。但可以先将其转为将亡值再来做。
    int i = 0;
    int &&j = static_cast<int &&> (i);

    X &&a = X();//a是右值引用
X b = a;//拷贝
X c = static_cast<X &&> (a);//移动
//此后不能再使用a了

    注意：右值引用是左值

  • 传入临时对象时，函数内部使用上述技巧的好处：

    • 常规做法：

      //接收右值引用，而右值引用 可引用 右值， 不可引用 左值。右值引用是左值。因此这里只能传右值
void test(X &&a)
{
    //a是左值
    X b(a);//没有必要的拷贝，a是一个将亡值传进来的，这里直接move更好
}
int main()
{
    //传入将亡值
    test(X());//无论实参是左值还是右值，形参一定是左值
    return 0;
}

    • 改进做法：

      //接收右值引用，而右值引用 可引用 右值， 不可引用 左值。右值引用是左值。因此这里只能传右值
void test(X &&a)
{
    //a是左值
    X b(static_cast<X &&> (a));//a被强转为右值，就会调用移动构造来创建b，而不是拷贝
}
int main()
{
    //传入将亡值
    test(X());//无论实参是左值还是右值，形参一定是左值
    return 0;
}

    • c++11提供了左值转右值的方法，不需要自己写static_cast了
      std::move(a)即可转为右值引用

  • 引用折叠规则
    发生引用折叠时，任一引用为左值引用 则 结果为左值引用。否则为右值引用。
    引用折叠

  • 实现完美转发：调用std::forward(t)或者写static_cast进行强转

    #include <iostream>
using namespace std;
void process(int & i)
{
    cout<<"左值引用的函数"<<endl;
}

void process(int && i)
{
    cout<<"右值引用的函数"<<endl;
}

template <typename T>
void myfun(T && t)
{
    //不能直接process(t)，否则无论t是int还是int&，都只能调process(int &)
    //应当将t强转为T &&，即多折叠上&&，这样对于int，就恢复成了右值引用；对于int&，就保持不变
    process(static_cast<T &&> (t));
    // process(std::forward<T>(t));
}
int main()
{   
    int a=3;
    myfun(a);//传入a，T被推导为int &
    myfun(2);//传入2，T被推导为int
    return 0;
}

总结

问：说一个c++11提出的非常重要的概念
右值引用：用来延长右值的生命周期，还实现了与之相关的移动语义和完美转发，许多常用容器都已经实现了移动构造和移动赋值

变长模板参数与折叠表达式

  • 要求1：实现变长参数求和

    c++17中 …有两种展开方式，一种是return (ts + ...)以ts自身开始展开，另一种是return (0 + ... + ts)指定一个初始值，然后展开。这里示例使用+ … ，实际上还可以有* …，甚至逗号 …展开。

    #include <iostream>
template<class ...Ts>
auto func(Ts ...ts)
{
    //return (ts + ...)等价于return (1+2+3)
    return (0 + ... + ts);//这里写上0是为了有一个初始值，否则func()为空参数时会报错
}
int main() {
    std::cout<<func()<<std::endl;
    std::cout<<func(1,2,3)<<std::endl;
    return 0;
}

    小细节：如果这样调用func((1,2,3))，会返回3，因为(1,2,3)是逗号表达式，表达式结果是其中的最后一个元素值

  • 要求2：想要ts[0]、ts[1]这样遍历打印参数

    使用逗号表达式，把()当作{}，把逗号当作分号使用，相当于一个for循环。例如(myprint(ts), …)就会让参数依次执行myprint。

    #include <iostream>
template<class T>
void myprint(T a)
{
    std::cout<< a;
}

template<class T0, class ...Ts>
auto func(T0 t0, Ts ...ts)
{
    myprint(t0);
    ((myprint(","), myprint(ts)), ...);
    myprint("\n");
}

int main() {
    func(1,2,3);//1,2,3
    return 0;
}

    如果是在c++11中，无法使用逗号…来展开，可以像下面这样写函数模板。

    auto func(){}

template<class T0, class ...Ts>
auto func(T0 t0, Ts ...ts)
{
    myprint(t0);
    myprint(",");
    func(ts...);//1，2，3，
}

    如果想要最后一个参数时不多打印一个逗号，要么利用c++17将myprint(“,”)写在if constexpr分支里，要么使用SFINAE来实现。下面是使用SFINAE(匹配失败不是错误)来实现的

    #include <iostream>
#include <numeric>
template<class T>
void myprint(T a)
{
    std::cout<< a;
}

auto func(){
    myprint("\n");
}

template<class T0, class ...Ts, std::enable_if_t<sizeof...(Ts) == 0, int> = 0>
auto func(T0 t0, Ts ...ts)
{
    myprint(t0);
    func(ts...);
}

template<class T0, class ...Ts, std::enable_if_t<sizeof...(Ts) != 0, int> = 0>
auto func(T0 t0, Ts ...ts)
{
    myprint(t0);
    myprint(",");
    func(ts...);
}

int main() {
    func(1,2,3);//1,2,3
    return 0;
}

    实际上还可以结合lambda表达式使用

    ([&](){
    myprint(",");
    myprint(ts);
}(), ...);

  • 要求3：怎么找到参数类型的共同类型(例如int和float共同类型是float，Cat和Animal共同类型是Animal)
    方法1：using T = std::common_type_t<Ts...>;
    方法2：利用decltype

    using type = decltype(1?int():double());得到的type是double，因为?后面的值在比较前要先提升到同一类型，这里提升为double。
    例如：下面的res类型为double
    double x = 3.5;
    int y = 4;
    auto res = (0 ? x : y);

    //这里使用三目运算符配合decltype得到共同类型。
//之所以不使用decltype(T1()+T2())，
//是因为T1和T2类型可能不是数值类型，可能是子类与父类的关系。
template<class T1, class T2>
struct common_type
{
    using type = decltype(0?T1():T2());
    //如果T1和T2没有构造函数，可以使用declval凭空构建
    //using type = decltype(0?std::declval<T1>():std::declval<T2>());
};

int main() {
    using what = typename common_type<const char *, char *>::type;
    return 0;
}

    拓展1：多使用模板偏特化来获取多个类型的共同类型

    #include <iostream>
#include <typeinfo>
//求两个类型的共同类型
template<class T1, class T2>
struct common_type_two
{
    using type = decltype(0?std::declval<T1>():std::declval<T2>());
};
//主模板
template<class ...Ts>
struct common_type
{    
};
//特化：结束条件，只有一个类型时，直接返回自身
template<class T0>
struct common_type<T0>
{    
    using type = T0;
};
//特化
template<class T0, class T1, class ...Ts>
struct common_type<T0,T1,Ts...>
{
    using type = typename common_type_two<T0,typename common_type<T1,Ts...>::type>::type;
    
};

int main() {
    using what = typename common_type<double, int, float>::type;
    return 0;
}

    拓展2：使用编译期函数搭配条件编译来实现

    #include <typeinfo>
#include <iostream>

template <class T0, class ...Ts>
constexpr auto get_common_type(T0 t0, Ts ...ts)
{
    if constexpr (sizeof...(Ts) == 0){
        return t0;
    }
    else{
        return 0 ? t0 : get_common_type(ts...);
    }
}
int main() {
    using what = decltype(int(), double(), float());
    return 0;
}

    拓展2的问题：如果是想得到子类和父类的共同类型，不能使用std::declval来凭空构造，因为这里是真的要调用构造函数得到对象来传递参数到get_common_type。
    拓展2的解决：但我们实际上需要的根本不是对象t0，而是它的类型，因此可以使用dummy(c++20才有)，下面自己实现了一个dummy，T类型没有构造函数，但dummy可以有，因此可以传递dummy类型的变量。只需要最后调用dummy提供的返回T类型凭空构造的方法，对其decltype，就能获得最终T类型。

    #include <typeinfo>
#include <iostream>

template <class T>
struct dummy
{   //这里自己定义的declval直接调用std库的declval进行凭空构造，外层decltype一下就能得到T类型
    static constexpr T declval()
    {
        return std::declval<T>();
    }
};

template <class T0, class ...Ts>
constexpr auto get_common_type(dummy<T0> t0, dummy<Ts> ...ts)
{
    if constexpr (sizeof...(Ts) == 0){
        return t0;
    }
    else{ //t0.declval()是dummy<Animal>
        return dummy< decltype(0 ? t0.declval() : get_common_type(ts...).declval()) >();
    }
    
}
struct Animal
{};
struct Cat:Animal
{
    Cat(Cat &&) = delete;//删除移动，则拷贝与默认构造都没了
};

int main() {
    using what = decltype(get_common_type(dummy<Animal>(), dummy<Cat>()).declval());
    return 0;
}

  • 要求4：想要变长参数类型全是int类型

    只需要使用c++20里的requires结合变长模板参数。如果想要能转换成int的都可以，那么将下面的is_same_v改为is_convertible_v

    template <class ...Ts>
//为了避免无参数时报错，不要写成requires((std::is_same_v<Ts, int> && ...))
requires((true && ... && std::is_same_v<Ts, int>))
void myvec(Ts ...ts)
{}

  • 要求5：判断类型T0 是否为 …Ts中的其中一个类型

    即T0要与…Ts进行 “或” 比较，使用std::is_same_v<T,Ts>即可比较，再搭配上变长模板参数…

    template<class T, class ...Ts>
struct is_same_any
{
    static constexpr bool value = (false || ... || std::is_same_v<T,Ts>);
};

  • 要求6：之前求共同类型时，需要把各种类型(int float double)等一起传来传去，不如写成tuple类型

    //1.定义tuple类型
using Tup = std::tuple<int, float, double>;
//2.把之前的common_type结构体用tuple包装一遍，就可以这样使用了
//using what = tuple_apply_common_type<Tup>::type;
//主模板
template<class Tup>
struct tuple_apply_common_type
{};
//特化
template<class ...Ts>
struct tuple_apply_common_type<std::tuple<Ts...>>
{	//直接调用之前写的求共同类型
    using type = typename common_type<Ts...>::type;
};

  • variant的使用

    #include <variant>
int main() {
    //1.获知当前类型在variant的索引(从0开始)
    // std::variant<int, std::string, double> v = 3.5;//如果没赋值，默认为第一个类型
    std::variant<int, std::string, double> v {std::in_place_index<2>,2.5};//明确写出要启用的数据类型
    // std::variant<int, std::string, double> v {std::in_place_type<double>, 2.5};//与上面等价
    std::cout<< v.index() <<std::endl;//2
    //2.get获取值
    std::cout<< std::get<double>(v) <<std::endl;//2.5，如果写成了get<int>会报错std::bad_variant_access
    //3.get_if获取值，得到的是指针，如果类型不正确会返回nullptr，使得有可以在访问前进行安全判断
    int* p = std::get_if<int>(&v);//get_if只接受指针
    std::cout<< (p == nullptr) <<std::endl;//安全判断：得知p为空指针
    //4.检查当前variant是不是int类型
    std::cout<< std::holds_alternative<int>(v) <<std::endl;//0 不是
    //5.可切换的类型个数
    std::cout<< std::variant_size_v<decltype(v)> <<std::endl;//3
    //6.访问
    std::visit([](auto && arg){
        std::cout<<arg<<std::endl;//2.5
    },v);
    //打印nh yx
    std::visit([](const auto &t){std::cout<<t<<" yx"<<std::endl;},std::variant<int, float, std::string> ("nh"));

    return 0;
}

  • tuple的使用

    //1.创建元组
std::tuple<int,double> a1(2, 2.5);
//2.访问与修改
std::get<0>(a1) = 3;//修改
std::cout<< std::get<0>(a1) <<std::endl;//3
//3.元组的元素个数
std::cout<< std::tuple_size<decltype(a1)>::value <<std::endl;//2
//4.解包
int m;
double n;
std::tie(m,n) = a1;
//5.获取元素类型
using what = std::tuple_element<0, decltype(a1)>::type;//int
//元组拼接
std::tuple<float, char> a2;
auto res = std::tuple_cat(a1, a2);//std::tuple<int, double, float, char> res

  • 要求7：tuple类型的连接

    template<class Tup1, class Tup2>
struct tuple_cat
{
};

template<class ...T1s, class ...T2s>
struct tuple_cat<std::tuple<T1s...>,std::tuple<T2s...>>
{
    using type = std::tuple<T1s..., T2s...>;
};
int main() {
    using what = tuple_cat<Tup1, Tup2>::type;
    return 0;
}

  • 要求8：tuple的push_front

    template<class T1, class T2>
struct tuple_push_front{};

template<class T1, class ...T2s>
struct tuple_push_front<T1, std::tuple<T2s...>>
{    
    using type = std::tuple<T1, T2s...>;
};
//使用
using what2 = tuple_push_front<char, Tup1>::type;

  • 要求9：获取tuple的第一个索引类型
    方式1：使用std::tuple_element_t获取指定下标的索引类型

    template<class T>
struct tuple_getfirst
{};

template<class ...Ts>
struct tuple_getfirst<std::tuple<Ts...>>
{
    using type = std::tuple_element_t<0,std::tuple<Ts...>>;
};

    方式2：自己实现

    template<class T>//如果tuple是空的，就会落入这里，因此其实可以在这里设置一个默认值
struct tuple_getfirst
{};

template<class T0, class ...Ts>
struct tuple_getfirst<std::tuple<T0, Ts...>>
{
    using type = T0;
};

  • 要求10：实现tuple_element获取任意下标的索引类型
    利用类模板递归

    #include <tuple>
//主模板
template<int index, class T>
struct tuple_element
{};
//特化：index为0时
template<class T0, class ...Ts>
struct tuple_element<0, std::tuple<T0, Ts...>>
{
    using type = T0;
};
//特化
template<int index, class T0, class ...Ts>
struct tuple_element<index, std::tuple<T0, Ts...>>
{
    using type = typename tuple_element<index-1, std::tuple<Ts...>>::type;
};

int main() {
    using Tup1 = std::tuple<int,float,char>;
    using what = tuple_element<1,Tup1>::type;//float
    return 0;
}

  • 要求11：判断tuple里的类型是不是全为integral(int char short)
    利用c++17的…折叠表达式

    template<class T>
struct tuple_all_integral
{};

template<class ...Ts>
struct tuple_all_integral<std::tuple<Ts...>>
{
    static constexpr bool value = (true && ... && std::is_integral_v<Ts>);
};
爬虫大佬
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
【极富参考价值！】第1章 ClickHouse 简介《ClickHouse 企业级大数据分析引擎实战》...
禅与计算机程序设计艺术
12-13 9440
《ClickHouse 企业级大数据分析引擎实战》全书目录目录第1章 ClickHouse 简介第2章 MergeTree 表存储引擎第3章 ClickHouse SQL 执行原理第4章 ...
【C++】C++11——右值引用和移动语义|可变参数模板
大三小白C++进阶之路
07-24 391
C++11右值引用、移动语义和可变参数模板的使用
【C++ 泛型编程 高级篇】C++可变参数模板探索：编程技巧与实战应用
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
04-08 737
C++可变参数模板揭秘：编程技巧与实战应用可变参数模板是C++11引入的一种新特性，用于定义可以接受任意数量和类型参数的模板。可变参数模板可以应用于类模板和函数模板。定义可变参数模板时，使用"..."表示一个参数包，该参数包可以包含任意数量和类型的参数。
C++之std::tuple(一) : 使用精讲(全)
红军不怕远征难，万水千山只等闲
02-03 5651
C++11之后引入了std::tuple，俗称元组，元组(tuple)是一种用于组合多个不同类型的值的数据结构。元组可以将不同类型的数据打包在一起，类似于一个容器，可以按照索引顺序访问其中的元素。元组的大小在编译时确定，不支持动态添加或移除元素。std::tuple类似互C语言的结构体，不需要创建结构体而又有结构体的特征，在某些情况下可以取代结构体而使得程序更加简洁，直观。std::tuple理论上可以定义无数多个不同类型的成员变量。
现代c++ 14 17 | decltype | 委托构造 | 折叠表达式
Meepo
12-13 202
https://www.zhihu.com/topic/20020247/hot c++17 知乎 https://zhuanlan.zhihu.com/p/57530780 variant http://yizhanggou.top/c-e5-8f-8d-e5-b0-84-e7-9a-84-e4-b8-80-e7-a7-8d-e5-ae-9e-e7-8e-b0--e5-8f-af-e5-8f-98-e5-8f-82-e6-95-b0-e6-a8-a1-e6-9d-bf/ 反射factory http
C++三剑客之std::variant(二)：深入剖析
红军不怕远征难，万水千山只等闲
01-17 2564
本文我们主要研究问题模板类std::variant如何做到存任意多个类型值的容器？不同类型怎么做到巧妙的构造与转换的?多种构造函数如何实现？内部数据怎么储存？为什么不能保存引用、数组和void类型？std::variant是在头文件variant中，是C++17引入的，本文以VS2019平台展开讲解variant的原理和深层次用法。std::negation 逻辑非元函数，一元函数对象类，其调用将返回对其实参求反的结果(由一元操作符-返回)。"");"");int main()
C++14与C++17新特性，你想知道的都在这
扶风的博客
12-25 4981
这篇博文躺在草稿箱里好久了，今天有点时间，整理下发出来 ------------------------------------------C++14篇------------------------------------------ 相对于C++11，C++14的改动可谓非常mini了，主要的改动一句话便是：扩大自动类型推断的应用范围。剩下的都是边边角角的小改动 这包括： 函数返回值自动推...
C#的进化——C#发展史、C#1.0-10.0语法系统性梳理、C#与JAVA的对比
sslyc8991的专栏
01-25 3481
本文将以C#版本为时间线，从C#1.0到C#10.0系统梳理每个版本的语法，并同时就语法机制与Java做出详细的对比。方便读者同时了解两门语言的特点。
《C++ Template》笔记 Chapter 26 Discriminated Unions
MYTCHITOS的博客
12-05 304
文章目录26.1 Storage26.2 Design26.3 Value Query and Extraction26.4 Element Initialization,Assignment and Destruction26.4.1 Initialization26.4.2 Destruction26.4.3 AssignmentSelf-AssignmentExceptionsstd::la...
【C语言】Top K问题【建小堆】
2301_80840905的博客
08-04 391
在我们生活中，经常会遇到TopK问题。建小堆解决
C++ STL copy, move 用法
08-04 170
前向（从前向后的顺序）拷贝/移动操作，将一个容器元素拷贝/移动到另一容器中。
OD C卷 - 中庸行者
weixin_45228198的博客
08-04 179
DFS
c++——map、set底层之AVL树（动图演示旋转）
2301_80687320的博客
08-05 751
我们之前学了过二叉搜索树，二这里的AVL也是一种搜索树，当我们二叉搜索树发生偏移时，搜索时间就会边长，就不树logN了，变成N；而AVL就修复了这一点。一、{}// 该节点的左孩子// 该节点的右孩子// 该节点的双亲T _data;int _bf;// 该节点的平衡因子。
嵌入式初学-C语言-十五
最新发布
MaBaB的博客
08-05 502
函数：实现一定功能的，独立的代码模块，我们的函数一定是先定义后使用使用函数的优势可以通过函数提供功能给别人使用，当然我们也可以使用别人提供的函数，减少代码量借助函数可以减少重复性代码。实现结构化（模块化）程序设计思想结构化程序设计思想：将大型的任务功能，划分为相互独立的小型的任务模块来设计3.函数是c语言程序的基本组成单元：C语言程序是由一个（必然是main函数）或多个函数组成。语法：返回类型 函数名(形参列表) -- 函数头 | 函数首部。
3.C_Demo_最大公约数、最小公倍数
Fresh_man111的博客
08-03 289
假设两个数字a和b，求两个数字相除的余数c=a%b，如果余数为0，则b为最大公约数。如果b不为零，a=b,b=c,继续循环计算。两个数的最小公倍数数等于两个数的乘积除以两个数的最大公约数。即：x，y的最小公倍数 min(公倍数)=x*y÷max(公约数)参数a，b：传入的两个数值，两个数都不能为0。参数a，b：传入的两个数值，不能全为0。返回值：0代表错误，正常返回最大公约数。返回值：0代表错误，正常返回最小公倍数。功能：求a，b最大公约数。功能：求a，b最小公倍数。
string类的模拟实现(C++)
2302_80190394的博客
08-02 1095
C++ string的功能函数实现
【c++】用c++指针传递来模拟“靶向治疗”
weixin_56334307的博客
08-02 688
这个程序通过模拟靶向治疗的过程，展示了C++中指针和数组的基本用法。通过传递数组元素的地址给函数，函数能够直接修改数组中的值，这种机制在C++中非常常见且强大，因为它允许函数对外部数据进行修改。在这个例子中，它用于模拟将癌变细胞治疗为健康细胞的过程。
C++ primer plus 第17 章 输入、输出和文件：使用 cin 进行输入
zhyjhacker的博客
08-05 977
C++ primer plus 第17 章 输入、输出和文件：使用 cin 进行输入。
【C++】类的使用
2401_83733103的博客
08-05 283
我们也可以定义C语言的struct结构体，不过struct会被升级成为类。class 自定义的类名//类的成员//末尾有分号如：class Dateint a;类的成员可以全在类中定义，类中的所有成员都可以无限制的访问彼此。int b;我们可以让类成员函数在类中声明，在类外定义。不过在类外的函数在成员名前加 -> 类名：：。以此确定该函数属于哪个类。class Date。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值