Fork me on GitHub

C++ 复制控制

每种类型还定义了创建该类型的对象时会发生什么——构造函数定义了该类类型对象的初始化。类型还能控制复制、赋值或撤销该类型的对象时会发生什么——类通过特殊的成员函数：复制构造函数、赋值操作符和析构函数来控制这些行为。如果没有显式定义复制构造函数或赋值操作符，编译器（通常）会为我们定义。

 

复制构造函数、赋值操作符和析构函数总称为复制控制。编译器自动实现这些操作，但类也可以定义自己的版本。

 

实现复制控制操作最困难的部分，往往在于识别何时需要覆盖默认版本。有一种特别常见的情况需要类定义自己的复制控制成员的：类具有指针成员。

 

复制构造函数是一种特殊构造函数，只具有单个形参，该形参（常用 const 修饰）是对该类类型的引用。当定义一个新对象并用一个同类型的对象对它进行初始化时，将显式使用复制构造函数。当将该类型的对象传递给函数或函数返回该类型的对象时，将隐式使用复制构造函数。

 

析构函数是构造函数的互补：当对象超出作用域或动态分配的对象被删除时，将自动应用析构函数。不管类是否定义了自己的析构函数，编译器都自动执行类中非static 数据成员的析构函数。

 

复制构造函数可用于：

• 根据另一个同类型的对象显式或隐式初始化一个对象。

• 复制一个对象，将它作为实参传给一个函数。

• 从函数返回时复制一个对象。

• 初始化顺序容器中的元素。

• 根据元素初始化式列表初始化数组元素。

 

C++ 支持两种初始化形式：直接初始化和复制初始化。复制初始化使用 = 符号，而直接初始化将初始化式放在圆括号中。

string null_book = "9-999-99999-9"; // copy-initialization

string dots(10, '.'); // direct-initialization

string empty_copy = string(); // copy-initialization

string empty_direct; // direct-initialization

对于类类型对象，只有指定单个实参或显式创建一个临时对象用于复制时，才使用复制初始化。

 

当形参为非引用类型的时候，将复制实参的值。类似地，以非引用类型作返回值时，将返回 return 语句 中的值的副本。当形参或返回值为类类型时，由复制构造函数进行复制。

 

合成的复制构造函数

合成复制构造函数的行为是，执行逐个成员初始化，将新对象初始化为原对象的副本。

合成复制构造函数直接复制内置类型成员的值，类类型成员使用该类的复制构造函数进行复制。数组成员的复制是个例外。虽然一般不能复制数组，但如果一个类具有数组成员，则合成复制构造函数将复制数组。复制数组时合成复制构造函数将复制数组的每一个元素。

 

定义自己的复制构造函数

复制构造函数就是接受单个类类型引用形参（通常用 const 修饰）的构造函数：

class Foo {

public:

Foo(); // default constructor

Foo(const Foo&); // copy constructor

// ...

};

虽然也可以定义接受非 const 引用的复制构造函数，但形参通常是一个const 引用。只包含类类型成员或内置类型（但不是指针类型）成员的类，无须显式地定义复制构造函数，也可以复制。

 

然而，有些类必须对复制对象时发生的事情加以控制。这样的类经常有一个数据成员是指针，或者有成员表示在构造函数中分配的其他资源。而另一些类在创建新对象时必须做一些特定工作。这两种情况下，都必须定义复制构造函数。

 

禁止复制

有些类需要完全禁止复制。为了防止复制，类必须显式声明其复制构造函数为 private。然而，类的友元和成员仍可以进行复制。如果想要连友元和成员中的复制也禁止，就可以声明一个（private）复制构造函数但不对其定义。

 

大多数类应定义复制构造函数和默认构造函数

不定义复制构造函数和／或默认构造函数，会严重局限类的使用。不允许复制的类对象只能作为引用传递给函数或从函数返回，它们也不能用作容器的元素。

一般来说，最好显式或隐式定义默认构造函数和复制构造函数。只有不存在其他构造函数时才合成默认构造函数。如果定义了复制构造函数，也必须定义默认构造函数。

 

重载操作符是一些函数，其名字为 operator 后跟着所定义的操作符的符号。

 

赋值操作符

如果类没有定义自己的赋值操作符，则编译器会合成一个。通过定义名为 operator= 的函数，我们可以对赋值进行定义。像任何其他函数一样，操作符函数有一个返回值和一个形参表。形参表必须具有与该操作符数目相同的形参（如果操作符是一个类成员，则包括隐式 this 形参）。赋值是二元运算，所以该操作符函数有两个形参：第一个形参对应着左操作数，第二个形参对应右操作数。赋值操作符的返回类型应该与内置类型赋值运算返回的类型相同。

 

