Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » Fehlermeldung bei Operatorimplementierung/überladung

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 < [ 2 ]
000
15.06.2004, 21:05 Uhr
Lumina



Hi Jungs,
diesmal stelle ich wieder eine ernsthafte Frage...

Hab in meiner Headerdatei dieses:

C++:
Vektor& operator-(const Vektor& vek, int);




In der zugehörigen Implementierungsdatei das:

C++:
Vektor& Vektor::operator-(const Vektor& vek, int)
{
   unsigned i;
  
   for (i=0; i<this->dim; i++)
   {
      this->pKomp[i] = -vek.pKomp[i];
   };
  
   return(*this);
}



Und ich hab diese Fehlermeldung:

Zitat:

error C2804: Binaerer Operator '-' hat zu viele Parameter




Der int-Wert soll nur zur Unterscheidung dienen, da ich ja schon einen Operator- habe.
Wie behebe ich den Fehler?!
--
*******************************************
Willst du glücklich sein im Leben, trage bei zu and'rer Glück,
denn die Freude, die wir geben, kehrt ins eig'ne Herz zurück!
*******************************************

Dieser Post wurde am 15.06.2004 um 21:06 Uhr von Lumina editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
15.06.2004, 22:05 Uhr
Lumina



Oh, ich glaub es werden 2 Fragen:

Headerdatei:

C++:
double Betrag(const CVektDbl& vek) const;
bool operator<(const Vektor& vek);


Implementierungsdatei:

C++:
double CVektDbl::Betrag(const CVektDbl& vek) const
{
   unsigned i;
   double betrag=0;

   for (i=0; i<this->dim; i++)
   {
      betrag += vek.pKomp[i] * vek.pKomp[i];
   };  
   betrag = sqrt(betrag);
   return(betrag);
}
//************************************************************
bool Vektor::operator<(const Vektor& vek)
{
   if (this->Betrag < vek.Betrag) return(true);
   else return(false);
}


Fehlermeldungen in der if-Anweisungszeile:

Zitat:

error C2296: '<' : Ungültig, da der linke Operand vom Typ 'double (__thiscall Vektor::*)(const class Vektor&) const' ist

error C2297: '<' : Ungültig, da der rechte Operand vom Typ 'double (__thiscall Vektor::*)(const class Vektor&) const' ist


warum lässt er mich das nicht machen?
P.S.: Danke!
--
*******************************************
Willst du glücklich sein im Leben, trage bei zu and'rer Glück,
denn die Freude, die wir geben, kehrt ins eig'ne Herz zurück!
*******************************************

Dieser Post wurde am 15.06.2004 um 22:07 Uhr von Lumina editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
15.06.2004, 23:15 Uhr
virtual
Sexiest Bit alive
(Operator)


Hallo,
also bei deiner ersten Frage, die mit Dem vector, da hast du wahrscheinlich den den op- als Member von der Klasse definiert:

C++:
class Vektor
{
public:
   Vektor& operator-(const Vektor& vek, int);
};


Bei dieser Deklaration wird der eine Parameter implizit übergeben (eben this) und sollte nicht in der Parameterlist stehen. Was Du schreiben könntest:

C++:
class Vektor
{
public:
   Vektor& operator-(int);
};


Mit gleichbleibender Implementierung. Allerdings fände ich einen solchen Operatornicht okay, weil er von der Semantik her dem üblichen widerspricht. Denn:

C++:
Vektor x;

x - 1; // Verändert implizit x


Üblicherweise schreibt man denn auch:

C++:
class Vektor
{
public:
   Vektor operator-(int); // Keine Referenz auf this, sondern ein eigenes Objekt zurückgeben
};


Und oft:

C++:
class Vektor
{
public:
   Vektor& operator-=(int); //Hier referenz, das wird von einem -= operator idR wohl erwartet.
};



Bei Deiner zweiten Frage glaube ich, hast du einfach () vergessen:

C++:
bool Vektor::operator<(const Vektor& vek)
{
   if (this->Betrag() < vek.Betrag()) return(true);
   else return(false);
}


oder eben gleich:

C++:
bool Vektor::operator<(const Vektor& vek)
{
   return this->Betrag() < vek.Betrag();
}


--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
16.06.2004, 09:02 Uhr
Lumina



Hab noch einen kleinen Fehler in meiner Methode für den Betrag gefunden, dann das andere entsprechend abgeändert:
Header:

C++:
class Vektor  
  {
public:
   double Betrag(void) const;

   // Operator für Vorzeichenwechsel:
   Vektor operator-(int);

   bool operator<(const Vektor& vek);
  }


Hier die (einstigen) Probleme:

