Ist der Vergleich ein BOOLESCHER Wert, gegen die JA gefährlich?

Fand ich einen Kommentar heute in einer Quellcode-Datei:

// - no longer compare BOOL against YES (dangerous!)

Ist der Vergleich BOOL gegen YES in Objective-C wirklich so gefährlich? Und warum ist das so?

Kann der Wert von YES ändern während der Laufzeit? Vielleicht NO ist immer 0 aber YES werden kann 1, 2 oder 3 - je nach Laufzeit-compiler, deine verlinkten frameworks?

Siehe diese Frage: stackoverflow.com/questions/690903/...
BTW, im 64-bit-iOS-Ziele BOOL jetzt übersetzt bool, das ist ein richtiger Typ "boolean". Aber historisch gesehen, war es nur eine signed char, und unter Berücksichtigung aller Vorsichtsmaßnahmen, die wir sehen, werden unten diskutiert.

InformationsquelleAutor | 2009-12-20

17

Das problem ist, dass die BOOL ist nicht von einem einheitlichen Typ, sondern eine Typdefinition:
```
typedef signed char      BOOL;

#define YES             (BOOL)1
#define NO              (BOOL)0
```
Als char, seine Werte sind nicht gezwungen, an TRUE und FALSE. Was passiert mit einem anderen Wert?
```
BOOL b = 42;
if (b)
{
    //true
}
if (b != YES)
{
    //also true
}
```
- ja ok, aber dass die coder Schuld, wenn er setzt seine BOOL vars einige beliebige Werte, weil er ein fauler hacker.
- oder die coder Mitarbeiter hat, oder die codebase des bisherigen Betreuers, oder ein Entwickler für eine Bibliothek verwendet, die in das Projekt... es schadet nie, Es zu paranoid.
- Ich weiß, das ist eine super alte Frage, aber settting eine BOOL mit so etwas wie bitMask & (1 << 2) ist eine durchaus vernünftige Sache zu tun, und kann eine "beliebige" truthy-Wert (mindestens ein bit gesetzt), der nicht gleich YES (nur LSB-set). Siehe BOOL's scharfen Ecken im BNR für mehr.
InformationsquelleAutor Michael Petrotta
11

Sollte man sich nie vergleichen Boolesche Werte gegen alles in einer der C-basierten Sprachen. Der richtige Weg, es zu tun ist, um entweder:
```
if (b)
```
oder:
```
if (!b)
```
Dies macht den code sehr viel besser lesbar (vor allem, wenn Sie mit intelligent benannte Variablen und Funktionen, wie isPrime(n) oder childThreadHasFinished) und safe. Der Grund, so etwas wie:
```
if (b == TRUE)
```
nicht so sicher ist, dass es tatsächlich eine große Anzahl von Werten der b wird zu true ausgewertet, und der TRUE ist nur einer von Ihnen.

Folgendes:
```
#define FALSE 0
#define TRUE  1

int flag = 7;
if (flag)         printf ("number 1\n");
if (flag == TRUE) printf ("number 2\n");
```
Sollten Sie sich beide diese Zeilen ausgedruckt, wenn es funktioniert wie erwartet, aber Sie erhalten nur die erste. Das ist, weil 7 ist tatsächlich wahr, wenn Sie korrekt behandelt werden (0 ist false, alles andere true ist), aber das explizite testen auf Gleichheit zu false ausgewertet wird.

Update:

In Antwort auf Ihren Kommentar, dass Sie dachte, es wäre mehr als coder Dummheit: ja, es gibt (aber ich würde trotzdem nicht Rabatt-coder Dummheit als Grund genug, den defensiven Programmierung ist immer eine gute Idee).

Ich erwähnte auch die Lesbarkeit, die ist ziemlich hoch auf meiner Liste der wünschenswerten Eigenschaften in code.

