何时将 C++ 中的运算符重载为用户定义数据结构的成员，何时不重载？我完全迷失了

选择非成员算子的一个原因是对称性。所谓对称性，我的意思是某些算子应该是可交换的。

标量乘法就是一个很好的例子。想要两者和允许的表达式是合理的。但是，如果要用作左操作数，则必须使用非成员函数。不能使用成员函数，因为它不是对象。实际上，您必须定义两个函数，一个用于 ，另一个用于 。(s * vec)(vec * s)ssVector3Doperator*(s * vec)(vec * s)

流运算符是必须使用非成员运算符函数的另一种情况，因为左操作数不是 Vector3D 对象。

以下程序中的评论进一步解释。它包含几个您可能会发现有用的成语，包括隐藏的朋友成语。此外，该程序还修复了 @Pete Becker 发现的两个问题：

1. operator*应通过调用 来实现。在两个不同的函数中对同一组操作进行编码很容易出错。迟早，两人会不同步！operator*=
2. OP 中的函数调用未定义的行为，因为它们做出了毫无根据的假设，即成员变量 ，并且像数组的元素一样存储。下面的代码使用一个实际的数组。operator[]xyz

// main.cpp
#include <array>
#include <cstddef>
#include <format>
#include <iostream>

class Vector3D
{
    enum : std::size_t { zero, one, two, three };
    using value_type = double;
    std::array<value_type, three> v{};
public:
    value_type& x() noexcept { return v[zero]; }
    value_type& y() noexcept { return v[one]; }
    value_type& z() noexcept { return v[two]; }

    value_type const& x() const noexcept { return v[zero]; }
    value_type const& y() const noexcept { return v[one]; }
    value_type const& z() const noexcept { return v[two]; }

    Vector3D() noexcept
        = default;
    Vector3D(
        value_type const x,
        value_type const y,
        value_type const z) noexcept
    {
        this->x() = x;
        this->y() = y;
        this->z() = z;
    }
    Vector3D& operator*=(value_type const s) noexcept
    {
        // operator*= must be a member function.
        x() *= s;
        y() *= s;
        z() *= s;
        return *this;
    }
    friend Vector3D operator*(Vector3D v, value_type const s) noexcept
    {
        // Note that v is a value parameter that receives 
        // a copy of its argument. Changing v here, will not 
        // change the original argument used when operator* 
        // is invoked.
        //
        // This function could also be implemented as a 
        // member function (with only one parameter, s).
        //
        // It is a common idiom for operator* to be implemented 
        // by calling member function operator*= to do the work.
        // 
        // The following return statement can be broken into pieces:
        // 
        //    1. Parameter v is like a "local" variable. It is a 
        //       Vector3D object, but it is not *this object.
        //
        //    2. Because v is a Vector3D object, we can use 
        //       operator*= to perform scalar multiplication on it.
        //
        //    3. operator*= returns a reference to v, which now 
        //       holds the result of scalar multiplication.
        //
        //    4. The return statement copies the result, and 
        //       sends it back to the calling routine.
        return v *= s;
    }
    friend Vector3D operator*(value_type const s, Vector3D v) noexcept
    {
        // In order to have a symmetric operator*, where s 
        // can appear either first or second, we have to code 
        // a second version of operator*.
        //
        // This function cannot be a member function, because 
        // the first operand, s, is not an object!
        //
        // Note that the two operator* functions use the 
        // "hidden friend" idiom.
        return v *= s;
    }
    Vector3D& operator+=(Vector3D const& that) noexcept
    {
        // operator+= must be a member function.
        x() += that.x();
        y() += that.y();
        z() += that.z();
        return *this;
    }
    friend Vector3D operator+(Vector3D a, Vector3D const& b)
    {
        // operator+ can be implemented either as a 
        // member function (with one parameter), or as 
        // a non-member function (with two parameters).
        //
        // I have chosen to use a non-member function, 
        // so that I can treat the left operand as 
        // a "local" variable.
        //
        // Note that parameter `a` is a value parameter.
        // It receives a copy of its argument.
        //
        // Unlike scalar multiplication, there is no "symmetry" 
        // problem here, so I only need one version of 
        // operator+.
        //
        // You can do an internet search to learn more about 
        // the "hidden friend" idiom used here. I like the 
        // video by Dan Saks:
        // https://www.youtube.com/watch?v=POa_V15je8Y
        return a += b;
    }
    std::string to_string() const
    {
        return std::format("[{}, {}, {}]", x(), y(), z());
    }
    friend std::ostream& operator<< (
        std::ostream& ost,
        Vector3D const& v)
    {
        // Another hidden friend.
        //
        // Once again, this function must be implemented as 
        // a non-member function, because the left operand 
        // is not a Vector3D object.
        ost << v.to_string();
        return ost;
    }
    value_type& operator[](std::size_t const i) noexcept
    {
        // Trap subscripting errors.
        return v.at(i);
    }
    value_type const& operator[](std::size_t const i) const noexcept
    {
        // Trap subscripting errors.
        return v.at(i);
    }
};
int main()
{
    Vector3D a{ 1, 2, 3 };
    a *= 2;
    auto b = a * 3;
    std::cout
        << "a     : " << a
        << "\nb     : " << b
        << "\nb * 2 : " << b * 2
        << "\n2 * b : " << 2 * b
        << "\na + b : " << a + b
        << "\n\n";
    return 0;
}
// end file: main.cpp

输出：

a     : [2, 4, 6]
b     : [6, 12, 18]
b * 2 : [12, 24, 36]
2 * b : [12, 24, 36]
a + b : [8, 16, 24]