guten morgen zusammen

hab da ein kleines problem, welches ich nun verzweifelt seit geraumer zeit zu lösen versuche, aber bisher kläglich daran scheitere.

zum problem: in einer klasse, die auf einer basisklasse basiert, möchte ich den vergleichsoperator "==" überladen. der überladene operator soll aber auch als virtuelle funktion in der basisklasse existieren, damit er auch in anderen, von der basisklasse abgeleiteten klassen, nutzbar ist

wichtige ausschnitte aus der klassendefinition:

[LIT.h]

class LIT

{

 private:

        int Id;

        STRING Title;

 public:

        LIT();

        void setId(int num);

        void setTitle(const STRING& Str);

        void setTitle(const char* pStr);

        int getId();

        STRING& getTitle();

        virtual bool operator==(const LIT& other) =0;

};


[PERSON.h]

class PERSON : public LIT

{

 private:

        STRING Fname;

        STRING Lname;

 public:

        PERSON(int num);

        PERSON(int num, const char* title, const char* Pname, const char* Sname);

        PERSON(int num, const STRING& title, const STRING& Pname, const STRING& Sname);

        STRING& getFname();

        STRING& getLname();

        int getId();

        STRING& getTitle();

        bool operator==(const PERSON& other);

};


[PERSON.cpp]

bool PERSON::operator==(const PERSON& other)

{

 PERSON tmp(*this);

 return ((tmp.Fname==other.Fname) && (tmp.Lname==other.Lname));

}

das versuche ich dann mit einer kleinen mainfunktion zu testen:

int main()

