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

赋值运算符重载（Assignment operator overloading）是C++中一种自定义类行为的机制，通过它，可以自定义一个类对象被赋值时的行为。C++中默认的赋值运算符是浅拷贝，只进行指针的赋值，对于动态分配的内存容易产生内存泄漏或者double free（将同一个内存地址指向多个指针）等问题，通过自定义赋值运算符重载，可避免这些问题的发生。

赋值运算符重载需要满足以下要求：

• 返回类型为该类的引用（*this）。
• 形参为该类的常量引用。可以使用const避免修改被赋值对象。
• 对自赋值的处理。

下面是一个示例：

class MyString{
public:
    MyString(const char* str = NULL); //构造函数
    MyString(const MyString& another); //复制构造函数
    ~MyString(); //析构函数
    MyString& operator=(const MyString& another); //赋值运算符重载
private:
    char* m_data; //用于保存字符串
};

MyString& MyString::operator=(const MyString& another)
{
    if(this == &another) //自赋值的处理
        return *this;

    //释放原有的内存
    delete[] m_data;
    m_data = NULL;

    //复制一个新的字符串
    m_data = new char[strlen(another.m_data) + 1];
    strcpy(m_data, another.m_data);

    return *this; //返回*this
}

上述示例中，在赋值语句执行时，如果被赋值对象和赋值对象为同一对象，直接返回*this就好了。如果不同就先析构原有对象中的字符串，然后再创建新的字符串。

下面是另一个示例：

class Vector{
public:
    Vector(int size = 0){ //构造函数
        m_data = new int[size];
        m_size = size;
    }
    Vector(const Vector& another){ //复制构造函数
        m_data = new int[another.m_size];
        memcpy(m_data, another.m_data, another.m_size*sizeof(int));
        m_size = another.m_size;
    }
    ~Vector(){ //析构函数
        delete[] m_data;
    }
    Vector& operator=(const Vector& another){ //赋值运算符重载
        if(this == &another)
            return *this;

        delete[] m_data;

        m_data = new int[another.m_size];
        memcpy(m_data, another.m_data, another.m_size*sizeof(int));

        m_size = another.m_size;

        return *this;
    }
private:
    int* m_data; //私有成员，用于存储数据
    int m_size; //私有成员，用于存储数据个数
};

int main(){
    Vector a(5);
    Vector b(a);
    Vector c(3);

    c = b = a; //a赋值给b，再把b赋值给c

    return 0;
}

上述示例中，实现了一个所谓的可复制的vector类，通过自定义赋值运算符重载，可以实现向vector对象中赋值，同时可以规避浅拷贝带来的问题，并实现了对自赋值的处理。

注意：自定义类中的赋值运算符如果不小心被赋值为其它类型的值，会导致程序运行崩溃。因此在定义前，需要明确赋值运算符的含义和需求，以便正确而便捷地使用该函数。