合成赋值操作符与合成复制构造函数的操作类似。它会执行逐个成员赋值：右操作数对象的每个成员赋值给左操作数对象的对应成员。除数组之外，每个成员用所属类型的常规方式进行赋值。对于数组，给每个数组元素赋值。

// equivalent to the synthesized assignment operator

Sales_item& Sales_item::operator=(const Sales_item &rhs)

{

isbn = rhs.isbn; // calls string::operator=

units_sold = rhs.units_sold; // uses built-in int assignment

revenue = rhs.revenue; // uses built-in double assignment

return *this;

}

 

一般而言，如果类需要复制构造函数，它也会需要赋值操作符。

 

析构函数

构造函数的一个用途是自动获取资源。例如，构造函数可以分配一个缓冲区或打开一个文件，在构造函数中分配了资源之后，需要一个对应操作自动回收或释放资源。析构函数就是这样的一个特殊函数，它可以完成所需的资源回收，作为类构造函数的补充。

 

何时调用析构函数

撤销类对象时会自动调用析构函数。变量在超出作用域时应该自动撤销。因此，当遇到右花括号时，将运行 item 的析构函数。动态分配的对象只有在指向该对象的指针被删除时才撤销。如果没有删除指向动态对象的指针，则不会运行该对象的析构函数，对象就一直存在，从而导致内存泄漏，而且，对象内部使用的任何资源也不会释放。

撤销一个容器（不管是标准库容器还是内置数组）时，也会运行容器中的类类型元素的析构函数。容器中的元素总是按逆序撤销：首先撤销下标为 size() - 1 的元素，然后是下标为 size() - 2 的元素……直到最后撤销下标为 [0] 的元素。

 

何时编写显式析构函数

析构函数通常用于释放在构造函数或在对象生命期内获取的资源。如果类需要析构函数，则它也需要赋值操作符和复制构造函数，这是一个有用的经验法则。这个规则常称为三法则，指的是如果需要析构函数，则需要所有这三个复制控制成员。

 

编译器总是会为我们合成一个析构函数。合成析构函数按对象创建时的逆序撤销每个非 static 成员。合成析构函数并不删除指针成员所指向的对象。

 

析构函数是个成员函数，它的名字是在类名字之前加上一个代字号（~），它没有返回值，没有形参。因为不能指定任何形参，所以不能重载析构函数。

析构函数与复制构造函数或赋值操作符之间的一个重要区别是，即使我们编写了自己的析构函数，合成析构函数仍然运行。

 

使用标准库一个原因是，使用标准库能够大大减少现代 C++ 程序中对指针的需要。

 

管理指针成员

设计具有指针成员的类时，类设计者必须首先需要决定的是该指针应提供什么行为。将一个指针复制到另一个指针时，两个指针指向同一对象。当两个指针指向同一对象时，可能使用任一指针改变基础对象。类似地，很可能一个指针删除了一对象时，另一指针的用户还认为基础对象仍然存在。

大多数 C++ 类采用以下三种方法之一管理指针成员：

1. 指针成员采取常规指针型行为。这样的类具有指针的所有缺陷但无需特殊的复制控制。

2. 类可以实现所谓的“智能指针”行为。指针所指向的对象是共享的，但类能够防止悬垂指针。

3. 类采取值型行为。指针所指向的对象是唯一的，由每个类对象独立管理。

 

常规指针型行为

// class that has a pointer member that behaves like a plain pointer

class HasPtr {

public:

// copy of the values we're given

HasPtr(int *p, int i): ptr(p), val(i) { }

// const members to return the value of the indicated data member

int *get_ptr() const { return ptr; }

int get_int() const { return val; }

// non const members to change the indicated data member

void set_ptr(int *p) { ptr = p; }

void set_int(int i) { val = i; }

// return or change the value pointed to, so ok for const objects

int get_ptr_val() const { return *ptr; }

void set_ptr_val(int val) const { *ptr = val; }

private:

int *ptr;

int val;

};

 

具有指针成员且使用默认合成复制构造函数的类具有普通指针的所有缺陷。尤其是，类本身无法避免悬垂指针。

int obj = 0;

HasPtr ptr1(&obj, 42); // int* member points to obj, val is 42

HasPtr ptr2(ptr1); // int* member points to obj, val is 42

 

ptr1.set_int(0); // changes val member only in ptr1

ptr2.get_int(); // returns 42

ptr1.get_int(); // returns 0

 

