演算子*はHで宣言さオペレータとCPPファイル

Question

ために、私は次のクラス（ヘッダーファイル）を有する不一致：

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); 
} 

ここに反し： no match for operator*

私は宣言し、私の​​メインプログラムにヘッダーファイルを含めました。私は、次のメッセージが表示されます：

main.cppに：11：エラー：「2.0E + 0 * v2の」の「演算子*」

そして私はなぜ理解できないためマッチしません。このエラーを発生させるコード行（メインファイル）は次のとおりです。

Kinetics v4 = 2.0 * v2; 

アドバイスは歓迎します。ありがとうございました。

Answer 1

これは、ほとんどのバイナリ演算子をメンバ関数として宣言することは悪い考えです。それらは非対称です。あなたは必要です

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); 
}; 

Answer 2

二項演算子を実装するための一般的なパターンは、複合代入演算子の点であります。これにより、友人の必要性が回避され、一貫した行動が得られます。あなたのケースでは

、これは次のようになります。

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. 
}