超越左手操作员的可能性？ C++中是否存在重写和左手操作的可能性？< /P>

例如，很容易覆盖右手：例如：

class MyClass{
  public inline MyClass operator*(float &other)
  {
     return MyClass(this->Data * other);
  }
};

所以我可以用这样的方法：

MyClass a = MyClass(...) * 0.4f;

如果有人想写，该怎么办：

MyClass a = 0.4f* MyClass();

?

在C#sharp中，这很容易做到，因为存在类扩展。C++也知道一些解决方法吗？

MyClass a = 0.4f* MyClass();
MyClass a = MyClass(...) * 0.4f;

为了使它们有意义，将运算符*声明为类的非成员函数以及单参数构造函数

---

为了使它们有意义，可以将运算符*声明为类的非成员函数以及单参数构造函数。

是的，可以将运算符重载声明为自由函数。在您的情况下，由于操作的两个顺序具有相同的含义，您可以将其中一个委托给另一个：

class MyClass
{
    float data_;

public:
    explicit MyClass(float data) : data_(data) { }   // exposition only

    MyClass operator*(float val) const { return MyClass(data_ * val); }
};

MyClass operator*(float val, MyClass const & x) { return x * val; }

现在，当您拥有

MyClass x

你说

x*4

，它使用了成员重载，但是当你说

4*x

时，它使用了free函数，而free函数又调用了成员函数

注意，通过委托给相反的操作符，我们可以得到一个简单、自由的函数，而不需要知道成员函数的实现。相反，如果您想从头开始重新实现自由函数，则需要访问类的私有成员，这通常通过使自由函数成为朋友来解决，如下所示：

class MyClass
{
    // as above

    friend MyClass operator*(float val, MyClass const & x)
    {
        return MyClass(x.data_ * val);   // access x's private member
    }
};

---

是的，您可以将运算符重载声明为自由函数。在您的情况下，由于操作的两个顺序具有相同的含义，您可以将其中一个委托给另一个：

class MyClass
{
    float data_;

public:
    explicit MyClass(float data) : data_(data) { }   // exposition only

    MyClass operator*(float val) const { return MyClass(data_ * val); }
};

MyClass operator*(float val, MyClass const & x) { return x * val; }

现在，当您拥有

MyClass x

你说

x*4

，它使用了成员重载，但是当你说

4*x

时，它使用了free函数，而free函数又调用了成员函数

注意，通过委托给相反的操作符，我们可以得到一个简单、自由的函数，而不需要知道成员函数的实现。相反，如果您想从头开始重新实现自由函数，则需要访问类的私有成员，这通常通过使自由函数成为朋友来解决，如下所示：

class MyClass
{
    // as above

    friend MyClass operator*(float val, MyClass const & x)
    {
        return MyClass(x.data_ * val);   // access x's private member
    }
};

---

您可以考虑类成员函数，如：

ReturnType Function(TypeOfThisClass* this_, TypeOfParam param, ...)

( 您也可以在

std:：thread

中使用此表单：（即，将类ptr作为参数传递）

)

因此，您的会员是：

class MyClass{
  ....
  friend MyClass operator*(const MyClass& this_, float &other)
  {
     return MyClass(this_.Data * other);
  };

  /*or MyClass operator*(float &other)
  {
     return MyClass(this->Data * other);
  };, which is the same, except you use it with reference not pointer)*/

  friend MyClass operator*(float &other, const MyClass& this_)
  {
     return this_ * other; //you can use the overloaded op. since it is defined above (first arg is class)
  };
};

---

如果您想访问类中的

受保护的
和
私有的
数据（在OOP中应该是这样），您应该只使用
朋友
关键字。
您可以考虑类成员函数，如：

ReturnType Function(TypeOfThisClass* this_, TypeOfParam param, ...)

(
您也可以在
std:：thread
中使用此表单：（即，将类ptr作为参数传递）

)

因此，您的会员是：

class MyClass{
  ....
  friend MyClass operator*(const MyClass& this_, float &other)
  {
     return MyClass(this_.Data * other);
  };

  /*or MyClass operator*(float &other)
  {
     return MyClass(this->Data * other);
  };, which is the same, except you use it with reference not pointer)*/

  friend MyClass operator*(float &other, const MyClass& this_)
  {
     return this_ * other; //you can use the overloaded op. since it is defined above (first arg is class)
  };
};

<>你只应该使用<代码>朋友< /Cord>关键字，如果你想访问类中的<代码>保护<代码>和<代码>私下<代码>数据（应该是OOP中的情况）。< /P>是的，C++有自由函数，我不称之为解决方案。你的例子也错了。不能将<代码> 0.4f < /代码>作为<代码>浮点和<代码>。是的，C++有自由函数，我不称之为解决方案。你的例子也错了。您不能传递
0.4f
，因为
float&
friend
允许访问私有数据和受保护的数据。这里通常的习惯用法是定义公共
MyClass&MyClass:：operator*=（MyClass const&rhs），然后使用它定义全局
操作符*
。@James Kanze我的意思是“受保护的”编辑后不公开可见。”。还有，你说的那个成语是什么，也许我可以把它添加到答案中。我只是写下了编译器是如何“看到”函数的，这样他就能更好地理解发生了什么。我所说的习惯用法是，如果你支持
a op b
，你也应该支持
a op=b
。后者通常应该是一个成员（因为你不想在左手边进行转换），前者很容易用后者来实现，因此甚至不需要是朋友。哦，我想我明白了，所以
t&operator*=（float-rhs）{/**/return*this；}
在类
t
和
t operator内*（float-lhs，T-rhs）{rhs*=lhs；return-rhs；}
类外。
friend
允许访问私有数据以及受保护的数据。这里的惯用用法是定义公共
MyClass&MyClass:：operator*=（MyClass const&rhs）；
，然后使用它定义全局
操作符*
。@James Kanze我的意思是“受保护的”，编辑的，不公开可见。还有你说的习惯用法是什么，也许我可以将它添加到答案中。我只是写下了编译器如何“看到”我所说的习惯用法是，如果你支持
a op b
，你也应该支持
a op=b
。后者通常应该是一个成员（因为你不想在左边进行转换），前者很容易用后者实现，所以甚至不需要成为朋友。哦，我想我明白了，所以
t&operator*=（float-rhs）{/**/return*this；}
在类内
t
和
t operator*（float-lhs，t-rhs）{rhs*=lhs；return-rhs；}
在类外。