拷贝构造函数与赋值构造函数的区别

构造函数、析构函数、赋值构造函数是每个类最基本的的函数。每个类只有一个析构函数和一个赋值构造函数。但是有很多构造函数(一个为拷贝构造函数，其他为普通构造函数)。
对于一个类A,如果不编写上述四个函数，c++编译器将自动为A产生四个默认的函数，即：

A(void)                                  //默认无参数构造函数
A(const A &a)                        //默认拷贝构造函数
~A(void);                              //默认的析构函数
A & operator = (const A &a);  //默认的赋值构造函数

既然能自动生成函数，为什么还需要自定义？原因之一是默认的拷贝构造函数和默认的赋值构造函数均采用”位拷贝“而非”值拷贝“。

位拷贝 v.s. 值拷贝

为便于说明，以自定义String类为例，先定义类，而不去实现。

#include <iostream>
using namespace std;
class String  
{
    public:
        String(void);
        String(const String &other);
        ~String(void);
        String & operator =(const String &other);
    private:
        char *m_data;
        int val;
};

位拷贝拷贝的是地址，而值拷贝拷贝的是内容。

如果定义两个String对象a, b。当利用位拷贝时，a=b，其中的a.val=b.val；但是a.m_data=b.m_data就错了：a.m_data和b.m_data指向同一个区域。这样出现问题：

a.m_data原来的内存区域未释放，造成内存泄露
a.m_data和b.m_data指向同一块区域，任何一方改变，会影响到另一方
当对象释放时，b.m_data会释放掉两次

因此当类中还有指针变量时，拷贝构造函数和赋值构造函数就隐含了错误。此时需要自己定义。

结论

如果类需要析构函数，则它也需要赋值操作符和拷贝构造函数。

注意

如果没定义拷贝构造函数（别的不管），编译器会自动生成默认拷贝构造函数
如果定义了其他构造函数（包括拷贝构造函数），编译器绝不会生成默认构造函数
即使自己写了析构函数，编译器也会自动生成默认析构函数

因此此时如果写String s是错误的，因为定义了其他构造函数，就不会自动生成无参默认构造函数。

拷贝构造函数 v.s. 赋值构造函数

#include <iostream>
#include <cstring>
using namespace std;
class String  
{
    public:
        String(const char *str);
        String(const String &other);
        String & operator=(const String &other);
        ~String(void); 
    private:
        char *m_data;
};
String::String(const char *str)
{
    cout << "自定义构造函数" << endl;
    if (str == NULL)
    {
        m_data = new char[1];
        *m_data = '\0';
    }
    else
    {
        int length = strlen(str);
        m_data = new char[length + 1];
        strcpy(m_data, str);
    }
}
String::String(const String &other)
{
    cout << "自定义拷贝构造函数" << endl;
    int length = strlen(other.m_data);
    m_data = new char[length + 1]; //申请空间，因为原来没有空间
    strcpy(m_data, other.m_data);
}
String & String::operator=(const String &other)
{
    cout << "自定义赋值构造函数" << endl; 
    if (this == &other)
    {
        return *this;   //防止自复制
    }
    else
    {
        delete [] m_data;   //赋值需要先删除原来的空间
        int length = strlen(other.m_data);
        m_data = new char[length + 1];
        strcpy(m_data, other.m_data);
        return *this;
    }
}
String::~String(void)
{
    cout << "自定义析构函数" << endl; 
    delete [] m_data;
}
int main()
{
    cout << "a(\"abc\")" << endl;
    String a("abc");
    cout << "b(\"cde\")" << endl;
    String b("cde");
    cout << " d = a" << endl;
    String d = a;
    cout << "c(b)" << endl;
    String c(b);
    cout << "c = a" << endl;
    c = a;
    cout << endl;
}

说明几点

赋值构造函数中，上来比较 this == &other 是很必要的，因为防止自复制，这是很危险的，因为下面有delete []m_data，如果提前把m_data给释放了，指针已成野指针，再赋值就错了
赋值构造函数中，接着要释放掉m_data,否则就没机会了（下边又有新指向了）
拷贝构造函数是对象被创建时调用，赋值构造函数只能被已经存在了的对象调用

注意：

String a(“hello”); String b(“world”); 调用自定义构造函数.
String c=a；调用拷贝构造函数，因为c一开始不存在，最好写成String c(a);

构造函数调用构造函数问题

看下面例子

#include <iostream>
#include <string>
using namespace std;
class A
{
    public:
        A(string _s1, string _s2)
        {
            s1=_s1;
            s2=_s2;
        }
        A(string _s1)
        {
            A(_s1, "");//调用另一个构造函数
        }
        void printme()
        {
            cout<<s1<<"   "<<s2<<endl;
        }
    private:
        string s1;
        string s2;
};
int main()
{
    A* a=new A("barret");
    a->printme();
    delete a;
    return 0;
}

上面代码的输出结果是空的，barret并不会被显示。

原因需要从构造函数的流程讲起，当定义一个对象时，会按顺序做2件事情：

分配好内存（非静态数据成员是未初始化的）
调用构造函数（构造函数的本意就是初始化非静态数据成员）

code中14行已经为a对象分配了内存，但是构造函数还没有执行完，在15行调用了另一个构造函数，15行执行完相当于产生了一个匿名的A临时对象（临时对象中s1=barret，s2=””）。而输入参数barret并没有赋值到a对象的s1数据成员中。所以，构造函数执行完，a对象s1，s2成员的都是默认的内容。

在构造函数里调用另一个构造函数的关键是让第二个构造函数在第一次分配好的内存上执行，而不是分配新的内存，这个可以用标准库的placement new做到。
第15行修改如下：

A(string _s1)
{
    new (this)A(_s1, "");
}

C 编程语言

C 类的构造函数

拷贝构造函数与赋值构造函数的区别

位拷贝 v.s. 值拷贝

结论

拷贝构造函数 v.s. 赋值构造函数

注意：

构造函数调用构造函数问题