【2020.12.28】对象拷贝之重载赋值运算符

对象拷贝的两种形式

1. 使用拷贝构造函数。
2. 使用 "=" 运算符。

面向对象中的 "=" 运算符

1. 简单的对象复制操作。
2. 有父类时的复制操作。

#include <iostream>

class Base
{
private:
    int x;
    int y;

public:
    Base()    {}
    Base(int x, int y)
    {
        this->x = x;
        this->y = y;
    }
};

int main(int argc, char* agrv[])
{
    Base c1(1, 2), c2(3, 4);

    c1 = c2;

    return 0;
}

c1 = c2;

赋值运算符的问题

赋值运算符 “=” 与拷贝构造函数一样，都是将成员的值直接复制，它们都是 "浅拷贝"，所以需要重载赋值运算符，与自定义构造函数一样。

重载赋值运算符

1. 如果要重载赋值运算符，必须对所有的属性进行处理。
2. 如果有父类，要显式调用父类的重载赋值运算符。

重载赋值运算符实现对象深拷贝

#include <iostream>

class Base
{
private:
    int Length;
    char* Buffer;

public:
    Base()
    {
        Length = 0;
        Buffer = NULL;
    }

    Base(char* szBuffer)
    {
        this->Length = strlen(szBuffer) + 1;
        Buffer = new char[Length];
        strcpy(Buffer, szBuffer);
    }

    Base& operator=(const Base& ref)
    {
        Length = ref.Length;
        if(Buffer != NULL)
            delete[] Buffer;
        Buffer = new char[Length];
        memcpy(Buffer, ref.Buffer, Length);

        return *this;
    }

    ~Base()
    {
        delete[] Buffer;
    }
};

int main(int argc, char* agrv[])
{
    Base c1("hello"), c2("world");

    c1 = c2;

    return 0;
}

有父类的情况下重载赋值运算符实现对象深拷贝

#include <iostream>

class Base
{
private:
    int Length;
    char* Buffer;

public:
    Base()
    {
        Length = 0;
        Buffer = NULL;
    }

    Base(char* szBuffer)
    {
        this->Length = strlen(szBuffer) + 1;
        Buffer = new char[Length];
        strcpy(Buffer, szBuffer);
    }

    Base& operator=(const Base& ref)
    {
        Length = ref.Length;
        if(Buffer != NULL)
            delete[] Buffer;
        Buffer = new char[Length];
        memcpy(Buffer, ref.Buffer, Length);

        return *this;
    }

    ~Base()
    {
        delete[] Buffer;
    }
};

class Test:public Base
{
private:
    int Index;

public:
    Test()    {}

    Test(int Index, char* szBuffer):Base(szBuffer)
    {
        this-Index = Index;
    }

    Test& operator=(const Test& ref)
    {
        //显示调用父类赋值运算符，先调用父类的赋值运算符，保证逻辑正确。
        Base::operator=(ref);

        Index = ref.Index;

        return *this;
    }
};

int main(int argc, char* agrv[])
{
    Base c1("hello"), c2("world");

    c1 = c2;

    return 0;
}

//显示调用父类赋值运算符
Base::operator=(ref); 

为什么拷贝构造函数不能这样写？

子类能全部继承父类的任何东西，除了构造函数和析构函数，所以不能在函数体中显式调用父类的拷贝构造函数。