赋值运算符“=”的重载 (浅拷贝与深拷贝)

本文探讨了C++中赋值运算符的默认行为及其可能导致的问题,特别是对于包含指针成员的类。文章详细解释了如何通过重载赋值运算符来实现深拷贝,从而避免指针悬挂等问题。

赋值运算符是双目运算符,如果没有用户自定义的赋值运算符函数,那么系统将自动地为其生成一个默认的赋值运算符函数实现对象的赋值

Complex c1(10,20),c2;

就调用默认的赋值运算符函数,将对象c1的数据成员逐一拷贝到对象c2中,即

c2.real=20;

c2.imag=10;

虽然默认的赋值运算符函数能够实现很多拷贝,但是有很多时候它是不行的,这时需要自己对赋值运算符进行重载

浅拷贝产生的指针悬挂问题     

浅拷贝:通过对象之间的一一赋值,使得对象中的指针指向同一块内存,使得出现了以下三个问题:(1.两次析构同一块内存,系统崩溃;2.修改一个地址造成其他的对象成员被修改;3.当删除一个指针指向的内容,则另一个对象不能正常访问该指针指向内存中的内容。

在浅拷贝中,是简单的赋值给另一个成员,如果里面有指针,则导致两个对象的指针指向相同的内存。由于指针在两个对象例指向相同的变量,当一个对象改变的时候则另一个对象会跟着改变。另一方面,我们不知道究竟由谁在负责析构指针开辟的堆内存,这样就会出现一下错误。调析构函数则析构两次,破坏内存;不调用析构则没有析构,造成内存泄露。

#include<iostream>
#include<string.h>
using namespace std;
class STRING
{
public:
    STRING(char *s)
    {
        cout<<"constructor  called"<<endl;
        ptr=new char[strlen(s)+1];
        strcpy(ptr,s);
    }
    ~STRING()
    {
        cout<<"Destructing called---"<<ptr<<endl;
        delete []ptr;
    }
private:
    char *ptr;
};
int main()
{
    STRING p1("book");
    STRING p2("jeep");
    p2=p1;
    return 0;

}






当类里有成员是指针时,并且动态分配了内存,我们应该重载赋值函数,实现一个深拷贝(physical copy)。

1.首先我们要检查是不是自身赋值,如果是应该立即返回(不要做其他事情);

2.如果不是自身赋值,我们要释放指针所指向的堆内存;

3.把右边对象的成员拷贝并值赋给左边对象的成员值;

4.最后,我们要返回返回本类对象的一个常引用,避免链式赋值(返回const对象引用,不让x=y=z)。



#include<iostream>
#include<cstring>
using namespace std;
class STRING
{
public:
    STRING(char *pt)
    {
        cout<<"constructing called   "<<endl;
        ptr=new char[strlen(pt)+1];
        strcpy(ptr,pt);
    }
    ~STRING()
    {
        cout<<"Destructing called   "<<ptr<<endl;
        delete ptr;
    }
    STRING& operator=(const STRING &);
private:
    char *ptr;
};
STRING& STRING::operator=(const STRING &p)   //重载赋值运算符必须是类的成员,重载赋值运算符应返回一个类的对象的引用。
{
    if(this==&p) return *this;   //

//用this和p的地址来检查是否是对自身的赋值的情况,如果调用赋值运算符函数的地址

                                                         //和被赋值的对象的地址相等,则说明是同一个对象,就返回当前对象。


    delete []ptr;    //如果不是对自身赋值的话,先将p2所指向的旧区域释放掉
    ptr=new char[strlen(p.ptr)+1];  //重新给p2分配一个新区域
    strcpy(ptr,p.ptr);      //将后者地址中的值拷贝给前者
    return *this;   //返回自引用到下面语句@   使函数能够继续向下执行
}
int main()
{
    STRING p1("book");
    STRING p2("jeep");
    p2=p1;      //@     p2=p1相当于p2.operator=(p1);
    return 0;

}




#include<iostream>
#include<cstring>
using namespace std;
class STRING
{
public:
    STRING(char *pt)
    {
        cout<<"constructing called   "<<endl;
        ptr=new char[strlen(pt)+1];
        strcpy(ptr,pt);
    }
    ~STRING()
    {
        cout<<"Destructing called   "<<ptr<<endl;
        delete ptr;
    }
    void operator=(const STRING &);
private:
    char *ptr;
};
void STRING::operator=(const STRING &p)   //函数返回为void
{
    if(this==&p) return ;
    delete ptr;
    ptr=new char[strlen(p.ptr)+1];
    strcpy(ptr,p.ptr);
//    return *this;
}
int main()
{
    STRING p1("book");
    STRING p2("jeep");
    p2=p1;          //@     p2=p1相当于p2.operator=(p1);   上面函数调用完成返回到此处  开始继续执行下面的c语句
    return 0;
}

结果都是


### 重载赋值运算符 `=` 的方法实现 在 C++ 中,赋值运算符 `=` 的重载是实现自定义类行为的重要组成部分。默认情况下,编译器会为每个类自动生成一个赋值运算符,该运算符对类的所有数据成员执行逐成员的浅拷贝。然而,在涉及资源管理(如动态内存、文件句柄等)时,必须显式重载赋值运算符以避免资源泄漏或重复释放等问题。 #### 基本格式 赋值运算符重载函数的格式包括以下几个关键部分: - **返回值类型**:通常是类类型的引用(`类名&`),以支持链式赋值操作。 - **函数名**:使用 `operator=` 表示重载赋值运算符。 - **参数列表**:通常是一个常量引用类型的参数(`const 类名&`),以避免不必要的拷贝。 - **返回值**:应返回当前对象的引用(`*this`)。 示例代码如下: ```cpp class BGPart { public: int s; BGPart& operator=(const BGPart& p) { if (this != &p) { s = p.s * 10; } return *this; } }; ``` 此实现中,首先检查是否是自赋值(即对象赋值给自己),以避免不必要的操作;然后执行实际的赋值逻辑;最后返回当前对象的引用以支持链式赋值[^4]。 #### 支持多参数赋值 虽然赋值运算符通常只接受一个参数(即另一个对象的引用),但也可以接受额外的参数,前提是这些参数必须具有默认值。例如: ```cpp Array& operator=(const Array& arr, int a = 100); ``` 这种方式允许在赋值过程中传递额外的控制参数,但并不常见,主要用于特定的扩展需求[^1]。 #### 避免自赋值问题 在实现赋值运算符时,必须处理自赋值的情况。如果不进行判断,直接对对象自身的资源进行释放和重新分配,可能导致未定义行为。因此,应在函数开头加入类似 `if (this != &p)` 的判断[^4]。 #### 返回类型的重要性 返回类型为类的引用(`类名&`)是为了支持连续赋值,例如 `a = b = c;`。若返回类型为 `void` 或者返回一个临时对象,则无法支持这种链式操作。因此,返回 `*this` 是标准做法[^2]。 #### 默认赋值运算符的行为 如果程序没有显式提供赋值运算符重载函数,编译器会自动生成一个默认版本。该默认实现会对每个成员变量进行逐个赋值。在大多数情况下,这种默认行为是合适的,除非类中包含指针或需要深拷贝的资源[^3]。 --- ### 示例代码 以下是一个完整的示例,展示了如何实现一个带有资源管理的类的赋值运算符: ```cpp #include <iostream> using namespace std; class MyString { private: char* data; public: MyString(const char* str = "") { data = new char[strlen(str) + 1]; strcpy(data, str); } ~MyString() { delete[] data; } MyString(const MyString& other) { data = new char[strlen(other.data) + 1]; strcpy(data, other.data); } MyString& operator=(const MyString& other) { if (this != &other) { char* newData = new char[strlen(other.data) + 1]; strcpy(newData, other.data); delete[] data; data = newData; } return *this; } void print() const { cout << data << endl; } }; int main() { MyString s1("Hello"); MyString s2("World"); s2 = s1; s2.print(); // 输出: Hello } ``` 此示例中,`MyString` 类管理一个动态分配的字符数组。赋值运算符重载函数确保在赋值时进行深拷贝,避免了指针共享的问题。 --- ### 注意事项 - **自赋值检查**:所有赋值运算符实现都应包含 `if (this != &other)` 以避免自赋值带来的问题。 - **资源释放顺序**:在重新分配资源之前,先创建新资源,再释放旧资源,以确保异常安全。 - **返回类型**:必须返回当前对象的引用,以支持链式赋值。 - **默认行为**:仅当默认赋值行为不满足需求时才需要手动重载。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序猿的探索之路

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值