!Operator überladen

Hallo zusammen,

folgendes habe ich mit Microsoft Visual Studio 2008 programmiert:

class Mitglieder
{
bool operator!(const Mitglieder &);
};

Dabei erhalte ich die Fehlermeldung:
Fehler 1 error C2808: Der unäre Operator '!' hat zu viele formale Parameter

Wenn ich einen anderen Operator benutze z.B. bool operator>(const Mitglieder &);
funktioniert alles wunderbar, aber ich soll den Ausrufezeichen verwenden.

Wäre dankbar, wenn mir jemand sagen könnte, wie man diesen Operator überladen kann.

Gruß Leo

Nexus

Der operator! ist unär, nimmt also nur einen Parameter. Wenn du ihn in der Klasse deklarierst, ist der erste Parameter bereits implizit ein Objekt der Klasse.

Mach den Operator also global:

Mitglieder operator! (const Mitglieder& Value);

volkard

Der operator! ist unär, nimmt also nur einen Parameter. Wenn du ihn in der Klasse deklarierst, ist der erste Parameter bereits implizit *this .

Mach den Operator also ohne expliziten Parameter:

class Mitglieder 
{ 
bool operator!() const; 
};

Nexus

volkard schrieb:

Der operator! ist unär, nimmt also nur einen Parameter. Wenn du ihn in der Klasse deklarierst, ist der erste Parameter bereits implizit [...]

Ein wenig viel abgeschrieben, nicht? :p

Aber stimmt, *this ist besser.

pumuckl

Nexus schrieb:

Der operator! ist unär, nimmt also nur einen Parameter. Wenn du ihn in der Klasse deklarierst, ist der erste Parameter bereits implizit ein Objekt der Klasse.

Mach den Operator also global:
Mitglieder operator! (const Mitglieder& Value);

Unäre Operatoren sollten in den meisten Fällen als Klassenmethoden implementiert werden, um implizite Konvertierungen des Arguments zu vermeiden. Beispiel:

class Mitglieder
{
public:
  Mitglieder(Person const& pers);
};
bool operator! (Mitglieder const& mtgl);

//....
Person Franzl;
if (!Franzl) //ups, das geht ja!
{
  /*...*/
}

volkards Beispiel ist also die bessere Wahl für onäre Operatoren im Allgemeinen.

Was die Überladung des op! im Speziellen angeht gibts meist bessere Alternativen. Wenn du die Objekte deiner Mitglieder-Klasse in einem boolschen Kontext auswerten willst (z.B. wie oben in der if-Abfrage), ist meist das Safe-Bool-Idiom die bessere Wahl, da man mit de op! nur negative Abfragen ermöglicht:

Mitglieder Mitgl;
if (!Mitgl); //OK
if (Mitgl); //Fehler!
if (!!Mitgl); //Doppelte Verneinung klapt zwar, sieht aber nicht so dolle aus

http://www.artima.com/cppsource/safebool.html

Nexus

pumuckl schrieb:

Unäre Operatoren sollten in den meisten Fällen als Klassenmethoden implementiert werden, um implizite Konvertierungen des Arguments zu vermeiden.

Okay, das geht aber auch mit einem expliziten Konstruktor. Das wäre bei diesem Beispiel sowieso nützlich, da man womöglich auch andere impliziten Konvertierungen vermeiden will.

Ich finde, dass Operatoren, die nichts an der Klasse ändern und auch nicht auf private Variablen zugreifen, eher global gemacht werden sollten (generell Funktionen).

pumuckl

Nexus schrieb:

Ich finde, dass Operatoren, die nichts an der Klasse ändern und auch nicht auf private Variablen zugreifen, eher global gemacht werden sollten (generell Funktionen).

Operatoren bzw. generell Funktionen, die weder an dem Objekt was ändern noch auf private Variablen zugreifen sind nur Hilfsfunktionen, weil sie das Interface der Klasse verbreitern ohne Funktionalität hinzuzufügen. Und solche Hilfsfunktionen sollten allgemein eher spärlich eingesetzt werden, z.B. wenn sie eine größere Menge an Operationen zusammenfassen. Allerdings sind Operatoren wegen ihrer üblichen Semantik meist nicht für slche Hilsfunktionen geeignet.

Vielen Dank für eure Antworten!

Es hat mir sehr weiter geholfen. Das Forum ist klasse. Ich werde mich hier registrieren.

PS: Frohes Neues