ptr1.set_ptr_val(42); // sets object to which both ptr1 and ptr2

point

ptr2.get_ptr_val(); // returns 42

 

int *ip = new int(42); // dynamically allocated int initialized to 42

HasPtr ptr(ip, 10); // Has Ptr points to same object as ip does

delete ip; // object pointed to by ip is freed

ptr.set_ptr_val(0); // disaster: The object to which Has Ptr points was freed!

因为 HasPtr 类没有定义复制构造函数，所以复制一个 HasPtr 对象将复制两个成员。复制之后，ptr1 和 ptr2 中的指针指向同一对象且两个对象中的 int 值相同。int 值是清楚和独立的，而指针则纠缠在一起。

 

智能指针

智能指针负责删除共享对象。用户将动态分配一个对象并将该对象的地址传给新的 HasPtr类。用户仍然可以通过普通指针访问对象，但绝不能删除指针。HasPtr 类将保证在撤销指向对象的最后一个 HasPtr 对象时删除对象。

定义智能指针的通用技术是采用一个使用计数。智能指针类将一个计数器与类指向的对象相关联。使用计数跟踪该类有多少个对象共享同一指针。使用计数为 0 时，删除对象。使用计数有时也称为引用计数。

每次创建类的新对象时，初始化指针并将使用计数置为 1。当对象作为另一对象的副本而创建时，复制构造函数复制指针并增加与之相应的使用计数的值。对一个对象进行赋值时，赋值操作符减少左操作数所指对象的使用计数的值（如果使用计数减至 0，则删除对象），并增加右操作数所指对象的使用计数的值。最后，调用析构函数时，析构函数减少使用计数的值，如果计数减至 0，则删除基础对象。

唯一的创新在于决定将使用计数放在哪里。

 

实现使用计数有两种经典策略，其中一种需要定义一个单独的具体类用以封闭使用计数和相关指针：

// private class for use by HasPtr only

class U_Ptr {

friend class HasPtr;

int *ip;

size_t use;

U_Ptr(int *p): ip(p), use(1) { }

~U_Ptr() { delete ip; }

};

U_Ptr 类保存指针和使用计数，每个 HasPtr 对象将指向一个 U_Ptr 对象，使用计数将跟踪指向每个U_Ptr 对象的 HasPtr 对象的数目。U_Ptr 定义的仅有函数是构造函数和析构函数，构造函数复制指针，而析构函数删除它。构造函数还将使用计数置为 1，表示一个 HasPtr 对象指向这个 U_Ptr 对象。

 

使用计数类的使用新的 HasPtr 类保存一个指向 U_Ptr 对象的指针，U_Ptr 对象指向实际的int 基础对象。必须改变每个成员以说明的 HasPtr 类指向一个 U_Ptr 对象而不是一个 int。

/* smart pointer class: takes ownership of the dynamically allocated

* object to which it is bound

* User code must dynamically allocate an object to initialize aHasPtr

* and must not delete that object; the HasPtr class will delete it

*/

class HasPtr {

public:

// HasPtr owns the pointer; pmust have been dynamically allocated

HasPtr(int *p, int i): ptr(new U_Ptr(p)), val(i) { }

// copy members and increment the use count

HasPtr(const HasPtr &orig):

ptr(orig.ptr), val(orig.val) { ++ptr->use; }

HasPtr& operator=(const HasPtr&);

// if use count goes to zero, delete the U_Ptr object

~HasPtr() { if (--ptr->use == 0) delete ptr; }

private:

U_Ptr *ptr; // points to use-counted U_Ptr class

int val;

};

复制构造函数从形参复制成员并增加使用计数的值。复制构造函数执行完毕后，新创建对象与原有对象指向同一 U_Ptr 对象，该 U_Ptr 对象的使用计数加1。

析构函数将检查 U_Ptr 基础对象的使用计数。如果使用计数为 0，则这是最后一个指向该 U_Ptr 对象的 HasPtr 对象，在这种情况下，HasPtr 析构函数删除其 U_Ptr 指针。删除该指针将引起对 U_Ptr 析构函数的调用，U_Ptr 析构函数删除 int 基础对象。

HasPtr& HasPtr::operator=(const HasPtr &rhs)

{

++rhs.ptr->use; // increment use count on rhs first

if (--ptr->use == 0)

delete ptr; // if use count goes to 0 on this object, delete it

ptr = rhs.ptr; // copy the U_Ptr object

val = rhs.val; // copy the int member

return *this;

}

