【C++11】移动语义，完美转发

最新推荐文章于 2023-12-13 02:03:09 发布
最新推荐文章于 2023-12-13 02:03:09 发布
阅读量411 收藏 1
点赞数 1
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_71138261/article/details/131554407
版权

1.移动语义

1.为什么要有移动语义？

C++中有拷贝构造函数和拷贝复制运算符，但是这需要占用一定的空间


class MyClass
{
public:
    MyClass(const std::string& s)
        : str{ s }
    {};
    MyClass(const MyClass& m)
    {
        str=m.str;
    }

private:
    std::string str;
};

int main()
{
    MyClass A{ "hello" };
    MyClass B=A; 
    return 0;
}

这个代码非常的简单就是A对象中有存储字符串hello\0,把A拷贝复制给B,此时会调用拷贝构造函数

但是来看下面的例子

class MyClass
{
public:
    MyClass(const std::string& s)
        : str{ s }
    {};

private:
    std::string str;
};
int main()
{
 std::vector<MyClass> myClasses;
 MyClass tmp{ "hello" };
 myClasses.push_back(tmp);
 myClasses.push_back(tmp);
 return 0;
}

在这个例子中，我们创建了一个容器以及一个MyClass对象tmp，我们将tmp对象添加到容器中2次每次添加时，都会发生一次拷贝操作,但是既然tmp在两次拷贝构造之后就要销毁，那第二次拷贝构函数这个操作是不是有点冗余，要是能有一个函数可以把tmp对象的数据拷贝，但不需要执行拷贝构造函数就好了

2.移动语义

所谓移动语义，就像其字面意思一样，即把数据从一个对象中转移到另一个对象中，从而避免拷贝操作所带来的性能损耗

我们回到上文的例子，对于myClasses容器的第一次push_back，我们期望执行的是拷贝操作，而对于myClasses容器的第二次push_back，由于之后我们不再需要tmp对象了，因此我们期望执行的是移动操作

对于容器的push_back函数来说，它一定针对拷贝操作和移动操作有不同的重载实现，而重载用到的即是左值引用与右值引用。伪代码如下：

   class vector
    {
    public:
        void push_back(const MyClass& value)  // const MyClass& 左值引用
        {
            // 执行拷贝操作
        }

        void push_back(MyClass&& value)  // MyClass&& 右值引用
        {
            // 执行移动操作
        }
    };

std::vector真正做的，是委托具体类型自己去执行拷贝操作与移动操作

class MyClass
    {
    public:
        MyClass(const std::string& s) //拷贝构造
            : str{ s }
        {};
        MyClass(MyClass&& rvalue) //移动构造
            :str{ std::move(rvalue.str) }
        {}

    private:
        std::string str;
    };

3.移动构造

在移动构造函数中，我们要做的就是转移成员数据。我们的MyClass有一个std::string类型的成员，该类型自身实现了移动语义，因此我们可以继续调用std::string类型的移动构造函数

 在有了移动构造函数之后，我们就可以在需要时通过它来创建新的对象，从而避免拷贝操作的开销 

int main()
{
  std::vector<wrt::MyClass> myClasses;
  wrt::MyClass tmp{ "hello" };
  myClasses.push_back({ std::move(tmp) }); //调用移动构造
  return 0;
}

还记得移动语义的精髓嘛？数据拿过来用就完事儿了。因此，在移动构造函数中，我们将传入对象A的数据转移给新创建的对象B。同时，还需要关注的重点在于，我们需要把传入对象A的数据清除，不然就会产生多个对象共享同一份数据的问题 

class MyClass
{
public:
    MyClass()
        : val{ 998 }
    {
        name = new char[] { "Peter" };
    }

    // 实现移动构造函数
    MyClass(MyClass&& rValue) noexcept
        : val{ std::move(rValue.val) }  // 转移数据
    {
        rValue.val = 0;  // 清除被转移对象的数据

        name = rValue.name;  // 转移数据
        rValue.name = nullptr;  // 清除被转移对象的数据
    }

    ~MyClass()
    {
        if (nullptr != name)
        {
            delete[] name;
            name = nullptr;
        }
    }

private:
    int val;
    char* name;
};
int main()
{
MyClass A{};
MyClass B{ std::move(A) };  // 通过移动构造函数创建新对象B
return 0;
}

4.移动赋值运算符

与拷贝构造函数和拷贝赋值运算符一样，除了移动构造函数之外，C++11还引入了移动赋值运算符。移动赋值运算符也是接收右值引用，它的实现和移动构造函数基本一致。在移动赋值运算符中，我们也是从传入的对象中转移数据，并将该对象的数据清除：

class MyClass
{
public:
    MyClass()
        : val{ 998 }
    {
        name = new char[] { "Peter" };
    }

    MyClass(MyClass&& rValue) noexcept
        : val{ std::move(rValue.val) }
    {
        rValue.val = 0;

        name = rValue.name;
        rValue.name = nullptr;
    }

    // 移动赋值运算符
    MyClass& operator=(MyClass&& myClass) noexcept
    {
        val = myClass.val;
        myClass.val = 0;  //数据清空

        name = myClass.name;
        myClass.name = nullptr; //数据置空

        return *this;
    }

    ~MyClass()
    {
        if (nullptr != name)
        {
            delete[] name;
            name = nullptr;
        }
    }

private:
    int val;
    char* name;
};
int main()
{
    MyClass A{};
    MyClass B{};
    B = std::move(A);  // 使用移动赋值运算符将对象A赋值给对象B
    return 0;
}

5. 移动构造函数和移动赋值运算符的生成规则

—— 定义一个空类，C++98中是默认生产四个函数：构造 析构 拷贝构造 拷贝赋值运算符函数

但是C++11中，我们写一个空类，会默认生成6个函数：原先的四个+移动构造+移动赋值运算符函数

 ——如果在类中定义了拷贝构造函数或者拷贝赋值运算符或者析构函数，那么编译器就不会自动生成移动构造函数和移动赋值运算符。此时，如果调用移动语义的话，由于编译器没有自动生成，因此会转而执行拷贝操作

——析构函数有一点值得注意，许多情况下，当一个类需要作为基类时，都需要声明一个virtual析构函数，此时需要特别留意是不是应该手动的为该类定义移动构造函数以及移动赋值运算符（没有定义的话会默认调用拷贝操作）此外，当子类派生时，如果子类没有实现自己的析构函数，那么将不会影响移动构造函数以及移动赋值运算符的自动生成： 

class MyClass
{
public:
    MyClass()
    {}

    // 我们定义了拷贝构造函数，这会禁止编译器自动生成移动构造函数和移动赋值运算符
    MyClass(const MyClass& value)
    {}
};

int main()
{
    MyClass A{};
    MyClass B{ std::move(A) };  // 执行的是拷贝构造函数来创建对象B
    return 0;
}

——如果我们在类中定义了移动构造函数，那么编译器就不会为我们自动生成移动赋值运算符。反之，如果我们在类中定义了移动赋值运算符，那么编译器也不会为我们自动生成移动构造函数

以移动构造函数为例，如果定义移动构造函数，编译器不会自动生成移动赋值运算符，此时，移动赋值运算符的调用并不会转而执行拷贝赋值运算符，而是会产生编译错误：

class MyClass
{
public:
    MyClass()
    {}

    // 我们定义了移动构造函数，这会禁止编译器自动生成移动赋值运算符，并且对移动赋值运算符的调用会产生编译错误
    MyClass(MyClass&& rValue) noexcept
    {}
};
int main()
{
    MyClass A{};
    MyClass B{};
    B = std::move(A);  // 对移动赋值运算符的调用产生编译错误：attempting to reference a deleted function
    return 0;
}

6noexcept

其实刚才在实现移动构造函数的时候 还有看string中支持的移动构造函数都有一个关键字noexcept

首先介绍一个概念 "强异常保证（strong exception guarantee）"

所谓强异常保证，即当我们调用一个函数时，如果发生了异常，那么应用程序的状态能够回到函数调用之前

如果学习过C++异常处理的小伙伴一看这个关键字就非常熟悉，他的意思在这里就是不会抛出异常的移动构造函数

拷贝构造函数是会分配内存，因此很可能会抛出异常，但是移动构造是更改数据的所有权，所以一般不会抛异常

先来看一个没有noexcept的拷贝构造函数 