C++:
// Operator für Vorzeichenwechsel(unäres Minus):
VektorVektor::operator-(int)
{
   for (unsigned i=0; i<this->dim; i++) this->pKomp[i] = -this->pKomp[i];
   return(*this);
}
//************************************************************
bool Vektor::operator<(const Vektor& vek)
{
   if (this->Betrag() < vek.Betrag()) return(true);
   else return(false);
}



Jetzt funktioniert alles soweit! Danke für den Denkanstoß! War gestern offensichtlich nicht mehr dazu fähig, weil ich so lang am Stück vor der Kiste war.
--
*******************************************
Willst du glücklich sein im Leben, trage bei zu and'rer Glück,
denn die Freude, die wir geben, kehrt ins eig'ne Herz zurück!
*******************************************

Dieser Post wurde am 16.06.2004 um 09:07 Uhr von Lumina editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
16.06.2004, 09:17 Uhr
(un)wissender
Niveauwart



C++:
Vektor operator-(int);

ist so nicht ganz korrekt.
Das ganze sollte const sein, daraufhindarf du dann in der Implementierung den Vector nicht ändern.
Das wäre wohl korrekt:

C++:
const Vektor operator-(int digit) const
{
  return Vektor(*this) -= digit;
}



Dann musst du noch:

C++:
Vektor & operator-=(int);

implementieren, hier musst du dann den Vector verändern.

Es kommt beim Klassendesign ziemlich auf Kleinigkeiten an, das "funktionieren" der Klasse ist nur der erste Schritt, siesollte dann auch in allen Situationen korrekt "funktionieren".
--
Wer früher stirbt ist länger tot.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
16.06.2004, 12:48 Uhr
Lumina



Den Operator hab ich doch auch! Der Operator-(int) soll doch nix anderes machen, als die Richtung des Vektors ändern! der int-Wert der übergeben wird dient für den Compiler nur zur Unterscheidung von dem Operator- von den Grundrechenarten.

Also wenn ich Operator-(int) aufrufe, will ich vek = -vek haben. Und das geht auch so, habs getestet.

Hast mich anscheinend falsch verstanden, (un)wissender.
--
*******************************************
Willst du glücklich sein im Leben, trage bei zu and'rer Glück,
denn die Freude, die wir geben, kehrt ins eig'ne Herz zurück!
*******************************************
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
16.06.2004, 13:32 Uhr
ao

(Operator)



Zitat:
Lumina postete
Der Operator-(int) soll doch nix anderes machen, als die Richtung des Vektors ändern!
Also wenn ich Operator-(int) aufrufe, will ich vek = -vek haben.

Dafür ist aber kein int-Argument nötig. Es genügt, wenn der Operator so deklariert ist:

C++:
Vektor operator- () const;



Bearbeitung von ao:
einen Absatz hinzugefügt

Hab noch mal nachgeschlagen: operator-(int) ist *kein* (unärer) Vorzeichenoperator, sondern ein binärer *Subtraktions*-Operator. Du hast also was deklariert was in Ausdrücken wie

C++:
Vektor v;
Vektor w = v - 2; // = v.operator-(2)


verwendet werden kann.

(un)wissender hat schon recht: operator-(int) impliziert, dass hier ein Zahlenwert von jeder Komponente abgezogen werden soll. Diesen Operator würde ich dann aber als Spezialfall von operator-(const Vektor & implementieren, aber das ist wieder ne andere Sache.

Dieser Post wurde am 16.06.2004 um 13:44 Uhr von ao editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
007
16.06.2004, 14:40 Uhr
(un)wissender
Niveauwart


@Lumina
Wenn du solche Spezialfälle implementierst würde ich einen Funktion nehmen, keinen Operator!
Das ist dann nämlich missverständlich und trägt der Sache nicht bei.
Nimm also eine Fkt. die bspw. changeDirection() heißt, da ist dann alles klar.
--
Wer früher stirbt ist länger tot.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
008
16.06.2004, 15:18 Uhr
ao

(Operator)


@(un)wissender:
Nein!

Vektor a, b;
a = -b; // Klar wie Kloßbrühe.
a = b.changeDirection (); // Hä?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
009
16.06.2004, 15:31 Uhr
(un)wissender
Niveauwart


Dann nenn es halt anders.
Hä? ist hier nicht angebracht, dann müsste bspw. in Javaprogrammen nur Hä? stehen.
Wenn ich es mir genau ansehe, ist const Vektor operator- () const; wohl ok, auf der sicheren Seite ist man aber immer mit Elementfunktionen, Operatoren sind da nur die Kür und man muss exakt wissen, wann sie anzuwenden sind.
--
Wer früher stirbt ist länger tot.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 < [ 2 ]     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: