C++转移构造函数与转移赋值函数

最新推荐文章于 2023-08-19 07:40:46 发布
最新推荐文章于 2023-08-19 07:40:46 发布
阅读量2.8k 收藏
点赞数
分类专栏： C++语法 文章标签： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010936800/article/details/51550408
版权

C++临时对象的定义：

当且仅当离开一段上下文(context)时在对象上执行的仅有的操作是析构函数时，一个对象被看成是临时的。这里上下文可能是一个表达式，也可能是一个语句范围，例如函数体。

freshXD
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++的右值引用具体用法
01-20
在c++11中，支持右值引用，右值引用的用处之一是移动语义，对象的资源所有权发生转移，在c++11之前，移动语义的缺失是c++饱受诟病的问题之一. 什么是左值？什么是右值？ 凡有名者，皆为左值．左值对应变量的存储位置，右值对应变量的值本身，右值可以被赋值给左值，或者绑定到引用． 右值引用的优点？ 类的右值是一个临时对象，如果没有被绑定到引用，在表达式结束时候，就会废弃，在右值被废弃之前，移走资源进行废物利用． 被移走资源的右值在废弃时已经成为空壳，析构的开销降低． 为临时变量续命，也就是为右值续命，右值在表达式结束后就消亡了，如果想继续使用右值，就会使用昂贵的拷贝构造函数 如果能够直接使用临时
C++智能指针(1).pdf
02-27
C++智能指针 智能指针 智能指针概念 C/C++ 语⾔最为⼈所诟病的特性之⼀就是存在内存泄露问题，因此后来的⼤多数语⾔都提供了内置内存分配与释放功能，有的甚⾄⼲脆对语 ⾔的使⽤者屏蔽了内存指针这⼀概念。这⾥不置贬褒，⼿动分配内存与⼿动释放内存有利也有弊，⾃动分配内存和⾃动释放内存亦如此，这 是两种不同的设计哲学。有⼈认为，内存如此重要的东西怎么能放⼼交给⽤户去管理呢？⽽另外⼀些⼈则认为，内存如此重要的东西怎么能 放⼼交给系统去管理呢？在 C/C++ 语⾔中，内存泄露的问题⼀直困扰着⼴⼤的开发者，因此各类库和⼯具的⼀直在努⼒尝试各种⽅法去检 测和避免内存泄露，如 boost，智能指针技术应运⽽⽣。 智能指针主要⽤于管理在堆上分配的内存，它将普通的指针封装为⼀个栈对象。当栈对象的⽣存周期结束后，会在析构函数中释放掉申请的 内存，从⽽防⽌内存泄漏。简要的说，智能指针利⽤了 C++ 的 RAII 机制，在智能指针对象作⽤域结束后，会⾃动做内存释放的相关操作， 不需要我们再⼿动去操作内存。 RAII是C++的发明者Bjarne Stroustrup提出的概念，RAII全称是"Resource Acquisition is Initialization"，直译过来是"资源获取即初始化"，也 就是说在构造函数中申请分配资源，在析构函数中释放资源。因为C++的语⾔机制保证了，当⼀个对象创建的时候，⾃动调⽤构造函数，当 对象超出作⽤域的时候会⾃动调⽤析构函数。所以，在RAII的指导下，我们应该使⽤类来管理资源，将资源和对象的⽣命周期绑定。 C++ 中有四种智能指针：auto_pt、unique_ptr、shared_ptr、weak_ptr 其中后三个是 C++11 ⽀持，第⼀个已经被 C++11 弃⽤且被 unique_prt 代替，不推荐使⽤。下⽂将对其逐个说明。 std::auto_ptr 在这个年代讨论 std::auto_ptr 不免有点让⼈怀疑是不是有点过时了，确实如此，随着 C++11 标准的出现（最新标准是 C++20），std::auto_ptr 已经被彻底放弃，取⽽代之是 std::unique_ptr。然⽽，之所以还向介绍⼀下 std::auto_ptr 的⽤法以及它的设计不⾜ 之处是想更多了解 C++ 语⾔中智能指针的发展过程，⼀项技术如果我们了解它过去的样⼦和发展的轨迹，我们就能更好地掌握它。 std::auto_ptr 的基本⽤法如下代码所⽰： #include <iostream> #include <memory> using namespace std; int main() { //初始化⽅式1 std::auto_ptr<int> ap1(new int(8)); //初始化⽅式2 std::auto_ptr<int> ap2; ap2.reset(new int(8)); cout << *ap1 << ", " << *ap2 << endl; return 0; } 输出： 8, 8 智能指针对象 ap1 和 ap2 均持有⼀个在堆上分配 int 对象，其值均是 8，这两块堆内存均可以在 ap1 和 ap2 释放时得到释放。这是 std::auto_ptr 的基本⽤法。 std::auto_ptr 真正让⼈容易误⽤的地⽅是其不常⽤的复制语义，即当复制⼀个 std::auto_ptr 对象时（拷贝复制或 operator= 复制），原对象 所持有的堆内存对象也会转移给复制出来的对象。⽰例代码如下： #include <memory> int main() { //测试拷贝构造 std::auto_ptr<int> ap1(new int(8)); std::auto_ptr<int> ap2(ap1); if (ap1.get() != NULL) { std::cout << "ap1 is not empty." << std::endl; } else { std::cout << "ap1 is empty." << std::endl; } if (ap2.get() != NULL) { std::cout << "ap2 is not empty." << std::endl; } else { std::cout << "ap2 is empty." << std::endl; } //测试赋值构造 std::auto_ptr<int> ap3(new int(8)); std::auto_ptr<int> ap4; ap4 = ap3; if (ap3.get() != NULL) { std::cout << "ap3 is not empty." << std::endl; }
C++智能指针的原理和实现.pdf
02-27
C++智能指针的原理和实现 智能指针的原理和实现 ⼀、智能指针起因 ⼀、智能指针起因 　　在C++中，动态内存的管理是由程序员⾃⼰申请和释放的，⽤⼀对运算符完成：new和delete。 　　new：在动态内存中为对象分配⼀块空间并返回⼀个指向该对象的指针； 　　delete：指向⼀个动态独享的指针，销毁对象，并释放与之关联的内存。 　　使⽤堆内存是⾮常频繁的操作，容易造成堆内存泄露、⼆次释放等问题，为了更加容易和更加安全的使⽤动态内存，C++11中引⼊了智 能指针的概念，⽅便管理堆内存，使得⾃动、异常安全的对象⽣存期管理可⾏。智能指针主要思想是RAII思想，"使⽤对象管理资源"，在类 的构造函数中获取资源，在类的析构函数中释放资源。智能指针的⾏为类似常规指针，重要的区别是它负责⾃动释放所指向的对象。 　　RAII是Resource Acquisition Is Initialization的简称，即资源获取就是初始化： 　　1.定义⼀个类来封装资源的分配与释放； 　　2.构造函数中完成资源的分配及初始化； 　　3.析构函数中完成资源的清理，可以保证资源的正确初始化和释放； 　　4.如果对象是⽤声明的⽅式在栈上创建局部对象，那么RAII机制就会正常⼯作，当离开作⽤域对象会⾃动销毁⽽调⽤析构函数释放资 源。 ⼆、智能指针类型 ⼆、智能指针类型 　　智能指针在C++11版本之后提供，包含在头⽂件<memory>中，标准命名std空间下，有auto_ptr、shared_ptr、weak_ptr、unique_ptr四 种，其中auto_ptr已被弃⽤。 　　：拥有严格对象所有权语义的智能指针； 　　：拥有共享对象所有权语义的智能指针； 　　：到 shared_ptr 所管理对象的弱引⽤； 　　：拥有独有对象所有权语义的智能指针。 2.1 auto_ptr 　　auto_ptr是通过由 new 表达式获得的对象，并在auto_ptr⾃⾝被销毁时删除该对象的智能指针，它可⽤于为动态分配的对象提供异常安 全、传递动态分配对象的所有权给函数和从函数返回动态分配的对象，是⼀个轻量级的智能指针，适合⽤来管理⽣命周期⽐较短或者不会被 远距离传递的动态对象，最好是局限于某个函数内部或者是某个类的内部。 　　声明： 　　template< class T > class auto_ptr; 　　template<> class auto_ptr<void>; // 对类型void特化　　 　　成员函数： 　　(1) ： 获得内部对象的指针； 　　(2) ：释放被管理对象的所有权，将内部指针置为空，返回内部对象的指针，此指针需要⼿动释放； 　　(3) ：销毁内部对象并接受新的对象的所有权； 　　(4) ：从另⼀auto_ptr转移所有权； 　　(5) 和：访问被管理对象。 　　注意事项： 　　(1) 其构造函数被声明为explicit，因此不能使⽤赋值运算符对其赋值，即不能使⽤类似这样的形式 auto_ptr<int> p = new int； 　　(2) auto_ptr 的对象所有权是独占性的，使⽤拷贝构造和赋值操作符时，会造成对象所有权的转移，被拷贝对象在拷贝过程中被修改； 　　(3) 基于第⼆条，因此不能将auto_ptr放⼊到标准容器中或作为容器的成员； 　　(4) auto_ptr不能指向数组，释放时⽆法确定是数组指针还是普通指针； 　　(5) 不能把⼀个原⽣指针交给两个智能指针对象管理，对其它智能指针也是如此。 　　auto_ptr是最早期的智能指针，在C++11 中已被弃⽤，C++17 中移除，建议使⽤unique_ptr代替auto_ptr。 　　简单实现： 1 template<class T> 2 class AutoPointer 3 { 4 public: 5 AutoPointer(T* ptr) 6 :mPointer(ptr){} 7 8 AutoPointer(AutoPointer<T>& other) 9 { 10 mPointer= other.mPointer; //管理权进⾏转移 11 other.mPointer= NULL; 12 } 13 14 AutoPointer& operator = (AutoPointer<T>& other) 15 { 16 if(this != &other) 17 { 18 delete mPointer; 19 mPointer = other.mPointer; //管理权进⾏转移 20 other.mPointer= NULL; 21 } 22 23 return *this; 24 } 25 26 ~AutoPointer() 27 { 28 delete mP
C++智能指针：auto-ptr详解.pdf
02-27
C++智能指针：auto_ptr详解 指针，相信⼤家并不陌⽣。⽆论是我们在进⾏查看内存还是在修改字符串，我们都会⽤到指针。 最常见的情况则是我们使⽤malloc或者new申请到了⼀块内存，然后⽤⼀个指针来保存起来。我们都知道有内存的申请那就必须要对它进⾏ 释放的处理，否则会造成最严重的后果——内存泄漏。⼀个或者两个申请的内存我们或许不会忘记去释放，但是如果成千上万⾏代码，你还 能记得住哪个释放了哪个没有释放吗？ ⽽智能指针就是为了解决这个问题⽽产⽣的。最开始智能指针是在boost库中的，随着时间发展现在已经成为了C11的特性。（虽然我们本 篇要介绍的最基础的auto_ptr在C++11中已经被unique_ptr替代了。。） 智能指针的基本原理 智能指针其实是⼀个类，可以通过将普通指针作为参数传⼊智能指针的构造函数实现绑定。只不过通过运算符重载让它"假装"是⼀个指 针，也可以进⾏解引⽤等操作。既然智能指针是⼀个类，对象都存在于栈上，那么创建出来的对象在出作⽤域的时候(函数或者程序结束)会 ⾃⼰消亡，所以在这个类中的析构函数中写上delete就可以完成智能的内存回收。 Auto_ptr详解 使⽤时，需要包含头⽂件：memory。 auto_ptr，作为智能指针的始祖，能基本实现我们所期望的功能。⽽且设计简单源码易懂，虽然缺陷众多，但作为了解智能指针的研究对象 还是⼗分合适的。 ⾸先我们先来写⼀个测试类⽤于分析。 #include <iostream> #include <memory> using namespace std; class Test { public: Test(int param = 0) //调⽤时，可以指定是第⼏个对象。默认第0个 { num = param; cout << "Simple:" << num << endl; } ~Test() //析构时会指出第⼏个对象被析构。 { cout << "~Simple:" << num << endl; } void PrintSomething() //输出附加的字符串⽅法。 { cout << "PrintSomething:" << info_extend.c_str() << endl; } int num; //代表这个对象的序号。 string info_extend; //附加的字符串。 }; 接下来，我们通过⼏个测试函数来实验⼀下auto_ptr的基本功能，再来了解⼀下它的弊端。 I.Auto_ptr的基本功能 的基本功能 void TestAutoPtr1() { auto_ptr<Test> my_auto (new Test(1)); //绑定⼀个Test类的新建对象 if(my_auto.get()) //get函数⽤来显式返回它拥有的对象指针，此处判⾮空 { my_auto->PrintSomething(); my_auto.get()->info_extend = "Addition"; //对类内成员进⾏操作 my_auto->PrintSomething(); //看是否成功操作 (*my_auto).info_extend += " other"; //实验解引⽤操作 mt_auto->PrintSomething(); } } 运⾏结果： 我们可以看到在绑定时输出Simple：1，之后也能正常实现Test类中的功能，同时my_auto可以通过get⽅法进⾏裸指针赋值以及使⽤*进⾏ 解引⽤操作，与普通指针⽆异。最后函数结束后，在调⽤析构函数的同时auto_ptr的析构函数也将Test类的对象delete掉，我加⼊的内存泄 漏探测⼯具也显⽰No memory leaks detected(没有检查测到内存泄漏). II.Auto_ptr的弊端 的弊端1 void TestAutoPtr2() { auto_ptr<Test> my_auto1 (new Test(1)); if(my_auto1.get()) { (*my_auto1).info_extend = "Test"; //先赋予⼀个初始值作为区别两个指针的标志 auto_ptr<Test> my_auto2; my_auto2 = my_auto1; my_auto2->PrintSomething(); //打印发现成功转移 my_auto1->PringSomething(); //崩溃 } } 在这个程序的最后⼀步会崩溃，罪魁祸⾸就是my_auto2 = my_auto1语句。 autp_ptr对赋值运算符重载的实现是reset(Myptr.release())，即reset和release函数的组合。release会释放所有权，reset则是⽤于接受
【C++】移动构造函数
m0_61629312的博客
08-15 491
移动构造函数是一个特殊的构造函数，用于从一个对象中移动（转移）资源到另一个对象，而不是进行复制操作。它通常与右值引用一起使用，以实现高效的资源转移，提高性能。
C++ 移动构造函数详解
a只如初见的博客
08-12 2万+
1、移动构造是C++11标准中提供的一种新的构造方法2、移动构造接管源对象，既不会产生额外的拷贝开销，也不会给新对象分配内存空间。提高程序的执行效率，节省内存消耗。3、移动构造函数的第一个参数必须是自身类型的右值引用...
c++ return * this的理解
10-31 3945
C++ return * this的理解 在c++代码中自定义操作符的时候，例如前置++, = 赋值操作的时候会返回*this。this是类自带的指针，指代的是对象本身。*this对指针解引用，因此使用*this返回的就是一个对象本身。这样的操作可以满足连续的= (赋值操作)。试想一下如果返回的是this,那么返回的是指针。 #include <iostream> using namespace std; class Test { public: int m_i; doubl
【C++11保姆级教程】移动构造函数（move constructor）和移动赋值操作符（move assignment operator）
最新发布
m0_62599305的博客
08-19 6751
在C++11标准中引入了移动语义的概念，通过移动构造函数和移动赋值操作符，我们可以更高效地管理对象的资源。本文将以通俗易懂的方式详细解释移动构造函数和移动赋值操作符的概念，并通过生动的比喻帮助读者更好地理解这两个概念。当我们需要在C++中处理大量数据或动态分配的对象时，移动构造函数和移动赋值操作符成为了重要的工具。它们是C++11引入的特性，旨在提高程序的性能和效率。
return *this和return this区别
qingtu11的博客
06-10 459
别跟我说， return *this返回当前对象， return this返回当前对象的地址（指向当前对象的指针）。 正确答案为：return *this返回的是当前对象的克隆或者本身（若返回类型为A， 则是克隆， 若返回类型为A&， 则是本身 ）。return this返回当前对象的地址（指向当前对象的指针）, 下面我们来看看程序吧： #include <iostream> using namespace std; class A { public: int x; .
C++之移动构造函数
bin_bujiangjiu的博客
11-28 2394
C++ 移动构造函数
[Visual.C++.2010入门经典(第5版)].Ivor.Horton.part1
04-26
8.1.3 析构函数与动态内存分配 366 8.2 实现复制构造函数 369 8.3 在变量之间共享内存 370 8.3.1 定义联合 371 8.3.2 匿名联合 372 8.3.3 类和结构中的联合 372 8.4 运算符重载 373 …… 第9章 类继承和虚函数 第10...
移动构造-C++11
沐埜专栏
09-28 2万+
移动构造： 移动构造是C++11标准中提供的一种新的构造方法。 在现实中有很多这样的例子，我们将钱从一个账号转移到另一个账号，将手机SIM卡转移到另一台手机，将文件从一个位置剪切到另一个位置……     移动构造可以减少不必要的复制，带来性能上的提升。 有些复制构造是必要的，我们确实需要另外一个副本；而有些复制构造是不必要的，我们可能只是希望这个对象换个地方，移动一下而已。 在C++11
c++右值引用之转移构造函数
weixin_42579072的博客
05-19 2572
右值引用是用来支持转移语义的。转移语义可以将资源 ( 堆，系统对象等 ) 从一个对象转移到另一个对象，这样能够减少不必要的临时对象的创建、拷贝以及销毁，能够大幅度提高 C++ 应用程序的性能。临时对象的维护 ( 创建和销毁 ) 对性能有严重影响。 这里有c++之左值引用和右值引用 在现有的 C++ 机制中，我们可以定义拷贝构造函数和赋值函数。要实现转移语义，需要定义转移构造函数，还可以定义转移赋值操作符。对于右值的拷贝和赋值会调用转移构造函数和转移赋值操作符。如果转移构造函数和转移拷贝操作符没有定义，那么就
泛型：转移构造函数
merced1976的专栏
07-09 2786
泛型：转移构造函数 Andrei Alexandrescu     我想你们知道得很清楚，创建，拷贝，并摧毁临时对象是你的C++编译器爱做的事，临时对象在内部被创建，不幸的是这极大影响到了C++程序的执行效率。实际上，临时对象是C++程序中最大的影响效率因素。     这样的代码看上去不错：   vector ReadFile(); vector vec = ReadFile();   或：  
C++(11)：移动构造函数
风静如云的博客
04-13 2568
对象a1，a2，a3会各自分配自己的m_i指向各自的内存，对于像a1和a2这样的临时对象，不仅仅需要构造他们，还需要为他们分配和释放内存，而内存的意义就是为了让后续的对象拷贝构造，这对于分配了大量内存的对象来说，是非常低效的。对象a2是调用拷贝构造函数，复制a1构造的，a2与a1的m_i拥有各自的内存地址，地址里的数值都是1。对象a3是调用拷贝构造函数，复制a2构造的，a3与a2的m_i拥有各自的内存地址，地址里的数值都是1。，即：当一个对象的构造是基于另一个临时匿名对象时，才能触发。
C++ 转换构造函数
weixin_45743799的博客
03-19 3290
在 C/C++ 中，不同的数据类型之间可以相互转换。无需用户指明如何转换的称为自动类型转换（隐式类型转换），需要用户显式地指明如何转换的称为强制类型转换。 自动类型转换示例： int a = 6; a = 7.5 + a; 编译器对 7.5 是作为 double 类型处理的，在求解表达式时，先将 a 转换为 double 类型，然后与 7.5 相加，得到和为 13.5。在向整型变量 a 赋值时，...
c++中return this和return *this的区别
Warms的博客
09-18 587
this是指向自身对象的指针，*this是自身对象。 也就是说return *this返回的是当前对象的克隆或者本身（若返回类型为A， 则是克隆， 若返回类型为A&， 则是本身 ）。 return this返回当前对象的地址（指向当前对象的指针） 下面代码写在CPerson类中 CPerson* getCperson() { cout<<"返回指向当前对象的指针: "&...
Exceptional C++ Item46：转交函数（forwarding function）
竹影映泉的博客
04-25 796
1.转交函数：对于将任务传递给其他函数或对象时很有用，尤其当转交函数被设计的很高效时。那么问题来了，如何设计高效的转交函数呢？2. 如何设计高效的转交函数有转交函数如下：bool f(X x) { return g(x); }改进一：传参时使用传const的引用代替原值（总被采用）：编译器能确保参数x除了传递给g()外没有被其他地方使用，编译器可以使x完全优化掉。例如：X my_x; f(my_...
今天看到的一个有趣面试题：return *this和return this有什么区别？
热门推荐
认知 行动 坚持
03-26 4万+
别跟我说， return *this返回当前对象， return this返回当前对象的地址（指向当前对象的指针）。 正确答案为：return *this返回的是当前对象的克隆或者本身（若返回类型为A， 则是克隆， 若返回类型为A&， 则是本身 ）。return this返回当前对象的地址（指向当前对象的指针）, 下面我们来看看程序吧： #include using namespace std; class A { public: int x; A
c++移动构造函数详解
05-24
移动构造函数是C++11引入的一个新特性，通过移动构造函数，可以将一个对象的资源所有权转移到另一个对象，避免了不必要的资源拷贝，提高了程序的运行效率。 移动构造函数的定义如下： ```cpp class ClassA { public: ClassA(ClassA&& other) noexcept { // 移动构造函数的实现 } }; ``` 其中，`ClassA&&`表示移动构造函数的参数为右值引用。移动构造函数通常使用`noexcept`关键字进行修饰，表示该函数不会抛出异常。 移动构造函数的实现需要将另一个对象的资源转移到当前对象，并将另一个对象的资源置为无效。常见的实现方式是通过移动构造函数中的`std::move()`函数来完成。例如，对于一个包含动态分配内存的类： ```cpp class MyClass { public: MyClass(int n) : data(new int[n]), size(n) {} MyClass(MyClass&& other) noexcept : data(other.data), size(other.size) { other.data = nullptr; other.size = 0; } ~MyClass() { delete[] data; } private: int* data; int size; }; ``` 在移动构造函数中，将另一个对象的指针和大小赋值给当前对象，并将另一个对象的指针置为nullptr，大小置为0，表示另一个对象的资源已经被移动到了当前对象。 使用移动构造函数可以大大提高程序的性能，特别是在涉及到大量的资源拷贝时。移动构造函数可以通过`std::move()`函数进行调用，例如： ```cpp MyClass a(10); MyClass b(std::move(a)); // 调用移动构造函数 ``` 在这个例子中，对象a的资源被移动到了对象b中，对象a的资源已经无效了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值