复制构造函数和赋值运算符

进行c++类设计时，如果不对复制构造函数和赋值运算符进行重写的话，编译器会默认调用默认函数。默认的复制构造函数和赋值运算符会造成许多问题。先看下面一段代码。

#include <iostream>
#include <cstring>
class My_string{
private:
    char* str;
    int len;
    static int num_string;
public:
    My_string(const char*);
    ~My_string();
    void show()const;
};
int My_string::num_string = 0;

My_string::My_string(const char* src = "c++") {
    len = std::strlen(src);
    str = new char[len+1];
    std::strcpy(str, src);
    num_string++;
}

My_string::~My_string() {
    delete [] str;
    num_string--;
}

void My_string::show() const {
    std::cout << str << " "<< num_string <<std::endl;
}

void foo(My_string s){
    s.show();
}

int main(){
    My_string a = My_string("c");
    My_string b = a;
    a.show();
    b.show();
    foo(a);
    a.show();
    b.show();
}

输出结果为：

c 2
c++ 2
c 2
c 2
 1
 1

上述运行结果有二个问题：

1、调用foo函数之后，My_string类调用了析构函数，使num_string的值减一，且a的str值被销毁。

2、b未经操作，但是str的值也被销毁。

引起上述第一个问题的原因是默认复制构造函数，第二个问题的原因是默认赋值运算符。

复制构造函数

首先调用复制构造函数的情况有3个：

1、类通过值传递作为参数。

2、类作为非引用返回值。

3、使用一个现有对象初始化同类对象。

My_string a = My_string;

My_string b(a);
My_string b1 = a;
My_string b2 = My_string(a);
My_string* b3 = new My_string(a);

上述4种初始化都会调用复制构造函数。

同时，默认的复制构造函数采用的浅复制。对于非静态成员变量，默认复制构造函数采用简单的逐个值复制，即对于指针也是复制的指针地址，而不是指针里面的内容。

有了上面的知识，我们再来看下foo函数。变量a作为参数传入foo函数时，系统调用默认的复制构造函数，创建了一个临时变量s。变量s的str指针和变量a的str指针指向同一块地址。当foo函数运行完毕时。临时变量s从栈中销毁，调用析构函数，num_string变量由2变为1，同时变量s和变量a的str指针所指向的内存被销毁。这就是num_string变量自减，且a值找不到的原因。

解决方法，我们应对默认复制构造函数进行重写：

My_string::My_string(const My_string & s){
    len = s.len;
    str = new char[len+1];
    std::strcpy(str, s.str);
    num_string++;
}

赋值运算符

赋值运算符的使用场景：

My_string a = My_string("c");
My_string b;
b = a; //调用赋值运算符

My_string c = b; //此时是初始化，调用的是复制构造函数

顾名思义，赋值运算符是当赋值的时候所使用。但是默认的赋值运算符所采用的也是浅复制。所以问题二中b的str指针与a的str指针指向的是同一地址。所以当a的str地址被foo函数中的临时变量销毁时，b的指针内容也同样被销毁了。

解决方法，重写赋值运算符：

My_string & My_string::operator=(const My_string & s) {
    if(&s == this)
        return *this;
    delete[] str;
    len = s.len;
    str = new char[len+1];
    std::strcpy(str, s.str);
    return *this;
}

重写完的类定义为：

class My_string{
private:
    char* str;
    int len;
    static int num_string;
public:
    My_string(const char*);
    My_string(const My_string &);
    ~My_string();
    void show()const;
    My_string & operator=(const My_string &);
};
int My_string::num_string = 0;
My_string::My_string(const char* src = "c++") {
    len = std::strlen(src);
    str = new char[len+1];
    std::strcpy(str, src);
    num_string++;
}
My_string::~My_string() {
    delete [] str;
    num_string--;
}
void My_string::show() const {
    std::cout << str << " "<< num_string <<std::endl;
}

My_string::My_string(const My_string & s){
    len = s.len;
    str = new char[len+1];
    std::strcpy(str, s.str);
    num_string++;
}

My_string & My_string::operator=(const My_string & s) {
    if(&s == this)
        return *this;
    delete[] str;
    len = s.len;
    str = new char[len+1];
    std::strcpy(str, s.str);
    return *this;
}

运行结果为：

c 2
c++ 2
c 2
c 3
c 2
c 2