class MyClass
{
public:
    MyClass(int x)
        :_x(x)
    {}
    MyClass(const MyClass& lvalue) //拷贝构造函数
    {
        cout << "MyClass(const MyClass& lvalue" << endl;
        _x = lvalue._x;
        throw runtime_error("copy exception");
    }
    // 我们定义了移动构造函数，这会禁止编译器自动生成移动赋值运算符，并且对移动赋值运算符的调用会产生编译错误
    MyClass(MyClass&& rValue) noexcept
        :_x(std::move(rValue._x))
    {
        rValue._x = 0;
        cout << " MyClass(MyClass&& rValue) noexcept" << endl;
    }
    ~MyClass()
    {
        cout << "~MyClass()" << endl;
    }
 private:
     int _x;
};
int main()
{
    try
    {
        MyClass A{ 1 };
        MyClass B{A};

        //MyClass B{ std::move(A) };
    }
    catch(runtime_error e)
    {
        cout << "Catch!!!" <<e.what()<< endl;
    }
    return 0;
}

再来看移动拷贝里面抛异常的情况


class MyClass
{
public:
    MyClass(int x)
        :_x(x)
    {}
    MyClass(const MyClass& lvalue) //拷贝构造函数
    {
        cout << "MyClass(const MyClass& lvalue" << endl;
        _x = lvalue._x;
        throw runtime_error("copy exception");
    }
    // 我们定义了移动构造函数，这会禁止编译器自动生成移动赋值运算符，并且对移动赋值运算符的调用会产生编译错误
    MyClass(MyClass&& rValue) noexcept
        :_x(std::move(rValue._x))
    {
        rValue._x = 0;
        cout << " MyClass(MyClass&& rValue) noexcept" << endl;
        throw runtime_error("copy exception");

    }
    ~MyClass()
    {
        cout << "~MyClass()" << endl;
    }
 private:
     int _x;
};
int main()
{
    try
    {
        MyClass A{ 1 };
        MyClass B{ std::move(A) };
    }
    catch(runtime_error e)
    {
        cout << "Catch!!!" <<e.what()<< endl;
    }
    return 0;
}

但是如果你在声明了noexcept的移动构造函数中抛异常，此时会直接报错，并不会捕捉异常 

2.完美转发 

模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，
但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，
我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发 

void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }

template<typename T>
void PerfectForward(T&& t)
{
	Fun(t);
}
int main()
{
	PerfectForward(10);  // 右值
	int a;
	PerfectForward(a);  // 左值
	PerfectForward(std::move(a)); // 右值
	const int b = 8;
	PerfectForward(b);  //const 左值
	PerfectForward(std::move(b)); // const 右值
	return 0;
}

 

 std::forward 完美转发在传参的过程中保留对象原生类型属性

void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }
// std::forward<T>(t)在传参的过程中保持了t的原生类型属性。
template<typename T>
void PerfectForward(T&& t)
{
	Fun(std::forward<T>(t));   //完美转发
}
int main()
{
		PerfectForward(10);  // 右值
	int a;
	PerfectForward(a);  // 左值
	PerfectForward(std::move(a)); // 右值
	const int b = 8;
	PerfectForward(b);  //const 左值
	PerfectForward(std::move(b)); // const 右值
	return 0;
}

 

 

