In Objective-c, un modo sicuro e valido per confrontare 2 valori BOOL?

Question

Voglio confrontare 2 valori BOOL in obiettivo-c.

Ho scoperto che (3) - (6) del codice seguente funziona.
(1) - (2) non funziona perché BOOL è solo signed char.

(3) funziona ed è molto leggibile ma penso che bool non sia obiettivo-c.
L'utilizzo di bool nel codice obiettivo-c è buono?

Qual è il modo sicuro e valido per confrontare 2 valori BOOL in obiettivo-c?
Ci sono altri modi migliori per confrontare?

BOOL b = YES; 
BOOL c = 2; 

NSLog(@"(1) %d", b == c); // not work 
NSLog(@"(2) %d", (BOOL)b == (BOOL)c); // not work 
NSLog(@"(3) %d", (bool)b == (bool)c); 
NSLog(@"(4) %d", !b == !c); 
NSLog(@"(5) %d", !!b == !!c); 
NSLog(@"(6) %d", (b != 0) == (c != 0)); 

risultati:

(1) 0 
(2) 0 
(3) 1 
(4) 1 
(5) 1 
(6) 1 

Answer 1

È perfettamente valido utilizzare bool in Objective-C poiché fa parte dello standard C99 (§7.16). Secondo me è anche il modo migliore per gestire confronti sicuri di tipi booleani.

L'unico motivo per non utilizzare bool ovunque è che BOOL è onnipresente in Objective-C e nei framework.

Answer 2

convertire il vostro numero per una valida BOOL, rispondendo che cosa si intende per "2"

nel vostro contesto, è 2 = YES

Int number = 2; 
BOOL c = (number == 2); //2 is YES 

è> 0 = SI

Int number = 2; 
BOOL c = (number > 0); //2 is YES 

Dipende virile su ciò che è vero e cosa è falso nell'applicazione

Answer 3

Da objc.h:

typedef signed char  BOOL; 
.... 

#define YES    (BOOL)1 
#define NO    (BOOL)0 

A quanto pare, BOOL è signed char, quindi è vero che è possibile assegnare il numero di variabili del tipo BOOL, che rovinerà il confronto (dal momento che il confronto è un confronto tra interi).

Penso che il metodo (4) che utilizza la negazione per convertire il valore integrale arbitrario in 0 o 1 sia un buon modo breve per confrontare in modo sicuro il valore logico di 2 BOOL.

Answer 4

a parte le altre risposte, desidero notare che il confronto di bool per l'uguaglianza è non un'operazione molto comune. BOOL non è un tipo, è solo una macro che nasconde il fatto che i booleani sono solo numeri interi. Per ogni operazione booleana, è preferibile utilizzare strutture di programmazione e operatori in grado di gestire correttamente interi come booleani:

e.g: if (condition1 == NO) {} dovrebbe essere if (!condition1) {}

if (condition1 == condition2) {}
può essere
if ((condition1 && condition2) || (!condition1 && !condition2)) {}
o meglio
BOOL newCondition = (condition1 && condition2) || (!condition1 && !condition2); if (newCondition) {}

La via più breve per scrivere un condizione non deve essere il modo migliore.

Answer 5

Il confronto di due valori booleani deve essere gestito con un'operazione XOR.

cercando di confrontare direttamente i due booleani è un uso improprio dei fondamenti della Algebra di Boole: http://en.wikipedia.org/wiki/Boolean_algebra_(logic)

Quando si sta facendo

BOOL a = (b == c); 

allora questo valore può restituire false anche se entrambi B e C sono veri Tuttavia, l'espressione b & & c restituirà sempre SÌ se entrambi b e c sono veri, vale a dire superiore a 0 e NO in caso contrario.

Invece questo è ciò che in realtà si sta cercando di fare:

BOOL xor = b && !c || !b && c; 
BOOL equal = !xor; 

equivalente con

BOOL equal = !(b && !c || !b && c); 

o

BOOL equal = (b && c) || (!b && !c) 

Se si deve spendere tempo fare in modo che il vostro BOOL i valori sono normalizzati (cioè impostati su 1 o 0), quindi stai facendo qualcosa di sbagliato.

Answer 6

Se si assegna il numero intero 2 a una variabile di tipo BOOL, il codice è danneggiato. Qualunque cosa tu abbia dopo, è ciò che meriti.

Pertanto, l'unico modo ragionevole per confrontare due BOOL a e b è

if (a == b) ... 
if (a != b) ...