纯净、安全、绿色的下载网站

首页|软件分类|下载排行|最新软件|IT学院

当前位置:首页IT学院IT技术

C++右值引用 详解C++右值引用

可可西   2021-06-07 我要评论
想了解详解C++右值引用的相关内容吗,可可西在本文为您仔细讲解C++右值引用的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:c++,右值引用,下面大家一起来学习吧。

概述

在C++中,常量、变量或表达式一定是左值(lvalue)或右值(rvalue)。

左值:非临时的(具名的,可在多条语句中使用,可以被取地址)。可以出现在等号的左边或右边。可分为非常量左值和常量左值。

右值:临时的(不具名的,只在当前语句中有效,不能取地址)。只能出现在等号的右边。可分为非常量右值和常量右值。

左值引用:对左值的引用就是左值引用。可分为非常量左值引用和常量左值引用。

注:常量左值引用是“万能”的引用类型,可以绑定到所有类型的值,包括非常量左值、常量左值、非常量右值和常量右值。

右值引用(Rvalue References):对右值的引用就是右值引用。可分为非常量右值引用和常量右值引用。

为临时对象的右值,它的生命周期很短暂,一般在执行完当前这条表达式之后,就释放了。

通过将其赋值给右值引用,可以在不进行昂贵的拷贝操作的情况下被“续命”,让其生命周期与右值引用类型变量的生命周期一样长。

右值引用的两个基本特性:移动语义(Move Semantics)和完美转发(Perfect Forwarding)

移动语义(Move Semantics)

可将资源从一个对象转移到另一个对象;主要解决减少不必要的临时对象的创建、拷贝与销毁。

移动构造函数MyClass(Type&& a):当构造函数参数是一个右值时,优先使用移动构造函数而不是拷贝构造函数MyClass(const Type& a)。

移动赋值运算符Type& operator = (Type&& a):当赋值的是一个右值时,优先使用移动赋值而不是拷贝赋值运算符Type& operator = (const Type& a)。

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

struct MyClass
{
    std::string s;
    MyClass(const char* sz) : s(sz) 
    {
        std::cout << "MyClass sz:" << sz << std::endl;
    }
    MyClass(const MyClass& o) : s(o.s) 
    { 
        std::cout << "copy construct!\n"; 
    }

    MyClass(MyClass&& o) noexcept : s(std::move(o.s)) 
    {
        std::cout << "move construct!\n";
    }

    MyClass& operator=(const MyClass& other) { // copy assign
        std::cout << "copy assign!\n";
        s = other.s;
        return *this;
    }
    MyClass& operator=(MyClass&& other) noexcept { // move assign
        std::cout << "move assign!\n";
        s = std::move(other.s);
        return *this;
    }

    static MyClass GetMyClassGo(const char* sz)
    {
        MyClass o(sz); // 注意:可能会被NRVO优化掉
        return o;
    }
};

void func0(MyClass o)
{
    std::cout << o.s.c_str() << std::endl;
}

void func1(MyClass& o)
{
    std::cout << o.s.c_str() << std::endl;
}

void func2(const MyClass& o)
{
    std::cout << o.s.c_str() << std::endl;
}

void func3(MyClass&& o)
{
    std::cout << o.s.c_str() << std::endl;
}

int main(int arg, char* argv[])
{
    MyClass a1("how");
    MyClass a2("are");

    a2 = a1; // copy assign  注:a1是一个左值

    a2 = MyClass("you"); // move assign  注:MyClass("you")是一个右值

    MyClass a3(a1); // copy construct  注:a1是一个左值
    MyClass&& a4 = MyClass::GetMyClassGo("go"); // move construct  注:发生在MyClass::GetMyClassGo()内部
    MyClass a5 = MyClass::GetMyClassGo("china"); // move construct两次  注:一次发生在MyClass::GetMyClassGo()内部;另一次发生在将返回值赋值给a5
    
    MyClass a6("let");
    MyClass a7("it");
    MyClass a8("go");
    MyClass a9("!");

    func0(a6);  // copy construct
    func1(a7);
    func2(a8);
    //func3(a9); // 编译error: 不能把一个左值赋值给右值

    func0(MyClass::GetMyClassGo("god")); // move construct两次  注:一次发生在MyClass::GetMyClassGo()内部;另一次发生在将返回值赋值给foo0参数时
    //func1(MyClass::GetMyClassGo("is")); // 编译error: 不能把一个右值赋值给左值
    func2(MyClass::GetMyClassGo("girl")); // move construct  注:发生在MyClass::GetMyClassGo()内部
    func3(MyClass::GetMyClassGo("!"));  // move construct  注:发生在MyClass::GetMyClassGo()内部

    return 0;
}

注:测试以上代码一定要关闭C++编译器优化技术 -- RVO、NRVO和复制省略

使用std::move来实现移动语义

将一个左值或右值强制转化为右值引用。 注:UE4中对应为MoveTemp模板函数

std::move(en chs)并不会移动任何东西,只是将对象的状态或者所有权从一个对象转移到另一个对象。注:只是转移,没有内存的搬迁或者内存拷贝。

① 基本类型(如:int、double等)被std::move移动后,其数值不会发生变化

② 复合类型被std::move移动后,处于一个未定义,但有效的状态(大部分成员函数仍有意义)例如:标准库中的容器类对象被移动后,会变成空容器

完美转发(Perfect Forwarding)

针对模板函数,使用全能引用将一组参数原封不动的传递给另一个函数。

原封不动指:左值、右值、是否为const均不变。带来如下3方面好处:

① 保证左值、右值的属性

② 避免不必要的拷贝操作

③避免模版函数需要为左值、右值、是否为const的参数来实现不同的重载

全能引用(universal references、转发引用)是一种特殊的模板引用类型,采用右值引用的语法形式(但它并不是右值引用)。如:template <class T> void func(T&& t) {}

T&& t在发生自动类型推断的时候,它是未定的引用类型(universal references),T取决于传入的参数t是右值还是左值。右值经过T&&变为右值引用,而左值经过T&&变为左值引用。

std::move就是使用全能引用实现的。其定义如下:

template <typename T>
typename remove_reference<T>::type&& move(T&& t)
{
    return static_cast<typename remove_reference<T>::type &&>(t);
}


/*****************************************
std::remove_reference功能为去除类型中的引用

std::remove_reference<T &>::type ---> T
std::remove_reference<T &&>::type ---> T
std::remove_reference<T>::type ---> T
******************************************/
//原始的,最通用的版本
template <typename T> struct remove_reference{
    typedef T type;  //定义T的类型别名为type
};
 
//部分版本特例化,将用于左值引用和右值引用
template <class T> struct remove_reference<T&> //左值引用
{ typedef T type; }
 
template <class T> struct remove_reference<T&&> //右值引用
{ typedef T type; }

① 当t为左值时,展开为:U&& move(U& t) 注:右值引用类型变量也是左值

② 当t为右值时,展开为:U&& move(U&& t)

最后,通过static_cast<>进行强制类型转换返回右值引用。注:static_cast之所以能使用类型转换,是通过remove_refrence::type模板移除T&&,T&的引用,获取具体类型T(模板偏特化)。

引用折叠

规律:含左值引用就是左值引用,否则就是右值引用

使用std::forward实现参数的完美转发。其定义如下(en chs):

template <typename T>
T&& forward(remove_reference_t<T>& arg) // forward an lvalue as either an lvalue or an rvalue
{ 
    return static_cast<T&&>(arg);
}

template <typename T>
T&& forward(remove_reference_t<T>&& arg) // forward an rvalue as an rvalue
{ 
    static_assert(!is_lvalue_reference_v<T>, "bad forward call");
    return static_cast<T&&>(arg);
}

最后,通过static_cast<>进行引用折叠,并强制类型转换后,实现原封不动转发参数。 注:UE4中对应为Forward模板函数

void bar(int& a, int&& b)
{
    int c = a + b;
}

void func(int a, int&& b)
{
    int c = a + b;
}

template <typename A, typename B>
void foo(A&& a, B&& b) { // a, b为左值引用或右值引用
    bar(std::forward<A>(a), std::forward<B>(b)); // 在std::forward转发前后,参数a,b的类型完全不变
}

int main(int arg, char* argv[])
{
    int a = 10;

    foo(a, 20); // 展开为void foo(int& a, int&& b),经过std::forward完美转发后,会调用到void bar(int& a, int&& b)函数

    func(std::forward<int>(a), std::forward<int&&>(30)); // 经过std::forward完美转发后,会调用到void func(int a, int&& b)函数

    return 0;
}

相关文章

猜您喜欢

  • java开发工具maven 一文掌握Java开发工具Maven(简单上手)

    想了解一文掌握Java开发工具Maven(简单上手)的相关内容吗,风在哪在本文为您仔细讲解java开发工具maven的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:java开发工具maven,java工具maven,下面大家一起来学习吧。..
  • MySQL id选择合适的数据类型 MySQL为id选择合适的数据类型

    想了解MySQL为id选择合适的数据类型的相关内容吗,岛上码农在本文为您仔细讲解MySQL id选择合适的数据类型的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:MySQL,id,MySQL,id数据类型,下面大家一起来学习吧。..

网友评论

Copyright 2020 www.moon-script.com 【月光下载】 版权所有 软件发布

声明:所有软件和文章来自软件开发商或者作者 如有异议 请与本站联系 点此查看联系方式