c++,operator=

operator=为什么值得注意?

从语法上讲,下面的程序可以编译通过,我在另一篇笔记示例里面也这样用了。

class A1
{
public:
    int operator=(int a)//参数是int,语法通过但逻辑不通。
    {
        return 8;
    }

    int operator+(int a)
    {
        return 9;
    }

    int operator=(A1 &a)//返回int,既无意义也不合逻辑,
    {
        cout<<"operator=(A1 &a)"<<endl;
        return 0;
    }
};  
// http://www.cnblogs.com/mylinux/p/4094808.html

 

实际上如图拷贝构造函数一样,我们要考虑更多问题:

1.浅拷贝的问题。[1]//构造函数,operator=与构造函数的道理相同。

注意事项:[2]  //Effective_C++

2.为什么opreator=要返回*this?
  为了支持a=b=c这样的连锁调用
3.为什么不返回const GoodObject&?
  为了和编译器(a=b)=c这样的操作兼容
4.为什么要传入const GoodObject& rhs
  主要支持以下操作:
  GoodObject a;
  const GoodObject b;
  a = b;
5.为什么要有if (this != &rhs)这样的判断
  主要是避免自我赋值a=a这样的情况发生.
6.不要忘记重写拷贝构造函数

 

7.示例:[3]

参考网友的示例:

class SampleClass
{
private:
         int a;
         double b;
         float* p;
public:
         SampleClass& operator= (const SampleClass& s)
         {
                   if(this == &s) return *this; // 解决自我赋值的一句话
                   a = s.a;
                   b = s.b;
                   delete p;
                   p = new float(*s.p);
                   return *this;
         }
};

 书上是这样写的://虽然多了个tmp,但建议参考

SampleClass& operator= (const SampleClass& s)
{
         if(this == &s) return *this; //
         a = s.a;
         b = s.b;
         float* tmp = p; // 先保存了旧的指针
         p = new float(*s.p); // 再申请新的空间,如果申请失败,p仍然指向原有的地址空间
         delete tmp; // 能走到这里,说明申请空间是成功的,这时可以删掉旧的内容了
         return *this;
}

 

参考:

1.C++深浅拷贝浅析
  http://www.jizhuomi.com/software/291.html

2.operator=函数.

  http://blog.csdn.net/howlet2/article/details/5090756

3.读书笔记_Effective_C++_条款十一:在operator=中处理自我赋值
  http://www.cnblogs.com/jerry19880126/archive/2013/03/21/2972648.html

C++中,赋值运算符(`operator=`)用于将一个对象的值赋给另一个对象。默认情况下,C++提供了一个浅拷贝的赋值运算符,但有时我们需要对其进行重构以实现深拷贝或其他自定义操作。 要重构赋值运算符,我们需要定义一个成员函数,并按照以下步骤进行操作: 1. 检查自我赋值:在进行任何赋值之前,我们应该检查源对象和目标对象是否是同一个对象。如果是同一个对象,那么不需要进行任何操作,直接返回当前对象。 2. 释放资源:如果目标对象已经拥有一些资源(例如动态分配的内存),我们应该首先释放这些资源,以防止内存泄漏。 3. 拷贝数据:根据需要进行深拷贝或其他自定义操作,将源对象的数据复制到目标对象中。 4. 返回引用:最后,返回当前对象的引用,以支持连续赋值操作(例如`a = b = c`)。 下面是一个简单示例,演示了如何重构赋值运算符: ```cpp class MyClass { private: int* data; public: // 构造函数 MyClass(int value) { data = new int(value); } // 析构函数 ~MyClass() { delete data; } // 重构赋值运算符 MyClass& operator=(const MyClass& other) { // 检查自我赋值 if (this == &other) { return *this; } // 释放资源 delete data; // 深拷贝数据 data = new int(*other.data); // 返回引用 return *this; } }; ``` 在上面的示例中,我们定义了一个简单的类`MyClass`,它包含一个动态分配的整数指针`data`。在赋值运算符重构中,我们首先检查自我赋值,然后释放目标对象的资源(如果有的话),并通过深拷贝源对象的数据来创建一个新的资源。 这只是一个简单示例,实际中的重构可能涉及更复杂的操作,具体取决于类的特定需求。重构赋值运算符可以确保正确的对象拷贝和资源管理,以避免内存泄漏和其他问题。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值