4

クラス CVector での演算子のオーバーロード:

CVector CVector::operator+ (CVector param) {
  CVector temp;
  temp.x = x + param.x;
  temp.y = y + param.y;
  return (temp);
}

そして主に：

CVector a (3,1);
  CVector b (1,2);
  CVector c;
  c = a + b;

したがって、オブジェクトが値渡しされ、別の一時オブジェクトが作成されます。b は値渡しされていると思います。a は + を呼び出しているため、x と y は a に属し、pram.x と param.y は b に属しています。temp が返され、コピー代入演算子が temp の値を c? に渡します。

しかし、これはどうですか：

CVector& CVector::operator= (const CVector& param)
{
  x=param.x;
  y=param.y;
  return *this;
}

そして主に：

a=b;

再び a は = を呼び出し、b は const として参照によって渡されます (この場合、値によって渡されたかどうかは問題になりますか?) ここで混乱します。この関数は x と y にアクセスできるので、なぜこの関数は void ではないのでしょうか。*これが返すものは、これが関数を呼び出すオブジェクトのアドレスであることを知っているので、*これは関数自体になりますが、オブジェクトを返す場合は、前の c=temp のような場所に割り当てる必要がありますtemp=a+b の後? そして、CVector& は何を意味するのでしょうか? CVector 型のオブジェクトのアドレスを期待しているようには見えませんか?

言い換えれば、なぜ関数だけではないのですか:

void CVector::operator= (const CVector& param)
    {
      x=param.x;
      y=param.y;
    }

??

次に、このコードがあります

#include <iostream> 
using namespace std;
 class Calc { 
private: 
  int value; 
public: 
  Calc(int value = 0) { this->value = value; } 
  Calc& Add(int x) { value += x; return *this; } 
  Calc& Sub(int x) { value -= x; return *this; } 
  Calc& Mult(int x) { value *= x; return *this; } 
  int GetValue() { return value; } }; 

int main() { 
  Calc cCalc(2); 
  cCalc.Add(5).Sub(3).Mult(4); 
  cout << cCalc.GetValue(); 
  return 0; 
}

関数から & を削除すると、次のようになります。

  Calc Add(int x) { value += x; return *this; } 
  Calc Sub(int x) { value -= x; return *this; } 
  Calc Mult(int x) { value *= x; return *this; }

と使用

Calc cCalc(2)
cCalc.Add(5);
cCalc.Sub(3);
cCalc.Mult(4);

前者の代わりに、同じ結果が生成されます。では、なぜ Calc& returne 型で連鎖が許可されるのでしょうか。

オブジェクト指向は、ロジックを使用しなければならない構造化プログラミングとは対照的に、多くの場合パターン (これはこのように記述され、これが必要な場合はこれが必要です) によって記述されるため、プログラミング方法を知りたいだけでなく、なぜコードの平和をそのまま定義し、直感的にそうあるべきだと思っていない理由 (ただし、プログラミングを学ぶのは約 1 年だけですが)。

ありがとう！

4

2 に答える 2

1

まず、C++ での通常の規則は、クラスの型引数を const への参照として渡すことです。明らかに例外 (標準ライブラリの述語オブジェクトまたは反復子) がありますが、アプリケーション レベルのコードでは、const への参照によってクラス型を渡すことは、コメントを正当化するのに十分遍在しています。

Vector
Vector::operator+( Vector const& rhs ) const
{
    //  ...
}

または、より可能性が高い:

Vector
operator+( Vector const& lhs, Vector const& rhs )
{
    Vector results( lhs );
    results += rhs;
    return results;
}

もう 1 つの広く普及している規則は、そのような二項演算子を関数から解放して、左右の引数が同じように扱われるようにすることです。そして、それらを = の観点から実装することで、 = と望ましい関係が確実に得られるようにします。

一方、代入演算子のように、左の引数を変更する演算子の場合、それらをメンバーにするのが規則です。operator=実際にはメンバーである必要があります。フリー関数Vector& operator+=( Vector& lhs, Vector const& rhs )は合法ですが、かなり珍しいものです。

operator=返す理由についてはVector&、慣習です。組み込みの演算子が行うことを最も正確にシミュレートします。

int&
MyClass::funcWithInt( int newValue )
{
    return myInt = newValue;
}

は正当です (たとえ私を含めて多くの人がそれを悪い stype と見なすとしても)、同じコードは operator= をオーバーロードするクラス型で正当であるはずです。そしてもちろん、生成 operator=されたコンパイラは const への参照を返すため、自分で作成するときに同じことを行うことには強い議論があります。

于 2013-08-23T15:20:20.617 に答える