赋值操作符首先将右操作数中的使用计数加 1，然后将左操作数对象的使用计数减 1 并检查这个使用计数。像析构函数中那样，如果这是指向 U_Ptr 对象的最后一个对象，就删除该对象，这会依次撤销 int 基础对象。将左操作数中的当前值减 1（可能撤销该对象）之后，再将指针从 rhs 复制到这个对象。赋值照常返回对这个对象的引用。

改变其他成员

现在需要改变访问 int* 的其他成员，以便通过 U_Ptr 指针间接获取 int：

class HasPtr {

public:

// copy control and constructors as before

// accessors must change to fetch value from U_Ptr object

int *get_ptr() const { return ptr->ip; }

int get_int() const { return val; }

// change the appropriate data member

void set_ptr(int *p) { ptr->ip = p; }

void set_int(int i) { val = i; }

// return or change the value pointed to, so ok for const objects

// Note: *ptr->ip is equivalent to *(ptr->ip)

int get_ptr_val() const { return *ptr->ip; }

void set_ptr_val(int i) { *ptr->ip = i; }

private:

U_Ptr *ptr; // points to use-counted U_Ptr class

int val;

};

 

建议：管理指针成员

具有指针成员的对象一般需要定义复制控制成员。如果依赖合成版本，会给类的用户增加负担。用户必须保证成员所指向的对象存在，只要还有对象指向该对象。

为了管理具有指针成员的类，必须定义三个复制控制成员：复制构造函数、赋值操作符和析构函数。这些成员可以定义指针成员的指针型行为或值型行为。

值型类将指针成员所指基础值的副本给每个对象。复制构造函数分配新元素并从被复制对象处复制值，赋值操作符撤销所保存的原对象并从右操作数向左操作数复制值，析构函数撤销对象。

作为定义值型行为或指针型行为的另一选择，是使用称为“智能指针”的一些类。这些类在对象间共享同一基础值，从而提供了指针型行为。但它们使用复制控制技术以避免常规指针的一些缺陷。为了实现智能指针行为，类需要保证基础对象一直存在，直到最后一个副本消失。使用计数是管理智能指针类的通用技术。同一基础值的每个副本都有一个使用计数。复制构造函数将指针从旧对象复制到新对象时，会将使用计数加 1。赋值操作符将左操作数的使用计数减 1 并将右操作数的使用计数加 1，如果左操作数的使用计数减至 0，赋值操作符必须删除它所指向的对象，最后，赋值操作符将指针从右操作数复制到左操作数。析构函数将使用计数减 1，并且，如果使用计数减至 0，就删除基础对象。

 

定义值型类

是给指针成员提供值语义。具有值语义的类所定义的对象，其行为很像算术类型的对象：复制值型对象时，会得到一个不同的新副本。对副本所做的改变不会反映在原有对象上，反之亦然。string类是值型类的一个例子。

/*

* Valuelike behavior even though HasPtr has a pointer member:

* Each time we copy a HasPtr object, we make a new copy of the

* underlying int object to which ptr points.

*/

class HasPtr {

public:

// no point to passing a pointer if we're going to copy it anyway

// store pointer to a copy of the object we're given

HasPtr(const int &p, int i): ptr(new int(p)), val(i) {}

// copy members and increment the use count

HasPtr(const HasPtr &orig):

ptr(new int (*orig.ptr)), val(orig.val) { }

HasPtr& operator=(const HasPtr&);

~HasPtr() { delete ptr; }

// accessors must change to fetch value from Ptr object

int get_ptr_val() const { return *ptr; }

int get_int() const { return val; }

// change the appropriate data member

void set_ptr(int *p) { ptr = p; }

void set_int(int i) { val = i; }

// return or change the value pointed to, so ok for const objects

int *get_ptr() const { return ptr; }

void set_ptr_val(int p) const { *ptr = p; }

private:

int *ptr; // points to an int

int val;

};

 

HasPtr& HasPtr::operator=(const HasPtr &rhs)

{

// Note: Every HasPtr is guaranteed to point at an actual int;

// We know that ptr cannot be a zero pointer

*ptr = *rhs.ptr; // copy the value pointed to

val = rhs.val; // copy the int

return *this;

}

 

复制构造函数不再复制指针，它将分配一个新的 int 对象，并初始化该对象以保存与被复制对象相同的值。每个对象都保存属于自己的 int 值的不同副本。因为每个对象保存自己的副本，所以析构函数将无条件删除指针。

赋值操作符不需要分配新对象，它只是必须记得给其指针所指向的对象赋新值，而不是给指针本身赋值：

posted @ 2015-12-26 11:20  ZHK的博客  阅读(916)  评论(0)  编辑  收藏  举报