Frage zu Rückgabe bei Operator überladen []



  • Ich habe eine Frage zum Überladen des [] Operators.
    Habe hierfür ein paar Zeilen Code eingefügt.
    Warum muss ich in der Funktion für das Überladen
    return feld[neues_feld] zurückgeben und kann nicht
    über return *this gehen ?
    Bei anderen Operatoren, z.b. -, kann ich doch auch mit return *this
    arbeiten.
    Bsp.:

    komplex& komplex::operator-(const komplex& k2)
    { 
         rababer rababer...
         return *this;
    }
    

    Hier der eigentliche Code...

    class op
    {
    	private:
    		double *feld;
    		int feldlaenge;
    
    	public:
    		op(int);
    		~op();
    		double& operator[](int);
    };
    
    double& op::operator [](int neues_feld)
    {
    	feld = new double[neues_feld];
    	return feld[neues_feld];
    
    }
    


  • Hallo,

    ist zwar das falsche Sub-Forum, aber whatever...

    c-mos schrieb:

    double& op::operator [](int neues_feld)
    {
    	feld = new double[neues_feld];
    	return feld[neues_feld];
    
    }
    

    blub? Was treibst du da? Operatoren sollten so überladen werden, wie sie auch für eingebaute Typen benutzt werden, in dem Fall als Index-Operator:

    //int Vector
    class Vector {
      size_t len;
      int *x;
    
    public:
      Vector(size_t len_=0) : len(len_) x(new int[len]) {}
    
      Vector(const Vector &v) : len(v.len), x(new int[len]) {
        for (int i=0;i<len;++i)
          x[i] = v.x[i];
      }
    
      ~Vector() { delete [] x; }
    
      int size() { return len; }
    
      //Zuweisungs-op
      Vector& operator=(const Vector &v) {
        if (this == &v)  //Selbstzuweisung?
          return *this;
    
        if (len != v.len) {  //Evtl. kann ich löschen und neuallokieren einsparen, wenn die Länge gleich ist
          delete [] x;
          len = v.len;
          x = new int[len];
        }
    
        for (int i=0;i<len;++i)  //rüberkopieren
          x[i] = v.x[i];
    
        return *this;
      }
    
      //Gibt eine Referenz auf den Wert an 'index' zurück
      int& operator[](int index) {
        return x[index];
      }
    
      //Gibt eine konstante Referenz auf den Wert an 'index' zurück, für konstante Vectors
      const int& operator[](int index) const {
        return x[index];
      }
    }
    

    Hilft das?

    MfG

    GPC



  • Dieser Thread wurde von Moderator/in SideWinder aus dem Forum DOS und Win32-Konsole in das Forum C++ verschoben.

    Im Zweifelsfall bitte auch folgende Hinweise beachten:
    C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

    Dieses Posting wurde automatisch erzeugt.


Anmelden zum Antworten