第 13 章 拷贝控制
1.拷贝,赋值与销毁
对初学c++的程序员来说,必须定义对象拷贝,移动,赋值或销毁时做什么
<1.拷贝
<<1.
拷贝构造函数:如果一个构造函数的参数是本身的引用,且其他的参数都有默认值,此构造函数是拷贝构造函数。
合成拷贝构造函数:在我们没有为类定义时,编译器会帮我们定义一个。编译器从给定对象中一次将每个非static成员拷贝到正在创建的对象中
例子:
#include <iostream> #include <string> using namespace std; class A { friend std::ostream& print(std::ostream &os, A &a); public: A() = default; A(int a,string b):i(a),s(b) { c++; } private: int i; string s; static int c; //所有类的对象都能访问,只能在类外初始化 //const static int c = 10; //const int 可以在类内初始化 //const static double c = 10.1; //error:初始化只能在类外初始化, 在类外加上const double A::c = 10.1就对了 }; int A::c = 10; std::ostream& print(std::ostream &os, A &a) { os << a.i << " " << a.s << " " << a.c << endl; } int main() { A a1(10,"123"); A a2(a1); //没有定义拷贝构造函数,编译器自己合成了一个,叫合成拷贝构造函数。不拷贝static成员。 print(std::cout, a2); A a3(10,"123"); print(std::cout, a3); }
拷贝构造函数:参数是自身类类型的常量引用,如果不是引用会无限递归
#include <iostream> #include <string> class A { public: A() = default; A(int a, std::string b):i(a), s(b) { } //直接初始化 A(const A&a):i(a.i),s(a.s) { std::cout << "调用拷贝构造函数" << std::endl; } //拷贝初始化 private: int i; std::string s; }; int main() { A a1(1,"123"); A a2(a1); //拷贝初始化 A a3 = a1; //拷贝初始化 }
拷贝操作不仅会在=发生还会在
向函数传递一个非引用的形参时
从一个返回类型为非引用类型的函数返回一个对象。
用花括号列表初始化一个数组或聚合类。
课后题13.4
指出哪些地方调用了构造函数
Point global; Point foo_bar(Point arg) //调用1次 { Point local = arg, *heap = new Point(global);//调用两次 *heap = local; //不调用 Point pa[4] = {local, *heap};//调用2次 return *heap; //调用1次 }
<2.拷贝赋值运算符
Sales_data s1,s2;
s1 = s2;
和拷贝构造函数一样,如果类未定义拷贝赋值运算符,编译器会默认合成一个。合成拷贝赋值运算符会将右侧的除了非static的成员全部拷贝过去
某些运算符必须定义成成员函数,包括赋值运算符,如果一个运算符是一个成员函数,其左侧运算对象就绑定到this指针上。
赋值运算符重载要返回类的引用是*this,因为赋值有可能是a= b = c;这种赋值,所以必须返回它自己的指针,那么也就是*this。所以必须定义成成员函数,和输出函数返回流的引用是一样的,可能os << a << b;
<3.析构函数
析构函数执行的于构造函数执行的相反,析构函数释放所使用的资源,并释放非static数据成员。
析构函数不接受参数,不能被重载,对于一个类只有一个析构函数。
析构函数销毁的顺序是构造函数构造顺寻的逆序。
在对象最后一次使用之后,析构函数的函数体可执行类设计者希望执行的任何首位工作。
隐式销毁一个内置指针类型的成员不会delete它所指向的对象
什么时候会调用析构函数
变量在离开其作用域的时候
当一个对象被销毁时,其成员被销毁
容器被销毁时
当对指向它的指针应用delete运算符时被销毁
对于临时对象,当创建它的完整表达式结束时被销毁
当指向一个对象的引用或指针离开作用域时,析构函数不会执行。
合成析构函数
编译器会默认合成一个合成析构函数,析构函数是在合成析构函数的补充,比如堆上申请的对象,必须我们手动释放,就写在析构函数里面。
知道析构函数体自身并不直接销毁成员是非常重要的,成员是在析构函数体之后隐含的析构阶段被销毁的。
#include <iostream> #include <string> #include <memory> class foo { public: foo():i(0),s(" "),p(new std::string) { } foo(int i1, std::string s1): i(i1), s(s1), p(new std::string()) { std::cout << "调用构造函数" << std::endl; } foo(const foo &f) { i = f.i; s = f.s; p = new std::string(*f.p); std::cout << "调用拷贝构造函数" << std::endl; } //foo(const foo &f): // i(f.i), s(f.s) { } foo& operator=(const foo&f) { i = f.i; s = f.s; p = new std::string(*f.p); std::cout << "调用赋值构造函数" << std::endl; return *this; } ~foo() { delete p; std::cout << "析构函数" << std::endl; } private: int i; std::string s; std::string *p; }; foo fun1(foo f) { foo f2(f); foo f3; f3 = f2; return f2; } int main() { foo f1(1,"123"); fun1(f1); }
我们可以通过=default让编译器来为我们生成默认版本
阻止拷贝:加上=delete
析构函数不能是删除的成员
删除一个类的析构函数或者类的某个成员的类型删除了析构函数,我们都不能定义该类的变量或临时对象
但可以动态分配这种类型,不能释放
<5.行为像值的类和行为像指针的类
行为像值的类:在类中包含需要动态分配的对象时,每次我们都new一个新值,那么在拷贝构造函数和赋值操作符也是要new一个新值。
对类资源的管理,每个类都有自己的一份
行为像指针的类:所有的类共享一份动态分配的对象,在c++11引入了智能指针shared_ptr , 所以我们可以很方便的来操作这些,但是如果我们想自己管理资源的话(不通过智能指针计数为0时释放资源)就要引入引用计数来辅助。
三个例子:
行为像值的类,行为像指针的类(智能指针指针),行为像指针的类(引用计数)
<<1.行为像值的类
#include <iostream> #include <string> class HasPtr { friend std::ostream& print(std::ostream &os, const HasPtr &hp); public: //HasPtr():p(nullptr),i(0) { }//加上会有二义性ambiguous HasPtr(const std::string s = std::string()): p(new std::string(s)), i(0) { std::cout << "调用单参或无参构造函数" << std::endl; } HasPtr(const std::string s, int t): p(new std::string(s)), i(t) { std::cout << "调用两参构造函数" << std::endl; } HasPtr(const HasPtr&hp) { std::cout << "调用拷贝构造函数" << std::endl; p = new std::string(*hp.p); i = hp.i; } HasPtr& operator=(const HasPtr &hp) { std::cout << "调用赋值运算符" << std::endl; auto temp = new std::string(*hp.p);//考给临时变量,万一=左值是自己就释放了。 if(p != nullptr) delete p; p = temp; i = hp.i; return *this; } ~HasPtr() { delete p; } private: std::string *p; int i; }; std::ostream& print(std::ostream &os, const HasPtr &hp) { std::cout << "string:" << *hp.p << " int:" << hp.i << std::endl; return os; } int main() { HasPtr p1; HasPtr p2("hehe"); print(std::cout, p1); print(std::cout, p2); p1 = p2; print(std::cout, p1); HasPtr p4 = p2; }
<<2.行为像指针的类(智能指针)
#include <iostream> #include <memory> #include <string> class HasPtr { friend std::ostream& print(std::ostream &os, const HasPtr &hp); public: HasPtr(const std::string &s = std::string()): sp(std::make_shared<std::string>(s)), i(0) { } HasPtr(const HasPtr& hp) { sp = hp.sp; i = hp.i; } HasPtr& operator=(const HasPtr& hp) { sp = hp.sp; i = hp.i; return *this; } private: std::shared_ptr<std::string>sp; int i; }; std::ostream& print(std::ostream &os, const HasPtr&hp) { os << "string:" << *hp.sp << " i:" << hp.i << "\n"; os << "usecout:" << hp.sp.use_count();//hp.sp->use_count() error use_count()是智能指针的成员 } int main() { HasPtr p1; HasPtr p2("hehe"); print(std::cout, p1) << std::endl; print(std::cout, p2) << std::endl; HasPtr p3 = p2; print(std::cout, p3) << std::endl; HasPtr p4; print(std::cout, p4) << std::endl; p4 = p2; print(std::cout, p4) << std::endl; }
<<3.行为像指针的类(引用计数)
#include <iostream> #include <string> class HasPtr { friend std::ostream& print(std::ostream &os, const HasPtr &ps); public: HasPtr(const std::string &s = std::string()): p(new std::string(s)), i(0), use(new std::size_t(1)) { } //HasPtr(const std::string &s = std::string(), std::size_t t): //error: 列表中带有默认初始值的要写在后面 HasPtr(std::size_t t, const std::string &s = std::string()): p(new std::string(s)), i(t), use(new std::size_t(1)) { } HasPtr(const HasPtr& hp) { use = hp.use; p = hp.p; ++*use; i = hp.i; } HasPtr& operator=(HasPtr &ps) { //*ps.use++ error: ++和*优先级相同,从右向左进行,先加了地址在解引用。 if(--*use == 0) { delete use; delete p; } p = ps.p; use = ps.use; i = ps.i; ++*ps.use; return *this; } ~HasPtr() { if(--*use == 0) { delete use; delete p; } } private: std::string *p; int i; std::size_t *use; //控制 }; //流要输出不能是const类型 std::ostream& print(std::ostream& os, const HasPtr &ps) { os << "string:" << *ps.p << " int:" << ps.i << " use:" << *ps.use; return os; } int main() { HasPtr p1; HasPtr p2(99, "hehe"); print(std::cout, p1) << std::endl; print(std::cout, p2) << std::endl; HasPtr p3 = p2; print(std::cout, p3) << std::endl; HasPtr p4; print(std::cout, p4) << std::endl; p4 = p3; print(std::cout, p4) << std::endl; }
根据我们的需要选取使用哪一种。
<6.swap交换操作
和拷贝控制成员不同,swap并不是必要的手段,但是对于分配了资源的类,定义swap可能是一种很重要的优化手段
因为我们对类使用系统的版本可能效率会非常的低,交换类对象时可能会是
void swap(A &a1, A &a2) { A temp = a1; //调用拷贝构造函数 a1 = a2; //调用赋值运算符 a2 = temp; //调用赋值运算符 }
在这段代码里使用了一次拷贝两次赋值,可见效率是比较低的,尤其对复杂的类
我们可以定义我们自己的swap,提升效率
且在赋值运算符中也可以使用swap来提升效率,
且使用拷贝和交换的赋值运算符自动就是异常安全的,能处理自动赋值
看HasPtr的改版,并使用vector排序
在这个例子中如果交换我们之用交换指针和字符串p,效率较高,但是如果我们用系统的版本就会一次拷贝两次赋值。
<span style="color:#000000;">#include <iostream> #include <string> #include <vector> #include <algorithm> class HasPtr { friend bool compare(HasPtr &hp1, HasPtr &hp2); //compare二元谓词函数,在sort中使用。也可使使用lambda friend void swap(HasPtr &hp1, HasPtr &hp2); //自定义版本的swap friend std::ostream& print(std::ostream &os, const HasPtr &hp); public: //HasPtr():p(nullptr),i(0) { }//加上会有二义性ambiguous HasPtr(const std::string s = std::string()): p(new std::string(s)), i(0) { std::cout << "调用单参或无参构造函数" << std::endl; } HasPtr(const std::string s, int t): p(new std::string(s)), i(t) { std::cout << "调用两参构造函数" << std::endl; } HasPtr(const HasPtr&hp) { std::cout << "调用拷贝构造函数" << std::endl; p = new std::string(*hp.p); i = hp.i; } //!!在赋值运算符中使用swap //!!拷贝并交技术 HasPtr& operator=(HasPtr hp) { swap(*this, hp);//!!使用我们自定义的版本。 这里是个小技巧,传参时传的是一份拷贝,然后我们交换*this和拷贝,此时已经“赋值”完成,*this已经改变 return *this; //!!而且在作用域结束的时候,hp就会销毁,且hp的任务已经完成。 } ~HasPtr() { delete p; } private: std::string *p; int i; }; bool compare(HasPtr &hp1, HasPtr &hp2) //<来排序 { return hp1.i < hp2.i; } void swap(HasPtr &hp1, HasPtr &hp2) { std::cout << "调用自定义版本swap" << std::endl; using std::swap; //为了避免使用成我们自己的版本从而引起无限递归。 swap(hp1.i, hp2.i); //系统版本 swap(hp1.p, hp2.p); //系统版本 } std::ostream& print(std::ostream &os, const HasPtr &hp) { std::cout << "string:" << *hp.p << " int:" << hp.i << std::endl; return os; } int main() { std::vector<HasPtr>vec_hp; HasPtr hp1("wang", 2); HasPtr hp2("wei", 3); HasPtr hp3("hao", 1); vec_hp.push_back(hp1); vec_hp.push_back(hp2); vec_hp.push_back(hp3); std::sort(vec_hp.begin(), vec_hp.end(), compare); for(const HasPtr&hp : vec_hp) { print(std::cout, hp); } }</span>
运行结果可以看出使用了多次自定义swap,使用次数越多效率越高。
构造函数和拷贝构造调用比较多,例子中让保存到vector中且排序了。
C++提供了关键字explicit,可以阻止不应该允许的经过转换构造函数进行的隐式转换的发生。声明为explicit的构造函数不能在隐式转换中使用。
在C++中,类的构造函数可以省略不写,这时C++会为它自动创建一个隐式默认构造函数;也可以由用户定义带参数的构造函数,构造函数也是一个成员函数,他可以被重载;当一个构造函数只有一个参数,而且该参数又不是本类的const引用时,这种构造函数称为转换构造函数。
<7.动态内存管理类
某些类需要自己进行内存分配,这些类要自己定义拷贝拷贝控制成员。
在某些操作中,动态内存管理类的性能会好的多,因为部分操作不会自己调用默认构造函数来初始化了,都是我们来直接拷贝赋值。
<8.对象移动
是c++11的新特性,也是非常重大的改变之一
很多情况下都会发生拷贝,而拷贝后就立即被销毁了,在这种情况下移动而非拷贝对象会大幅度提升效率。
IO类和unique_ptr 类可以移动但不能拷贝。
<<2.为了支持移动操作,新标准引入了右值引用&&
右值引用只能绑定在将要销毁的对象上
返回左值引用的函数,连同赋值,下标,解引用和前置递增递减运算符,都是返回左值的表达式,我们可以将这些值绑定到左值表达式上。
返回非引用类型的函数,连同算数,关系,位以及后置递增递减运算符(可以发现这些值都是临时的,即将销毁的),都生成右值。 我们不能将左值引用绑定到这类运算符上,但是可以将const的左值引用或者一个右值引用绑定到这类表达式上。
简单的说左值引用生存期长,右值引用生存期短
右值引用只能绑定到临时对象,该对象没有其他用户。使用右值引用的代码可以自由的接管所引用对象的资源。
不能将变量绑定到右值上,即使变量是右值引用类型。
标准库move函数
虽然不能将右值绑定到左值上面,但是可以显示的将左值转化为右值类型。
move告诉编译器:我们有一个左值但是我们希望像右值一样处理它,调用move后我们只能销毁对象或者赋值
使用move的代码应该使用std::move
<<3.移动构造函数和移动赋值运算符
要求:类支持拷贝和赋值
移动构造函数的第一个参数是该类类型的一个右值引用,和拷贝构造函数一样,其他任何参数都必须有默认的实参
移动构造函数确保移动后源对象处于这样一个状态,销毁它是无害的,一旦资源完成移动,源对象就必须不再指向
被移动的资源,这些资源的所有权已经归属新创建的对象
和构造函数不同,移动构造函数不创建任何新的资源。
可以这样理解,上面所说的算数,关系位和后置运算符都产生的是一个临时的对象,即将被销毁的,此时我们调用移动构造函数,将它的
所有权交给一个新创建的对象,也就是即将被销毁的不销毁了交给了别人保管。
移动操作不应该抛出异常
所以我们应该用noexcept来显示的指定
看StrVec的移动构造函数
StrVec::StrVec(StrVec &&s) noexcept //noexcept指名不抛出异常 :elements(s.elements), first_free(s.first_free),cap(s.cap) { s.elements = s.first_free = s.cap = nullptr; //销毁地动源后的对象 }
注意:
noexcept是C++11引入的,在一个构造函数中,noexcept出现在参数列表和初始化列表开始的冒号之间
不抛出异常的移动构造函数和移动赋值运算符必须标记为noexcept
之所以不允许抛出异常是因为在移动过程中抛出异常会产生问题。移动源改变了,新创建的对象也改变了,源对象不能保证在失败的情况下自身不变的要求
移动赋值运算符
StrVec& StrVec::operator=(StrVec &&s) noexcept //不抛出任何异常 { if(this != &s) //检测是否是自己给自己赋值, { free(); //释放this本身资源 elements = s.elements; first_free = s.first_free; cap = s.cap; s.elements = s.cap = s.first_free = nullptr; } return *this; }
注意:
当我们编写一个移动赋值运算符时,必须保证移后源对象必须保持有效的,可析构的状态,但是我们不能对它的值进行任何假想。
对象移动这块内容比较多,也比较重要,《c++ primer》用了14页来讲述,而且std::move对编写程序效率影响很大
So,这里就简单叙述下,下面专门写一篇关于对象移动的博客。
这章我感觉比第四版的变化大了太多,新知识很多,而且不仅仅是语法,思想性的东西也很多。温故而知新