Einen Zustand sollte, ist entweder ein Vergleich zwischen Objekten oder ein flag (einschließlich booleschen Werte):
```
if (a == b) ...
if (c > d) ...
if (strcmp (e, "Urk") == 0) ...
if (isFinished) ...
if (userPressedEsc (ch)) ...
```
Wenn Sie (wie ich denke) ein Greuel wie:
```
if (isFinished == TRUE) ...
```
wo wollen Sie aufhören:
```
if (isFinished == TRUE) ...
if ((isFinished == TRUE) == TRUE) ...
if (((isFinished == TRUE) == TRUE) == TRUE) ...
```
und so weiter.

Den Recht Weg, es zu tun für eine bessere Lesbarkeit ist nur entsprechend dem Namen flag-Variablen.
- ja ok, aber wenn ich mit einer BOOL variable dann werde ich nicht einstellen, dass es etwas anderes als JA oder NEIN. es ist wie der Vergleich von vorzeichenlosen mit vorzeichenbehafteten und weint, weil komische Sachen passiert. Ich dachte, dass es möglicherweise einen anderen Grund als die Programmierer, die Dummheit nicht zu vergleichen BOOL.
- Ja, da ist die Lesbarkeit auch. Boolsche Variablen sollten in der form "etwas == etwas", "etwas" < "etwas" und so weiter, wenn Sie tatsächlich vergleichen von Dingen. Ein flag sollte entsprechend benannt (finishedLoop, gotUserData, ...), so dass Sie können verwenden Sie einfach "if (flag)". Das "if (flag == TRUE)" - Konstrukt ist ein Greuel in Bezug auf die Lesbarkeit, da das ist nur ein weiterer check. Ist, die, wo Sie aufhören oder halten Sie sich gehen: "if ((flag == TRUE) == TRUE)", "if (((flag == TRUE) == TRUE) == TRUE)", ad infinitum (reduction ad absurdum). 🙂
InformationsquelleAutor paxdiablo
2

All dies wahr ist, aber es gibt triftige Gegenargumente in Betracht:

— Vielleicht haben wir wollen zu überprüfen, ein BOOL ist eigentlich ein JA oder NEIN. Wirklich, die Speicherung beliebiger anderer Wert als 0 oder 1 in ein BOOL ist ziemlich falsch. Wenn es passiert, ist es nicht mehr wahrscheinlich, weil ein Fehler irgendwo anders in der codebase, und ist nicht explizit überprüft JA nur die Maskierung dieser Fehler? Ich denke, dies ist viel wahrscheinlicher als ein schlampiger Programmierer mit BOOL in einem nicht-standard-Weg. Also, ich denke, ich würde wollen meinen tests fehl, wenn Sie meinen BOOL nicht JA, wenn ich bin auf der Suche nach der Wahrheit.

Ich nicht unbedingt damit einverstanden, dass "wenn (isWhatever)" ist leichter lesbar, besonders bei der Bewertung lang, aber ansonsten gut lesbar, Funktionsaufrufe,

vgl.
```
if ([myObj doThisBigThingWithName:@"Name" andDate:[NSDate now]]) {}
```
mit:
```
if (![myObj doThisBigThingWithName:@"Name" andDate:[NSDate now]]) {}
```
Die erste ist der Vergleich gegen true, die zweite gegen die falschen und es ist schwer zu sagen, der Unterschied, wenn man schnell Lesen, code, Recht?

Vergleichen:
```
if ([myObj doThisBigThingWithName:@"Name" andDate:[NSDate now]] == YES) {}
```
und
```
if ([myObj doThisBigThingWithName:@"Name" andDate:[NSDate now]] == NO) {}
```
...und ist es nicht viel mehr lesbar?

Wieder, ich sage nicht ein Weg ist richtig und die andere falsch ist, aber es gibt einige Kontrapunkte.

InformationsquelleAutor Russell Quinn
0

Wenn der code verwendet eine BOOL variabel, es soll eine solche variable als boolean. Der compiler überprüft nicht, ob eine BOOL variable bekommt einen anderen Wert, in der gleichen Weise, die der compiler überprüft nicht, ob Sie initialisieren eine variable an eine Methode übergeben, mit einem Wert, der zwischen einer Reihe von Konstanten.

InformationsquelleAutor kiamlaluno

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.