博客

C++中的赋值运算符重载是什么？

  • Post category:cplus

赋值运算符重载是C++中一种运算符重载的方法，它可以对类对象进行赋值操作。在类中，如果没有重载“=”运算符，那么在对对象进行赋值操作时，就会采用浅拷贝的方式，即对象成员数据的指针值被拷贝了一份，而指针所指的内存块并没有被拷贝。因此，如果被赋值对象和赋值对象共用一个内存块，那么两个对象就会出现不一致的情况。

赋值运算符重载会重载“=”运算符，使得可以对类对象进行正确的赋值操作，而不是采用浅拷贝的方式。具体操作如下：

class MyClass {
public:
    MyClass& operator=(const MyClass& other) {  // 重载“=”运算符
        if (this != &other) {  // 判断是否为同一对象
            // 将other对象的成员数据拷贝到this对象中，确保两者数据独立
        }
        return *this;  // 返回this指针，方便连续操作
    }
};

示例1：

#include <iostream>

class MyClass {
public:
    MyClass(int x) : m_x(x) {}
    MyClass(const MyClass& other) : m_x(other.m_x) {}
    MyClass& operator=(const MyClass& other) {
        if (this != &other) {
            m_x = other.m_x;
        }
        return *this;
    }
    int get_x() const { return m_x; }
private:
    int m_x;
};

int main() {
    MyClass obj1(1);
    MyClass obj2 = obj1;  // 调用拷贝构造函数
    MyClass obj3(3);
    obj2 = obj3;  // 调用赋值运算符重载函数
    std::cout << "obj1.x = " << obj1.get_x() << std::endl;  // 输出1
    std::cout << "obj2.x = " << obj2.get_x() << std::endl;  // 输出3
    return 0;
}

在示例1中，程序定义了一个名为MyClass的类，该类有一个带有参数的构造函数、一个拷贝构造函数和一个赋值运算符重载函数。当我们分别用obj1和obj3初始化obj2，并输出它们的成员变量m_x时，我们会发现obj2的成员变量m_x被正确地赋值为3。

示例2：

#include <iostream>

class MyString {
public:
    MyString() : m_data(nullptr), m_len(0) {}
    MyString(const char* str) {
        if (str == nullptr) {
            m_data = nullptr;
            m_len = 0;
        } else {
            m_len = strlen(str);
            m_data = new char[m_len + 1];
            strcpy(m_data, str);
        }
    }
    MyString(const MyString& other) {
        m_len = other.m_len;
        m_data = new char[m_len + 1];
        strcpy(m_data, other.m_data);
    }
    MyString& operator=(const MyString& other) {
        if (this != &other) {
            delete [] m_data;
            m_len = other.m_len;
            m_data = new char[m_len + 1];
            strcpy(m_data, other.m_data);
        }
        return *this;
    }
    ~MyString() {
        if (m_data != nullptr) {
            delete [] m_data;
            m_data = nullptr;
            m_len = 0;
        }
    }
    friend std::ostream& operator<<(std::ostream& os, const MyString& str) {
        os << str.m_data;
        return os;
    }
private:
    char* m_data;
    int m_len;
};

int main() {
    MyString s1("hello");
    MyString s2("world");
    s1 = s2;
    std::cout << "s1 = " << s1 << std::endl;  // 输出“s1 = world”
    return 0;
}

在示例2中，程序定义了一个名为MyString的类，该类有一个默认构造函数、一个带有const char*参数的构造函数、一个拷贝构造函数、一个析构函数和一个赋值运算符重载函数。当我们用s2初始化s1，并输出s1的值时，我们会发现s1的值正确地被赋值为“world”。

总之，赋值运算符重载是为了正确地对类对象进行赋值操作而进行的运算符重载。在实现时，需要先判断是否是同一对象，然后将被赋值对象的成员数据拷贝到赋值对象中，最后返回this指针。

Tags: