C++ 在函数中使用时自身运算符+的奇怪行为（点3D（0,0,0）+点）

我有一门课：

class Point3D : public Point{
    protected:
        float x;
        float y;
        float z;

    public:
        Point3D(){x=0; y=0; z=0;}
        Point3D(const Point3D & point){x = point.x; y = point.y; z = point.z;} 
        Point3D(float _x,float _y,float _z){x = _x; y = _y; z = _z;}

        inline const Point3D operator+(const Vector3D &);

        const Point3D & operator+(const Point3D &point){
            float xT = x + point.getX();
            float yT = y + point.getY();
            float zT = z + point.getZ();
            return Point3D(xT, yT, zT);
        }
...

当我这样使用它时：

Point3D point = Point3D(10,0,10);

一切正常

当我写作时：

Point3D point = Point3D(10,0,10);
Point3D point2 = Point3D(0,0,0) + point();

也可以，点2=点。当我添加超过0,0,0的内容时，它也会起作用

但当我只想：

Point3D point = Point3D(10,0,10);
someFunction( Point3D(0,0,0) + point ); //will get strange (x,y,z)

在我看来，函数得到了一些随机的x，y，z的值。为什么?

更奇怪的是，在这个类似的例子中，一切都将再次正常工作：

---

出现这种奇怪行为的原因是什么？

您从运算符+返回对局部变量的引用，该引用在函数返回后将失效，您需要返回创建的Point3D的副本。

您从运算符+返回对局部变量的引用，该引用在函数返回后将失效，您需要返回所创建的Point3D的副本。

运算符+正在返回一个悬空引用，返回的引用是指在运算符+返回时销毁的Point3D实例。改为：

Point3D operator+(const Point3D &point) const {

因此，将返回一个副本，并将其设置为常量，因为它没有理由更改任何内容。

运算符+返回一个悬空引用，返回的引用是指运算符+返回时销毁的Point3D实例。改为：

Point3D operator+(const Point3D &point) const {

---

因此，将返回一个副本，并将其设置为常量，因为它没有理由更改任何内容。

支持算术运算符的类的典型模式是

class Foo
{
public:
  Foo & operator+=(Foo const & rhs) { /* ... */ return *this; }
  Foo & operator-=(Foo const & rhs) { /* ... */ return *this; }
  Foo & operator*=(Foo const & rhs) { /* ... */ return *this; }
  Foo & operator/=(Foo const & rhs) { /* ... */ return *this; }
};

Foo operator+(Foo const & lhs, Foo const & rhs) { return Foo(lhs) += rhs; }
Foo operator-(Foo const & lhs, Foo const & rhs) { return Foo(lhs) -= rhs; }
Foo operator*(Foo const & lhs, Foo const & rhs) { return Foo(lhs) *= rhs; }
Foo operator/(Foo const & lhs, Foo const & rhs) { return Foo(lhs) /= rhs; }

---

支持算术运算符的类的典型模式是

class Foo
{
public:
  Foo & operator+=(Foo const & rhs) { /* ... */ return *this; }
  Foo & operator-=(Foo const & rhs) { /* ... */ return *this; }
  Foo & operator*=(Foo const & rhs) { /* ... */ return *this; }
  Foo & operator/=(Foo const & rhs) { /* ... */ return *this; }
};

Foo operator+(Foo const & lhs, Foo const & rhs) { return Foo(lhs) += rhs; }
Foo operator-(Foo const & lhs, Foo const & rhs) { return Foo(lhs) -= rhs; }
Foo operator*(Foo const & lhs, Foo const & rhs) { return Foo(lhs) *= rhs; }
Foo operator/(Foo const & lhs, Foo const & rhs) { return Foo(lhs) /= rhs; }

---

直到你说它应该还我这个。现在我-1。是运算符+，不是运算符+=。为什么它要更改任何参数？@Luchian Grigore:困惑了：…现在将其更改回返回副本。我+1愿意，直到你说它应该返回*这个。现在我-1。是运算符+，不是运算符+=。为什么它要更改任何参数？@Luchian Grigore:感到困惑：…现在将其更改回以返回副本。看这篇文章：看这篇文章：我认为运算符+也应该是常量成员函数。运算符+也应该是常量成员函数，IMO.+1 operator+应为自由函数，以+=成员形式实现；虽然最好让它返回常量Foo，这样就不能像A+B=C那样写废话+1 operator+应该是根据+=成员实现的自由函数；虽然最好让它返回常量Foo，这样就不能像A+B=C那样写废话；