クラスオブジェクトを処理するオーバーロード演算子？

Question

メインの機能でf2=11; f3=12;を繰り返す必要はありません。このコードは、最も一般的な演算子のオーバーロード用です。

class FLOAT{ 
    private: 
     float x; 
    public: 
     FLOAT(){ x=0.0; } 
     void setFloat(float f)  { x=f; } 
     float getFloat()   { return x;}; 
     FLOAT operator+(FLOAT obj) {x=x+obj.x; return *this;}; 
     FLOAT operator-(FLOAT obj) {x=x-obj.x; return *this;}; 
     FLOAT operator*(FLOAT obj) {x=x*obj.x; return *this;}; 
     FLOAT operator/(FLOAT obj) {x=x/obj.x; return *this;}; 
     FLOAT& operator=(const FLOAT& obj) {this->x=obj.x; return *this; }; 
     FLOAT& operator=(const float& y) {this->x=y; return *this; }; 
}; 

int main() { 
    FLOAT f,f2,f3; 
    f2=11; 
    f3=12; 

    f=f3-f2; 
    cout<<"f3-f2 ="<<f.getFloat()<<endl; 


    f2=11; 
    f3=12; 
    f=f3+f2; 
    cout<<"f3+f2 ="<<f.getFloat()<<endl; 

    f2=11; 
    f3=12; 
    f=f3*f2; 
    cout<<"f3*f2 ="<<f.getFloat()<<endl; 

    f2=11; 
    f3=12; 
    f=f3/f2; 
    cout<<"f3/f2 ="<<f.getFloat()<<endl; 

    system("pause"); // to pause console screen 
    return 0; 
} 

Answer 1

@ Oliの答えはかなりあなたに何を言いますか最小あなたのコードを動作させるために必要なこと。しかし、あなたのクラスの実装には多くの欠陥があることがわかります（@Oliも知っています）。

FLOATを実装しているので、Doubleの実装について説明します（FLOATの実装は同様です）。

class Double { 
    double data; 
public: 
    Double (double p=0.0) : data(p){} 
    double value() { return data; } 
    Double & operator+=(Double const & other) 
    { 
     data += other.data; 
     return *this; 
    } 
    Double & operator-=(Double const & other) 
    { 
     data -= other.data; 
     return *this; 
    } 
    //... 
}; 

あなたはoperator=(Double const&)とDouble(Double const&)を実装する必要はありません。コンパイラで生成されたもので十分でしょう。コンストラクタはdoubleという1つの引数を取るため、operator=(double const &)も実装する必要はありません。コンパイラは、コピーセマンティクスをコンストラクタとともに生成し、それを処理します。

は今、私はそれぞれoperator+=とoperator-=の面でoperator+とoperator-を実施してきたこの、

//implement operator+ and operator- as non-member functions 
Double operator+(Double a, Double const & b) 
{ 
    a += b; //a is local copy, so we can change it 
    return a; 
} 
Double operator-(Double a, Double const & b) 
{ 
    a -= b; //a is local copy, so we can change it 
    return a; 
} 

ノートを参照してください。

同様に、あなたはメンバ関数としてoperator/=とoperator*=を実装し、それらの面でoperator/とoperator*を実装することができます！

Answer 2

オペレータは新しいインスタンスを作成する必要があります。彼らは自分自身を変更するべきではありません（実際には、これを防ぐためにconstと宣言する必要があります）。

例えば：

FLOAT operator+(FLOAT obj) const 
{ 
    FLOAT tmp; 
    tmp.setFloat(x + obj.x); 
    return tmp; 
} 

注（例えばoperator+=の点でoperator+を定義し、floatを取るコンストラクタを定義する）オペレータのオーバーロードを定義するはるかに慣用の方法があります。しかし、上記は十分であるはずです。