c++OOP之复制控制 ------复制构造函数、赋值重载、析构

本博文我们讨论OOP复制控制的一些内容；
首先考虑对象复制的时机： 非引用类型

1）：根据一个类去显式或者隐式初始化一个对象；

2）：复制一个对象，将它作为实参传给一个函数；

3）：从函数返回时复制一个对象。（ string tolittle（string word））

4）：初始化顺序容器中的元素。（例如vector 必须具备 copy，assignment功能）

一个空类，编译器提供默认无参数构造函数、拷贝构造函数、赋值运算符以及析构函数，一共四个函数。（面试）!!

11.复制构造函数、赋值运算符以及析构函数，称为三法则，一旦提供了其中一个，务必提供其余两个。以String为例：
a)  涉及到深拷贝、浅拷贝问题，所以需要提供拷贝构造函数
b)  然后，为了保持一致，赋值运算符也应该实现深拷贝
c)  既然实现深拷贝，那么必定申请了资源（例如内存），所以必然需要析构函数来手工释放。

一：复制构造函数：

复制构造函数调用的时机就是在对象复制的时候。方式有两种：

1）：当用户不提供时，编译器自动为我们合成一个拷贝构造函数；

示例代码如下：

#include <iostream>
#include <string>
using namespace std;

class Student
{
public:
Student()
{}
Student(int id, const string&name, int age)
:id_(id),name_(name),age_(age)
{}

void print()
{  cout << id_ <<":" << name_ <<":" << age_ << endl; }
private:
int id_;
string name_;
int age_;
};

int main(int argc, const char *argv[])
{
Student s(11,"zhangsan",23);
s.print();

Student s2(s); //执行此句，调用默认复制构造函数
s2.print();
return 0;
}

2）：用户自己定义：

放入class Student 的public中即可；

Student(const Student &s)
{
id_ = s.id_;
name_ = s.name_;
age_ = s.age_;
}

复制构造函数之 深copy 和 浅copy；

含有指针成员变量的类在复制时，有两种选择：
a) 复制指针的值，这样复制完毕后，两个对象指向同一块资源，这叫做 浅拷贝shallow copy（有可能出错）
b) 复制指针所指向的资源，复制完毕后，两个对象各自拥有自己的资源，这叫做 深拷贝 deep copy

示例代码：

#include "iostream"
#include "string.h"
using namespace std;

//copy String 时，仅仅复制指针的值
//导致析构时发生了问题
class String
{
public:
String();
String(const char*s);
String(const String &s);
~String();
void print()const
{
cout << str_ << endl;
}
private:
char *str_;
};
String::String()
:str_(new char(0))
{  }
String::String(const char *s)
:str_(new char[strlen(s)] +1)
{
::strcpy(str_, s);
}
//程序结束时会调用析构函数，两个对象s1,s2必然会析构两次，而str_指向同一片区域；
//当析构s1时，s1.str_所指向的区域被释放；而s2.str_ 也同时被释放
//当析构s2时，由于s2.str_已经被s1.str_释放，所以会产生错误.
String::String(const String &s)
:str_(s.str_)
{}

/* 修改成以下即可：
*String::String(const String &s)
*     :str_(new char[strlen(s)] +1)
* {
*  ::strcpy(str_, s.str_);
*  }
*/
String::~String()
{
delete[] str_; //注意
}
int main(int argc, const char *argv[])
{
String s("helloworld");
s.print();

String s2(s);
s.print();
return 0;
}

二： 赋值运算符的重载：【因为我们自定义的类没有内置比较运算符（<、>、！=）】
示例代码如下：

#include <iostream>
#include <string.h>
using namespace std;

class String
{
public:
String();
String(const char *s);
String(const String &s);
~String();
String &operator = (const String &s);
size_t size()const //自己构造size函数
{
return strlen(str_);
}

void print()
{ cout << str_ << endl; }
private:
char *str_;
};
String::String()
:str_(new char[1])
{ *str_ = 0; }

String::String(const char*s)
:str_(new char(strlen(s)+1))
{ ::strcpy(str_, s); }

String::String(const String &s)
:str_(new char(strlen(s.str_)+1))
{ ::strcpy(str_, s.str_); }

String &String::operator = (const String &s)
{
if(this == &s)//自身赋值
return *this;
delete[]str_;
str_ = new char(s.size() + 1 );
::strcpy(str_, s.str_);

return *this;
}

String::~String()
{ delete[] str_; }

int main(int argc, const char *argv[])
{
String s("helle");
s.print();

String s2;
s2 = s; //赋值重载
s2.print();

s2 = s2 ; //注意自身赋值情形
s2.print();

return 0;
}

禁止类复制和赋值的方法：

a）：把 copy构造函数和复制运算符设为private；

b）：只声明，不实现；

#include <iostream>
#include <string>
#include <vector>
using namespace std;

//no copy,no assignment
//google 推荐写法
#define   DISALLOW_COPY_AND_ASSIGN(TypeName) \
TypeName(const TypeName&); \
void operator=(const TypeName&)

class Test
{
public:
Test(){}
~Test(){}

private:
Test(const Test&t);
void operator=(const Test &t);
};

int main(int argc, const char *argv[])
{
Test t;

Test t2(t);//error

Test t3;
t3 = t; //error

return 0;
}

a）：如果一个类，不需要复制和赋值，那就禁用这种能力，这可以帮助避免大量潜在的bug。
b）：如果一个类，实现了像value一样的复制和赋值能力（意味着复制和赋值后，
两个对象没有任何关联，或者逻辑上看起来无任何关联），那么就称这个类的对象为  值语义（value semantics）。
如果类不能复制，或者复制后对象之间的资源归属纠缠不清，那么称为 对象语义（object semantics），或者 引用语义（reference semantics）。