在h和CPP文件中声明的操作符*操作符不匹配

no match for operator * operator declared in h and cpp file

本文关键字：操作符 不匹配 声明 CPP 文件      更新时间：2023-10-16

我有以下类(头文件):

class Kinetics{
    double x;
    double y;
    double z;
public:
    Kinetics();
    Kinetics(double x_, double y_, double z_);
    Kinetics(const Kinetics & obj);
    ~Kinetics();
    double get_x();
    void set_x(double x_);
    Kinetics operator + (const Kinetics & obj);
    Kinetics operator * (double c);
    void operator = (const Kinetics & obj);
};

操作符+和*已被实现(cpp)为:

Kinetics Kinetics::operator + (const Kinetics & obj){
    Kinetics aux(x + obj.x, y + obj.y, z + obj.z);
    return(aux);
}

和

Kinetics Kinetics::operator * (double c){
   Kinetics aux(x * c, y * c, z * c);
   return(aux);
}

与这里相反:没有匹配操作符*

我已经在主程序中声明并包含了头文件。我得到以下消息:

main.cpp:11:错误:' 2.0e+0 * v2 '中的' operator* '不匹配

我不知道为什么。产生此错误的代码行(主文件)是:

Kinetics v4 = 2.0 * v2;

欢迎提供任何建议。谢谢你。

这就是为什么将大多数二进制操作符声明为成员函数是一个坏主意——它们是不对称的。你需要

class Kinetics;
Kinetics operator *(const Kinetics& k, double c);
Kinetics operator *(double c, const Kinetics&k) { return k*c; }
class Kinetics{
    double x;
    double y;
    double z;
public:
    Kinetics();
    Kinetics(double x_, double y_, double z_);
    Kinetics(const Kinetics & obj);
    ~Kinetics();
    double get_x();
    void set_x(double x_);
    Kinetics operator + (const Kinetics & obj);
    friend Kinetics operator * (const Kinetics& k, double c);
    void operator = (const Kinetics & obj);
};

就复合赋值操作符而言，有一种实现二元操作符的通用模式。这避免了对朋友的需要，并使你的行为一致。

在你的例子中，它看起来像这样:

class Kinetics {
  // all that stuff
public:
  Kinetics& operator +=(const Kinetics& rhs) {
    // implemented inline for less typing
    x += rhs.x;
    y += rhs.y;
    z += rhs.z;
    return *this;
  }
  Kinetics& operator *=(double rhs) {
    x *= rhs;
    y *= rhs;
    z *= rhs;
    return *this;
  }
}
// These are non-member, non-friend functions
// Again inline for my convenience
inline Kinetics operator +(Kinetics lhs, const Kinetics& rhs) {
  lhs += rhs; // lhs is already a copy
  return lhs;
}
inline Kinetics operator *(Kinetics lhs, double rhs) {
  lhs *= rhs; // You may be tempted to write "return lhs *= rhs;".
  return lhs; // Don't. That would prevent RVO.
}
inline Kinetics operator *(double lhs, Kinetics rhs) {
  rhs *= lhs; // Thanks for this being commutative
  return rhs; // this implementation works.
}
相关文章：