C++之派生类的拷贝构造与赋值运算符重载

这里只说一下为什么派生类在拷贝构造器和赋值运算符重载中一些注意语法：
一、派生类的拷贝构造器

1.派生类的拷贝构造器跟普通构造器一样，若没有自定义生成，编译器会自动生成拷贝构造器，自动调用父类的拷贝构造器（不管父类的拷贝构造是否自定义或编译器自动生成）。

2.若派生类的拷贝构造器自定义生成，则一定要显示调用父类的拷贝构造器（不管父类的拷贝构造器是否自定义或编译器自动生成），否则编译可以通过，But拷贝不正确。

3.当自定义派生类的拷贝构造时注意显示调用父类的拷贝构造器的位置：在初始化列表（即参数列表的位置）。原因是：派生类能全盘继承父类的任何东西，除了构造器和析构器，故不能函数体中显式调用父类的拷贝构造。

二、派生类的赋值运算符重载

1.派生类的赋值运算符重载与派生类的拷贝构造器的前两条类似；

2.当自定义派生类的赋值运算符重载时注意调用父类的赋值运算符重载函数前要加上父类的域名，因为两个类的赋值运算符重载函数名都为：

operator=

这么个东西，子类与父类如果有函数同名的函数，不管返回值和参数是什么，都会发生shadow现象，也就是说子类的函数隐藏了父类的同名函数，子类只知道自己有这么个函数，就不晓得父类其实也有个同名的函数。为了防止这种命名冲突现象，在继承过程中，父类的数据成员和成员函数会带着父类的域名一起被继承，而不是单纯的继承数据成员和成员函数。

下面举个例子：

class Student
{
public:
    Student(char* name = "", int age = 0, float score = 0)
    {
    int len = strlen(name);
    this->name = new char[len + 1];
    strcpy(this->name, name);
    this->age = age;
    this->score = score;
    }
    ~Student(){
        delete []name;
    }
    Student(const Student & another){
        delete []name;
        int len = strlen(another.name);
        name = new char[len + 1];
        strcpy(name, another.name);
        age = another.age;
        score = another.score;
    }
    Student& operator=(const Student & another){
        if(this == &another)
            return *this;
        delete []name;
        int len = strlen(another.name);
        name = new char[len + 1];
        strcpy(name, another.name);
        age = another.age;
        score = another.score;
        return *this;
    }
    void dis(){
        cout << "name: " << name << endl;
        cout << "age: " << age << endl;
        cout << "score: " << score << endl;
    }
private:

    char* name;
    int age;
    float score;
};

class GraduateStudent: public Student
{
public:
    GraduateStudent(char* name = "", int age = 0, float score = 0, double salary = 0):Student(name, age, score), salary(salary){};
    GraduateStudent(const GraduateStudent & another):Student(another){
        salary = another.salary;
    }
    GraduateStudent& operator=(const GraduateStudent& another){
        if(this == &another)
            return *this;
        Student::operator =(another);
        salary = another.salary;
    }
    void dis(){
        Student::dis();
        cout << "salary: " << salary << endl;
    }
private:
    double salary;
};

int main()
{
    Student s1("jack", 25, 130);
    s1.dis();
    cout << "-------------------" << endl;
    GraduateStudent gs("marray", 30, 150, 3000);
    gs.dis();
    cout << "-------------------" << endl;
    GraduateStudent gs_cpy(gs);
    gs_cpy.dis();
    GraduateStudent gs_equal;
    cout << "-------------------" << endl;
    gs_equal = gs_cpy;
    gs_equal.dis();
    return 0;
}

结果如下：

这里对dis()函数也做了shadow现象的处理，加了函数域名，另外不论是拷贝构造还是赋值运算符重载都采用的深拷贝，当然默认都是浅拷贝（也叫等位拷贝）。