C++ Vektor-Operator Überladen

Gibt es ein paar Dinge zu wissen, wenn Sie schreiben die Betreiber, die nicht so Häufig mit anderen Funktionen.

Zuweisen Operatoren, zum Beispiel, wird return *this weil Sie den Wert ändern, der Vektor:

class v {
public:
  double x_, y_;
  v& operator += (const v& rhs)
  {
     _x += rhs._x;
     _y += rhs._y;
     return *this;
  }
};

Andere interessant, die vor ++ - und post - ++ sind Verschieden, nur weil einer nicht verwendeten parameter:

class v {
public:
  double x_, y_;
  v& operator ++ (); //++v
  v& operator ++ (int); //v++
};

"Gleich" (Belegung) ist ein anderes, das ist schwierig, wenn du Zeiger verwenden. Für einen Vektor, der es in der Regel nicht ein problem sein, aber wenn Sie definieren einen Vektor V und weisen Sie es selbst, Sie haben, vorsichtig zu sein:

class v {
public:
  double x_, y_;
  v& operator = (const v& rhs)
  {
    if(this != &rhs)
    {
      x_ = rhs.x_;
      y_ = rhs.y_;
    }
  }
};

In Ihrem Fall, die if() wird sicherlich nicht hilfreich sein, aber denken Sie über das tun etwas wie dieses:

   delete p_;
   p_ = new foo;
   p_->x_ = rhs.p_->x_;

Wenn &rhs == this, dann die delete p_ gelöscht rhs Zeiger! Das bedeutet, dass der Zugriff auf die 3. Zeile ist ein Fehler.

Den rest sollte einfach genug, mit zu arbeiten. Die Vergleichsoperatoren zurück bool und sind const:

class v {
public:
  double x_, y_;
  bool operator == (const v& rhs) const
  {
    return x_ == rhs.x_ && y_ == rhs.y_;
  }
};

Außer für die [] Betreiber. Es gibt zwei Versionen, eins:

class v {
public:
  //I would imagine you'd use an array but as a simple example...
  double x_, y_;
  double operator [] (int idx) const
  {
    return idx == 0 ? x_ : y_;
  }
  v_ref operator [] (int idx)
  {
    v_ref v(this, idx);
    return r;
  }
};

Wie Sie sehen können, die nicht-Konstante version der [] - operator gibt eine Referenz. Dies ist notwendig, damit können Sie etwas schreiben wie:

r[3] = 7.3;

r[3] zurück, die Referenz, dann die Zuordnung der heißt mit 7.3 als parameter.

class v_ref
{
public:
  v *p_;
  int i_;
  v_ref(v *p, int i)
    : p_(p), i_(i)
  {
  }
  operator = (double q)
  {
     //again, I suppose you'd use an array instead!
     if(i_ == 0)
     {
       p_->x_ = q;
     }
     else
     {
       p_->y_ = q;
     }
  }
};

Angenommen, Sie möchten einige Sicherheit, die Vektor-Zeiger könnte machen verwenden der Referenz-Zähler, damit Sie wissen, ob ein Vektor-Objekt gelöscht wird, bevor alle seine Referenz-Objekte...

Einer anderen Anmerkung: ich könnte mir vorstellen, dass Ihr Konstruktor alloziert ein array double (oder verwenden Sie eine std::vector<double> geben...), Wenn Sie neu, denken Sie daran, um zu löschen im Destruktor, und das ist, wenn die if() in der Zuweisungsoperator ist sehr wichtig.

InformationsquelleAutor Alexis Wilke