这样重载操作符“＝”为什么不行？

Question

偶定义了一个类
class CFPoint  
{
public:
CFPoint();
CFPoint(double x, double y);
virtual ~CFPoint();
CFPoint operator =(CFPoint fpt);

public:
double m_x;
double m_y;
};
其中的CFPoint operator =(CFPoint fpt)函数如下CFPoint CFPoint::operator =(CFPoint fpt)
{
CFPoint tmpFpt;

tmpFpt.m_x = fpt.m_x;
tmpFpt.m_y = fpt.m_y; return tmpFpt;
}可是调用时却不对，如：
CFPoint fpt1, fpt2(100., 100.);
fpt1 = fpt2;fpt1没有得到，我知道是函数有问题，但不知是什么问题，请赐教！

Answer 1

明白了，应该这样写：void CFPoint::operator =(CFPoint fpt)
{
    m_x = fpt.m_x;
    m_y = fpt.m_y;
}
解决了，但分给谁呢？

Answer 2

CFPoint& operator = ( const CFPoint& rhs );

Answer 3

CFPoint& operator = ( const CFPoint& rhs )
{
m_x = rhs.m_x;
m_y = rhs.m_y;
return *this;
}这是C＋＋大师们的做法，（Effective C++）

Answer 4

sorry,应该是
const CFPoint& operator = ( const CFPoint& rhs )
{
m_x = rhs.m_x;
m_y = rhs.m_y;
return *this;
}

Answer 5

m_x = fpt.m_x;
m_y = fpt.m_y;

return *this;

Answer 6

强烈建议楼主阅读Essential C++,C++ Primer,Effective C++,More Effective C++.了解大师们的编程习惯。

Answer 7

DentistryDoctor(雅克医生(潜心修内功)) 是对的.

Answer 8

多谢诸位啊，尤其DentistryDoctor(雅克医生(潜心修内功)),谢谢你推荐的好书。

Answer 9

CFPoint CFPoint::operator =(CFPoint fpt)
{

this.m_x = fpt.m_x;
this.m_y = fpt.m_y; return tmpFpt;
}建议看 c++ 的基础书籍条款15: 让operator=返回*this的引用c++的设计者bjarne stroustrup下了很大的功夫想使用户自定义类型尽可能地和固定类型的工作方式相似。这就是为什么你可以重载运算符，写类型转换函数（见条款m5），控制赋值和拷贝构造函数，等等。他做了这么多努力，那你最少也该继续做下去。让我们看看赋值。用固定类型的情况下，赋值操作可以象下面这样链起来：int w, x, y, z;w = x = y = z = 0;所以，你也应该可以将用户自定义类型的赋值操作链起来：string w, x, y, z;               // string是由标准c++库
                                 // “自定义”的类型
                                 // (参见条款49)w = x = y = z = "hello";因为赋值运算符的结合性天生就是由右向左，所以上面的赋值可以解析为：w = (x = (y = (z = "hello")));很值得把它写成一个完全等价的函数形式。除非是个lisp程序员，否则下面的例子会很令人感到高兴，因为它定义了一个中缀运算符：w.operator=(x.operator=(y.operator=(z.operator=("hello"))));这个格式在此很具有说明性，因为它强调了w.operator=, x.operator=和y.operator=的参数是前一个operator=调用的返回值。所以operator=的返回值必须可以作为一个输入参数被函数自己接受。在一个类c中，缺省版本的operator=函数具有如下形式（见条款45）：c& c::operator=(const c&);一般情况下几乎总要遵循operator=输入和返回的都是类对象的引用的原则，然而有时候需要重载operator=使它能够接受不同类型的参数。例如，标准string类型提供了两个不同版本的赋值运算符：string&                            // 将一个string
operator=(const string& rhs);      // 赋给一个stringstring&                            // 将一个char*
operator=(const char *rhs);        // 赋给一个string请注意，即使在重载时，返回类型也是类的对象的引用。c++程序员经常犯的一个错误是让operator=返回void，这好象没什么不合理的，但它妨碍了连续（链式）赋值操作，所以不要这样做。另一个常犯的错误是让operator=返回一个const对象的引用，象下面这样：class widget {
public:
  ...                                            
  const widget& operator=(const widget& rhs);    
  ...                                            
};                                               这样做通常是为了防止程序中做象下面这样愚蠢的操作：widget w1, w2, w3;...(w1 = w2) = w3;         // w2赋给w1, 然后w3赋给其结果
                        // (给operator=一个const返回值
                        // 就使这个语句不能通过编译)这可能是很愚蠢，但固定类型这么做并不愚蠢：int i1, i2, i3;...(i1 = i2) = i3;                // 合法! i2赋给i1
                               // 然后i3赋给i1!这样的做法实际中很少看到，但它对int来说是可以的，对我和我的类来说也可以。那它对你和你的类也应该可以。为什么要无缘无故地和固定类型的常规做法不兼容呢？采用缺省形式定义的赋值运算符里，对象返回值有两个很明显的候选者：赋值语句左边的对象（被this指针指向的对象）和赋值语句右边的对象（参数表中被命名的对象）。哪一个是正确的呢？例如，对string类（假设你想在这个类中写赋值运算符，参见条款11中的解释）来说有两种可能：string& string::operator=(const string& rhs)
{  ...  return *this;            // 返回左边的对象
}string& string::operator=(const string& rhs)
{  ...  return rhs;              // 返回右边的对象
}对你来说，这好象是拿六个一和十二的一半来比较一样为难。实际上他们有很大的不同。首先，返回rhs的那个版本不会通过编译，因为rhs是一个const string的引用，而operator=要返回的是一个string的引用。当要返回一个非const的引用而对象自身是const时，编译器会给你带来无尽的痛苦。看起来这个问题很容易解决——只用象这样重新声明operator=：string& string::operator=(string& rhs)   { ... }这次又轮到用到它的应用程序不能通过编译了！再看看最初那个连续赋值语句的后面部分：x = "hello";                     // 和x.op=("hello");相同因为赋值语句的右边参数不是正确的类型——它是一个字符数组，不是一个string——编译器就要产生一个临时的string对象（通过stirng构造函数——参见条款m19）使得函数继续运行。就是说，编译器必须产生大致象下面这样的代码：const string temp("hello");      // 产生临时stringx = temp;                        // 临时string传给operator=编译器一般会产生这样的临时值（除非显式地定义了所需要的构造函数——见条款19），但注意临时值是一个const。这很重要，因为它可以防止传递到函数内的临时值被修改。否则，程序员就会很奇怪地发现，只有编译器产生的临时值可以修改而他们在函数调用时实际传进去的参数却不行。（关于这一点是有事实根据的，早期版本的c++允许这类的临时值可以被产生，传递，修改，结果很多程序员感到很奇怪）现在我们就可以知道如果string的operator=声明传递一个非const的stirng参数，应用程序就不能通过编译的原因了：对于没有声明相应参数为const的函数来说，传递一个const对象是非法的。这是一个关于const的很简单的规定。所以，结论是，这种情况下你将别无选择：当定义自己的赋值运算符时，必须返回赋值运算符左边参数的引用，*this。如果不这样做，就会导致不能连续赋值，或导致调用时的隐式类型转换不能进行，或两种情况同时发生。