{

 PERSON a(1, "user", "fname", "lname");

 PERSON b(2, "user", "fname", "lname");

 PERSON c(3, "in", "out", "done");


 if(a== cout<<"a==b\n";

 if(a==c) cout<<"a==c\n";


 return 0;

}

[/code]




der compiler wirft dann diese fehlermeldung raus:

[code] PERSON.cpp: In member function ‘bool PERSON::operator==(const PERSON&)’: PERSON.cpp:73: error: cannot declare variable ‘tmp’ to be of abstract type ‘PERSON’ PERSON.h:6: note: because the following virtual functions are pure within ‘PERSON’: LIT.h:19: note: virtual bool LIT::operator==(const LIT&) engine.cpp: In function ‘int main()’: engine.cpp:44: error: cannot declare variable ‘a’ to be of abstract type ‘PERSON’ PERSON.h:6: note: since type ‘PERSON’ has pure virtual functions engine.cpp:45: error: cannot declare variable ‘b’ to be of abstract type ‘PERSON’ PERSON.h:6: note: since type ‘PERSON’ has pure virtual functions engine.cpp:46: error: cannot declare variable ‘c’ to be of abstract type ‘PERSON’ PERSON.h:6: note: since type ‘PERSON’ has pure virtual functions

wenn ich den eintrag "virtual bool operator==(const LIT& other) =0;" aus der LIST.h entferne läuft das programm ohne zu murren. dem entnehme ich, dass der compiler ein problem mit der virtuellen funktion hat, wobei ich mir nicht erklären kann welches.

kann mich da jemand aufklären?

MfG

T.Error

Wird der Typ "String" nicht komplett klein geschrieben !?

STRING ist eine von mir selbst definierte klasse

Du hast in der Basisklasse eine pure virtual Methode. Wenn du davon erbst, muss die abgeleitete Klasse diese Methode definieren. Und zwar genau diese, nicht eine Überladung. Das ist bei Operatoren nicht anders.

hmm...

virtual bool operator==(const LIT& other) =0;

Also erstens: pure gewollt? Zweitens: Die Klasse PERSON muss den abstrakten Operator überschreiben. Drittens:

operator==(const LIT& other)

und

operator==(const PERSON& other)

sind bei mir zwei Paar Schuhe.

[Editerle]

Ahh, Klotzkopp war schneller. :/

mkay danke für die antworten

... fehler erkannt. da hab ich wohl den ganzen spaß nich komplett durchdacht gehabt ... pure virtual war übrigens gewollt ... bin ich mal gespannt, obs am ende trotzdem so funktioniert, wie ich mir das vorgestellt hab

grüße

T.Error

pure virtual war übrigens gewollt ...

Dann kannst du keine Reference const LIT& other als Parameter irgendwo übergeben.

Probiers mal mit Pointern.

Ansonsten würd ich den abstrakten Vergleichsoperator einfach weglassen und sicherstellen, dass jede Klasse an sich ihren Vergleichsoperator hat (welcher wieder nur mit dem Parametertyp der eigenen Klasse aufgerufen werden kann [hmm, das riecht nach generischer Klasse]).

Dann kannst du keine Reference const LIT& other als Parameter irgendwo übergeben.

Natürlich kann er. Referenzen sind genauso polymorph wie Zeiger.

Natürlich kann er. Referenzen sind genauso polymorph wie Zeiger.

hmm ok, grad getestet.

Wahrscheinlich war der Hinweis im Netz nur auf die Instanzerstellung bezogen.

(Jaja, wer lesen kann und so. :floet:)

hm pointer zu benutzen klingt echt nach nem plan

... ich arbeite ja auch später im zugriff auf die objekte der klasse PERSON mit nem pointer der klasse LIT ... aber auf die pointer auch dort zu benutzen muss man erstma kommen :floet:

danke für den tipp

grüße

T.Error

tjoa nach langem und nervtötendem rumprobiere möchte ich hier meinen fortschritt posten ... ich komm an selbem problem "mal wieder" nich weiter. hab, soweit es nötig war, alles auf pointer umgestellt, es lässt sich problemlos compilieren, nur passiert nicht das, wie es von mir beabsichtig ist.

die änderungen zum "original":

[LIT.h in pulbic]

virtual bool operator==(const LIT *other) =0;



[PERSON.cpp]

bool PERSON::operator==(const LIT* other)

{

 PERSON* tmp(this);

 PERSON* obj;

 obj=(PERSON*)other;


 return ((tmp->Fname==obj->Fname) && (tmp->Lname==obj->Lname));

}

interessant wäre da evtl auch ein paar ausschnitte aus der STRING-klasse:

class STRING

{

 private:

        int len;

        char* pBuf;

 public:

        STRING();

        STRING(const char* pStr);

        STRING(const STRING& other);

        STRING(char C, int n);

        ~STRING();

        int getLen();

        STRING& operator=(const STRING& other);

        STRING& operator=(const char* pStr);

        bool operator==(const STRING& other);

        friend ostream& operator<<(ostream& OS, const STRING& other)

        {

         OS<<other.pBuf;

         return OS;

        }

};



STRING& STRING::operator=(const STRING& other)

{

 len=other.len;

 pBuf=new char[len+1];

 strncpy(pBuf, other.pBuf, len);

 return *this;

}


STRING& STRING::operator=(const char* pStr)

{

 len=strlen(pStr);

 pBuf=new char[len+1];

 strncpy(pBuf, pStr, len);

 return *this;

}


bool STRING::operator==(const STRING& other)

{

 STRING tmp(*this);

 return !strcmp(tmp.pBuf, other.pBuf);

}

die dazugehörige main-funktion, um das zu testen lautet:

int main()

{

 PERSON* a;

 PERSON* b;

 PERSON* c;

 a=new PERSON(1, "user", "fname", "lname");

 b=new PERSON(2, "user", "fname", "lname");

 c=new PERSON(3, "in", "out", "done");


 if(a== cout<<"a==b\n";

 if(a==c) cout<<"a==c\n";


 return 0;

}

[/code]

die beiden if-abfragen werden beide als false interpretiert. nur weiß ich nicht warum ... irgendwo muss der fehler liegen.

wenn sich irgendwer dem ganzen wirrwar annehmen würde währ ich demjenigen äußerst dankbar ... aber warscheinlich seh ich mal weider den wld vor lauter bäumen nicht

grüße

technichal.error

Die Umstellung auf Zeiger war ein Schritt in die falsche Richtung. Jetzt hast du einen Operator, der PERSON mit einem Zeiger auf LIT vergleichen kann. Du vergleichst aber zwei Zeiger, dafür hast du keinen Operator überladen, du kannst es auch gar nicht.

Ein weiteres Problem ist der Cast von other auf PERSON* in deinem Vergleichsoperator. Wenn der Parameter gar kein PERSON* ist (z.B. nur ein Zeiger auf ein LIT oder eine andere von LIT abgeleitete Klasse), dann hast du da undefiniertes Verhalten.