05 拷贝构造函数

拷贝构造函数：对于对象的复制时使用的一种特殊的函数。

以下三种情况是对对象的复制：

1. 建立一个新的对象并用已有对象对新对象初始化：

class Text
{
    int a;
    int b;
};

main()
{
    Text text1;
    Text text2(text1);
    return 0;
}

1. 作为函数参数传递：

void fun(Text text)
{
    
}

main()
{
    Text text1;
    Text fun(text1);
    return 0;
}

1. 函数返回值是类的对象：

Text fun( )
{
    Text text;
    return text;
}

main()
{
    Text text1;
    text1 = fun();
    return 0;
}

缺省的拷贝构造函数：

• 如果类中没有说明拷贝构造函数，编译器会自动生成一个缺省的拷贝构造函数，作为该类的公有成员，来进行对象间的位拷贝，这个拷贝构造函数简单的关联了所有的类成员
• 每个类必须有一个拷贝构造函数

定义形式：

<类名>::<类名>(const <类名>&<引用名>)

例子：

#include <iostream>
 
using namespace std;
 
class Line
{
   public:
      int getLength( void );
      Line( int len );             // 简单的构造函数
      Line( const Line &obj);      // 拷贝构造函数
      ~Line();                     // 析构函数
 
   private:
      int *ptr;
};
 
// 成员函数定义，包括构造函数
Line::Line(int len)
{
    cout << "调用构造函数" << endl;
    // 为指针分配内存
    ptr = new int;
    *ptr = len;
}
 
Line::Line(const Line &obj)
{
    cout << "调用拷贝构造函数并为指针 ptr 分配内存" << endl;
    ptr = new int;
    *ptr = *obj.ptr; // 拷贝值
}
 
Line::~Line(void)
{
    cout << "释放内存" << endl;
    delete ptr;
}
int Line::getLength( void )
{
    return *ptr;
}
 
void display(Line obj)
{
   cout << "line 大小 : " << obj.getLength() <<endl;
}
 
// 程序的主函数
int main( )
{
   Line line(10);
 
   display(line);
 
   return 0;
}

如果在后两种情况不使用拷贝构造函数的时候，就会导致进行两次析构函数一个指针指向已经被删除的内存空间。对于第一种情况来说，初始化和赋值的不同含义是拷贝构造函数调用的原因。事实上，拷贝构造函数是由普通构造函数和赋值操作符共同实现的。描述拷贝构造函数和赋值运算符的异同的参考资料有很多。

使用原则

通常的原则是：

　　①对于凡是包含动态分配成员或包含指针和引用成员的类都应该提供拷贝构造函数；

　　②在提供拷贝构造函数的同时，还应该考虑重载"="赋值操作符号。

 

 深拷贝和浅拷贝：

编译器默认的方式是浅拷贝，浅拷贝就是对对象的简单赋值，一般情况浅拷贝就可以了，但是如果在堆上new一个新的空间的话对象就存在动态成员，浅拷贝就会出错。

#include <iostream>

using namespace std;

class Rect
{
    public:
        Rect()
        {
            cout << "rect" << endl;
            p = new int(100);
        }
        
        ~Rect()
        {
            cout << "~rect" << endl;
            if (p != NULL)
            {
                delete p;
            }
        }
    private:
        int width;
        int height;
        int *p;
}; 

int main()
{
    Rect rect1;
    Rect rect2(rect1);
    return 0;
 } 

错误分析：

代码会运行1次构造函数，两次析构函数，这样第二次的析构函数释放的空间不存在。

深拷贝：

深拷贝会在堆上重新分配一块空间，这样就不会出现上面那种问题了。

#include <iostream>

using namespace std;

class Rect
{
    public:
        Rect()
        {
            cout << "rect" << endl;
            p = new int(100);
        }
        Rect(const Rect& r)
        {
            width = r.width;
            height = r.height;
            p = new int;// 为对象重新分配空间
            *p = *(r.p); 
        }
        ~Rect()
        {
            cout << "~rect" << endl;
            if (p != NULL)
            {
                delete p;
            }
        }
    private:
        int width;
        int height;
        int *p;
}; 

int main()
{
    Rect rect1;
    Rect rect2(rect1);
    return 0;
 } 

参考链接