3. operator[] Ueberladung fuer eine Klasse CArray

operator[] Ueberladung fuer eine Klasse CArray

  • M

    In der Abendschule schreiben wir gerade an der Klasse CArray.
    Diese legt ein Feld der Feldweite fw mit Daten des Typs T im Heap an.
    Im Zuge der Operatorueberladungen sind wir jetzt bei operator[] angekommen.

    codesnipplets:

    CArray.h

    // define type of data in CArray Fields just here in headerfile
typedef int T;

class CArray
{

    private:
		  int fw;      // fieldwidth
		  T* p;        // pointer to fields

    public:

                  // snipped some code
                  T operator[](int);
};

    CArray.cpp

    // als weitere Erklaerung hier mal der Konstruktor
CArray::CArray(int ini_fw, T val) : fw(ini_fw), p(NULL)
{
	if(!(p = new T[fw])) // if allocation is successfull, it will return
	                    // an address, otherwise it will return 0.
                           // Ich weiss, dass dies kein gutes Errorhandling ist
                          // aber so machen wir es zur Zeit nun einmal.
	{
		cerr << "Allocation not successful!" << endl; // further actions
	} // end if
	else
	{   
		for(int i=0; i < fw; ++i)
		{
			p[i] = val;
		} //end for
	} // end else
} 

// Zuweisungsoperator
const CArray& CArray::operator=(const CArray& op)
 {
//    cout << "In operator= method" << endl;  
	if (&op != this) // catch x=x;
 	{
        if (fw != op.fw)
        {    
     	  delete [] p; // delete old allocation
		  fw = op.fw;
		  p = new T[fw]; 
        } // endif

		for(int i=0; i < fw; ++i)
		{                        
			p[i] = op.p[i];   

        	} //end for            
	} //
	return *this; 
}
// und hier operator[] bisher
T CArray::operator[](int op2)
{
       return p[op2];
}

    operator[] bietet uns jetzt die Moeglichkeit Felddaten einer Instanz auszulesen, Aufgabe ist aber, auch schreibend Zugriff zu haben.

    Beispiel:

    CArray x(10,2); // erstellt ein Feld der Feldweite 10 und schreibt 2en in jedes Feld

cout << x[1]; // funktioniert jetzt ja schon und gibt mir auch brav die 2 aus.

x[3] = 5; // soll mir in Zukunft eine 5 ins Feld mit dem Index 3 schreiben.
x[1] = x[3]; // soll den Inhalt von Feldindex 3 in Feldindex 1 schreiben.

    Soweit, so gut.
    Irgendwie komm ich damit rein gedanklich mal wieder nicht klar.
    Den Zuweisungsoperator habe ich mal mit im Source gepostet, ich bin mir nicht sicher, inwiefern ich den auch noch aendern muss.

    Mein Gedankengang bisher ist, dass ich den Wert ja lesen kann (soweit bin ich schonmal fast alleine gekommen ;o)), aber so wie ich das sehe, kann ich nicht schreiben.
    Versuche ich eine Zuweisung vorzunehmen, bekomme ich die Fehlermeldung:

    69 op_CArray.cpp non-lvalue in assignment

    z[1] = 1337; // Zeile 69 in meinem Testprogramm

    Was mich aber auch nicht weiter wundert.

    Haette vielleicht jemand Loesungsansaetze, Hinweise, Tips fuer mich, wie ich das am Besten umsetze?

    Wer will, bekommt den ganzen Code zugemailt.

    0
  • M

    Wie wäre es, wenn dein op[] eine Referenz zurückgibt?

    0
  • E

    Erst mal ne Frage war das deine Idee?

    typedef int T;

    Das ist nämlich quark.

    template < typename T >
  class CArray
  {...

    hätte genau diesen Effekt nur noch besser, man kann dann verschiedene Typen in der Gleichen Anwendung benutzen.

    CArray<int> int_array;
CArray<long> long_array;
CArray<float> float_array;

    Und nun zu deinem Problem:

    T operator[](int);

    du musst hier eine Referenz zurückgeben
    ➡

    T & operator[](int);

    MfG

    0
  • M

    evilissimo schrieb:

    template

    Ja, habe ich mir schon angesehen und wollte es auch schon benutzen. Vorgabe kommt aber von unserem Lehrer und ich will nicht allzu sehr vorausgreifen, weil ich sonst bei manchen Sachen einfach den Ueberblick verliere.
    Generell gibt es da Verbesserungen, das Problem ist, dass die Klasse zu einem Grossteil eh schon nicht wirklich mitkommt, aber das steht eh auf einem anderen Blatt.

    An die Referenz hatte ich schon gedacht, aber ich haette nicht gedacht, dass es so einfach geht.

    Was passiert denn jetzt genau, wenn die Zuweisung gemacht wird?
    Vielmehr ist meine Frage glaube ich:
    Wohin wird der Rueckgabewert zurueckgegeben?

    BTW: danke schonmal. Funktioniert wunderbar. Ich haette es vielleicht einfach mal ausprobieren sollen, als ich die Idee hatte.

    0
  • V

    feldgrenzenüberschreitung (absturz) gesichtet bei "for(int i=0; i < fw; ++i)".

    0
  • M

    volkard schrieb:

    feldgrenzenüberschreitung (absturz) gesichtet bei "for(int i=0; i < fw; ++i)".

    Ich haette dazuschreiben sollen, dass von dem Lehrer vorausgesetzt wurde, das die Felder die gleiche Feldweite haben.
    Wie schon geschrieben weiss ich, dass ein paar Sachen hier verbesserungswuerdig sind.

    template < typename T >
  class CArray
  {...

    Muss ich template < typename T > nur bei der Deklaration der Klasse erwaehnen, oder muss ich das noch an anderen Stellen einbinden? Also in der KTor Definition, oder Methodendefinitionen, etc? Wenn es noch in anderen Bereichen eingebaut werden muss, wie genau gehe ich dabei vor?

    0
  • C
    Mod

    volkard schrieb:

    feldgrenzenüberschreitung (absturz) gesichtet bei "for(int i=0; i < fw; ++i)".

    wo? eher wird das hier mit einem aktuellen compiler nicht funktionieren:

    if(!(p = new T[fw]))

    müsste

    if(!(p = new(std::nothrow) T[fw]))

    sein.

    0
  • G

    camper schrieb:

    eher wird das hier mit einem aktuellen compiler nicht funktionieren:

    if(!(p = new T[fw]))

    Naja, funktionieren tut's schon. Die Nullzeiger Abfrage ist nur überflüssig, da es nie einer sein wird.

    0
Anmelden zum Antworten