2011-01-05 15 views

Antwort

98

Mitglied Funktionen der Form

operator TypeName() 

sind Konvertierungsoperatoren. Sie erlauben es, Objekte des Klassentyps so zu verwenden, als ob sie vom Typ TypeName wären, und wenn sie sind, werden sie unter Verwendung der Umwandlungsfunktion in TypeName umgewandelt.

In diesem speziellen Fall ermöglicht operator bool(), dass ein Objekt des Klassentyps verwendet wird, als wäre es ein bool. Zum Beispiel, wenn Sie ein Objekt der Klasse Typ obj benannt haben, können Sie es als

if (obj) 

verwenden Dies wird die operator bool() nennen, geben das Ergebnis, und verwenden Sie das Ergebnis als den Zustand des if.

Es sollte angemerkt werden, dass operator bool() ist eine sehr schlechte Idee, und Sie sollten wirklich nie verwenden. Eine detaillierte Erklärung, warum es schlecht ist und für die Lösung des Problems, finden Sie unter "The Safe Bool Idiom."

(C++ 0x, die bevorstehende Überarbeitung des C++ - Standards, fügt Unterstützung für explizite Konvertierung Operatoren hinzu. Dies wird Ihnen ermöglichen Schreiben Sie einen sicheren explicit operator bool(), der richtig funktioniert, ohne durch die Reifen der Implementierung der Safe Bool Idiom zu springen.)

+2

+1 für Verweis auf sichere Bool Idiom – greyfade

+1

„verwendet, als ob es ein Bool waren“ fälschlicherweise impliziert, man könnte sagen, es einen Booleschen Wert zuweisen. Vielmehr generiert es im Code des Posters eine temporäre Variable vom Typ bool, die sich auf den momentanen Wert von col bezieht, aber danach unabhängig von dem Objekt ist, das sie erzeugt hat. Darüber hinaus ist die Erwähnung der Safe Bool Idiom großartig, aber nur um zu registrieren, dass gegenteilige Ansichten existieren: IMHO ist der Ratschlag "Niemals wirklich" übertrieben - es gibt strengere Compiler-Prüfungen gegen albernen Missbrauch auf Kosten einer verschleierten API das kann zu einem versehentlichen Missbrauch führen. –

+1

@Tony: Nun, es kann verwendet werden, als wäre es ein Bool; Da das Ergebnis der Konvertierung ein rvalue ('bool') ist, nein, können Sie ihm nicht zuweisen. Wenn es ein modifizierbarer L-Wert wäre (z.B. 'bool &'), könnten Sie ihm zuweisen. Bezüglich der Korrektheit argumentiere ich, dass ein 'operator bool()' immer falsch ist, weil er die Verwendung eines klassenartigen Objekts in einer großen Anzahl von Situationen erlaubt, in denen es nie benutzt werden soll. Safe Bool ist eine weit überlegene Alternative. –

1

Es ist eine implizite Umwandlung zu bool. I.e. Wo immer implizite Konvertierungen erlaubt sind, kann Ihre Klasse durch Aufruf dieser Methode in bool konvertiert werden.

3

Es ist benutzerdefinierte implicit Konvertierungsfunktion, um Ihre Klasse in entweder true oder false konvertieren.

//usage 
bool value = yourclassinstance; //yourclassinstance is converted into bool! 
0

Wie die anderen gesagt haben, ist es für die Typumwandlung, in diesem Fall zu einem bool. Zum Beispiel:

class A { 
    bool isItSafe; 

public: 
    operator bool() const 
    { 
     return isItSafe; 
    } 

    ... 
}; 

Jetzt kann ich ein Objekt dieser Klasse verwenden, als ob es ein boolean ist:

A a; 
... 
if (a) { 
    .... 
} 
8
operator bool() const 
{ 
    return col != 0; 
} 

Legt fest, wie die Klasse in einen Booleschen Wert konvertierbar ist, die const nach dem () wird verwendet, um anzuzeigen, dass diese Methode nicht mutiert (ändern Sie die Mitglieder dieser Klasse).

Sie würden in der Regel solche Operatoren wie folgt:

airplaysdk sdkInstance; 
if (sdkInstance) { 
    std::cout << "Instance is active" << std::endl; 
} else { 
    std::cout << "Instance is in-active error!" << std::endl; 
} 
-1

Eine weitere gebräuchliche Anwendung ist für std Container Gleichheit Vergleich zu wichtigen Werten zu tun innerhalb benutzerdefinierten

class Foo 
{ 
    public: int val; 
}; 

class Comparer { public: 
bool operator() (Foo& a, Foo&b) const { 
return a.val == b.val; 
}; 

class Blah 
{ 
std::set< Foo, Comparer > _mySet; 
}; 
+0

Dieses Beispiel verwendet 'operator()' nicht 'operator bool'. Sie sind total verschieden. 'operator()' ist der Aufrufoperator, so dass ein 'Comparer' als Funktion aufgerufen werden kann. Dieser 'operator()' gibt zufällig 'bool' zurück, aber das macht ihn nicht gleich 'operator bool', was einfach eine implizite Umwandlung zu' bool' ermöglicht. – anthropomorphic

4

Objekte Ich möchte geben, mehr Codes, um es zu verdeutlichen.

struct A 
{ 
    operator bool() const { return true; } 
}; 

struct B 
{ 
    explicit operator bool() const { return true; } 
}; 

int main() 
{ 
    A a1; 
    if (a1) cout << "true" << endl; // OK: A::operator bool() 
    bool na1 = a1; // OK: copy-initialization selects A::operator bool() 
    bool na2 = static_cast<bool>(a1); // OK: static_cast performs direct-initialization 

    B b1;  
    if (b1) cout << "true" << endl; // OK: B::operator bool() 
    // bool nb1 = b1; // error: copy-initialization does not consider B::operator bool() 
    bool nb2 = static_cast<bool>(b1); // OK: static_cast performs direct-initialization 
}