咸菜不闲
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
深入理解C++中的移动语义及其用法
禅与计算机程序设计艺术
08-04 1144
C++语言作为目前世界上应用最广泛的高级编程语言之一，具有着极高的运行效率和跨平台能力。然而，对一些内存管理的细节和机制不够理解，也可能导致一些内存泄漏或其他错误。因此，在学习C++的过程中，我们需要对C++中关于内存管理的一些细节和机制有所了解。其中“移动语义”是一个非常重要的概念，它使得程序员能够充分利用现代计算机硬件的性能优势，并有效地减少内存分配和释放的开销。本文将从如下几个方面深入探讨C++中的“移动语义”，包括它的基本概念、优点和缺陷、使用方法、具体实现等。
【C++11】三大神器之——右值、移动语义、完美转发
ZER00000001的博客
12-14 880
如果你还不知道 C++ 11 引入的右值引用是什么，可以读读这篇文章，看看有什么 启发；如果你已经对右值引用了如指掌，也可以读读这篇文章，看看有什么 补充。欢迎交流~
【移动语义和完美转发】
wangjie112358的博客
06-15 2196
移动语义和完美转发
【C++】移动语义与完美转发
weixin_46778443的博客
04-30 1940
移动语义与完美转发
C++ 移动语义（通用引用，完美转发的终极理解）
让代码改变世界
07-09 273
您既然说了引用的引用还是引用，而每种引用都有左值引用和右值引用的区分，这排列组合。为通用引用形式，编译器要根据用户传入的参数类型来实例化，如果用户传入的是左值，那a被实例化为左值引用，如果用户传入的是右值，那a被时候成右值引用。标准：刚不说了嘛，只有a是左值引用的时候，T才是int&，所以a肯定也是int&，也就是说int& &&=int&，引用的引用还是引用，这听着多么丝滑啊~行吧，那我给你提供个方式，让你能把一个普通的变量转成临时变量，额，不对，这不能叫临时变量了，算了，重新起个名字吧，我看看叫啥呢。
C++11 中的移动语义和完美转发
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
04-06 631
左值、纯右值和将亡值、左值引用和右值引用、移动构造函数与移动语义、std::move 和 std::forward
浅析C++11中的右值引用、转移语义和完美转发
09-01
C++11是一个重要的语言版本，它引入了许多新特性，其中右值引用、移动语义和完美转发是提升效率和代码质量的关键元素。本文将详细解释这三个概念。 首先，我们来了解一下左值与右值的概念。左值（lvalue）是指可以...
深入了解c++11 移动语义与右值引用
12-17
此外，C++11还引入了“完美转发”（perfect forwarding）的概念，这使得函数模板可以传递任何类型的参数，包括左值和右值，同时保持参数的原始性质。这进一步增强了移动语义的灵活性和泛用性。 总的来说，C++11的...
右值引用、移动语义和完美转发1
08-08
在C++编程语言中，右值引用和移动语义是C++11标准引入的重要特性，它们极大地提升了程序性能，特别是在处理临时对象和资源管理时。本文将详细探讨这两个概念，以及它们如何与左值引用和左值、右值相互作用。 首先，...
C++11右值引用和转发型引用教程详解
08-27
C++11标准引入了右值引用（rvalue reference）和转发型引用（forwarding reference），解决了移动语义和完美转发问题。本教程将详细介绍右值引用和转发型引用的概念、类型、语法、用法和应用场景。 一、右值引用...
C++11标准文档英文版
03-10
右值引用允许我们创建临时对象的引用，这对于实现移动语义和完美转发至关重要。这些特性显著提高了资源管理的效率，如智能指针（std::unique_ptr, std::shared_ptr）和容器的移动构造函数。 3. **lambda表达式** ...
C++移动语义和完美转发
weixin_42520189的博客
07-07 368
理解移动语义和完美转发的概念
c++11右值引用、移动语义和完美转发
tonny的博客
05-11 1054
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 前言 希望通过本篇文章能让你了c++右值引用的目的，以及其和移动语义、完美转发的联系及用法！ 一、右值引用 1.左值和右值 到底什么时候是左值？什么时候是右值？是不是有点混乱？ 在 C++ 中，每个表达式（expression）都有两个特性： has identity? —— 是否有唯一标识，比如地址、指针。有唯一标识的表达式在 C++ 中被称为glvalue（generalized lvalue）（广义左值）。 can be m.
移动语义和完美转发
f593256的博客
11-20 149
完美转发是 C++11 引入的一个重要特性，它允许在模板中精确地保持函数参数的值类别（左值还是右值），并将它们传递到其他函数。完美转发通常用于实现泛型代码，特别是在编写通用函数模板时非常有用。完美转发的核心在于使用通用引用（Universal Reference）和引用折叠。通用引用的语法是T&&，其中T是模板参数。引用折叠是指在模板类型推导或类型声明的过程中，两个引用（无论是左值引用还是右值引用）可能折叠成一个引用。// 用于演示的一个简单处理函数// 完美转发函数模板。
C++之完美转发、移动语义（forward、move函数）
weixin_65743593的博客
02-10 3522
C++之完美转发、移动语义（forward、move函数）
C++的移动语义和完美转发
最新发布
m0_51415606的博客
12-13 1142
std::move()内部是用static_cast做类型转换，只不过它是使用模板实现的函数，因此会根据传参类型自动推导返回值类型，省去了指定类型的代码。
【C++11】万能引用与完美转发
m0_70980326的博客
09-26 540
万能引用与完美转发
C++11：右值引用，实现移动语义和完美转发
bigger_belief的博客
06-05 730
介绍了右值引用，移动语义和完美转发的含义，以及右值引用如何实现移动语义和完美转发。
c 完美转发和移动语义
07-08
完美转发（perfect forwarding）和移动语义（move semantics）是C++中的两个重要概念。 完美转发是指在函数模板中将参数按原样转发给另一个函数，保留参数的值类别（lvalue、rvalue或xvalue）。这在实现通用代码时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值