当我的对象位于 C++ 的右侧时，如何重载运算符 *？

发布于 2024-10-15 07:17:08 字数 170 浏览 5 评论 0原文

我想在我的类中实现“operator *”重载，这样我就能够执行以下操作：

Rational a(1, 2), b;
b = 0.5 * a; // b = 1/4

注意 b 在右侧，有没有办法在内部做这样的事情”理性”类？

原文

I want to implement "operator * " overloading INSIDE my class, so I would be able to do the following:

Rational a(1, 2), b;
b = 0.5 * a; // b = 1/4

Notice that b is on the right side, is there a way to do such a thing inside "Rational" class?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

云醉月微眠 2024-10-22 07:17:08

是：

class Rational {
  // ...
  friend Rational operator*(float lhs, Rational rhs) { rhs *= lhs; return rhs; }
};

注意：这当然是对 friend 关键字的滥用。它应该是一个免费函数。

Yes:

class Rational {
  // ...
  friend Rational operator*(float lhs, Rational rhs) { rhs *= lhs; return rhs; }
};

Note: this is of course an abuse of the friend keyword. It should be a free function.

回复收藏 0 原文

帅气尐潴 2024-10-22 07:17:08

不可以。您必须将 operator* 定义为自由函数。当然，您可以根据第二个参数的成员函数来实现它。

回复收藏 0 原文

压抑⊿情绪 2024-10-22 07:17:08

答案是否定的，你不能，但由于浮点值位于左侧，你可能期望“0.5 * a”的结果类型将是双精度的。在这种情况下，您可以考虑对转换运算符进行一些处理。请注意，添加“pow(a, b)”只是为了说明这个想法。

  1 #include <stdio.h>
  2 #include <math.h>
  3 
  4 class Complicated
  5 {
  6 public:
  7     Complicated(int a, int b) : m_a(a), m_b(b)
  8     {
  9     }   
 10      
 11     Complicated(double a) : m_a(a)
 12     {
 13     }
 14     
 15     template <typename T> operator T()
 16     {
 17         return (T)(pow(10, m_b) * m_a);
 18     }   
 19     
 20     void Print()
 21     {
 22         printf("(%f, %f)\n", m_a, m_b);
 23     }   
 24     
 25 private:
 26     double m_a;
 27     double m_b;
     28 };  
 29
 30 
 31 int main(int argc, char* argv[])
 32 {
 33     Complicated pr(1, 2);
 34     Complicated c = 5.1 * (double) pr;
 35     c.Print();
 36 }
 37

Answer is no you cannot, but since float value is on left side you may expect that type of result from "0.5 * a" will be double. In that case you may consider doing something about conversion operator. Please note that "pow(a, b)" is added only to illustrate the idea.

  1 #include <stdio.h>
  2 #include <math.h>
  3 
  4 class Complicated
  5 {
  6 public:
  7     Complicated(int a, int b) : m_a(a), m_b(b)
  8     {
  9     }   
 10      
 11     Complicated(double a) : m_a(a)
 12     {
 13     }
 14     
 15     template <typename T> operator T()
 16     {
 17         return (T)(pow(10, m_b) * m_a);
 18     }   
 19     
 20     void Print()
 21     {
 22         printf("(%f, %f)\n", m_a, m_b);
 23     }   
 24     
 25 private:
 26     double m_a;
 27     double m_b;
     28 };  
 29
 30 
 31 int main(int argc, char* argv[])
 32 {
 33     Complicated pr(1, 2);
 34     Complicated c = 5.1 * (double) pr;
 35     c.Print();
 36 }
 37

回复收藏 0 原文

~没有更多了~