TRUE ha sempre avuto un valore diverso da zero?

StackOverflow https://stackoverflow.com/questions/104225

  •  01-07-2019
  •  | 
  •  

Domanda

Ho un collega che sostiene che TRUE era definito come 0 e che tutti gli altri valori erano FALSE. Potrei giurare che ogni lingua con cui ho lavorato, se potessi anche ottenere un valore per un valore booleano, che il valore per FALSE è 0. TRUE era 0? In tal caso, quando siamo passati?

È stato utile?

Soluzione

La cosa 0 / non-0 di cui il tuo collega è confuso si riferisce probabilmente a quando le persone usano valori numerici come valore di ritorno che indica successo, non verità (cioè negli script bash e alcuni stili di C / C ++).

L'uso di 0 = success consente una precisione molto maggiore nello specificare le cause del fallimento (ad es. 1 = file mancante, 2 = arto mancante e così via).

Come nota a margine: in Ruby, gli unici valori falsi sono zero e falso. 0 è vero, ma non al contrario di altri numeri. 0 è vero perché è un'istanza dell'oggetto 0.

Altri suggerimenti

Potrebbe essere in riferimento a un codice risultato di 0 che nella maggior parte dei casi dopo l'esecuzione di un processo, un codice risultato di 0 significava " Ehi, tutto ha funzionato bene, nessun problema qui. " ;

Ho lavorato in un'azienda con una grande quantità di vecchio codice C. Alcune delle intestazioni condivise hanno definito i propri valori per TRUE e FALSE, e alcune hanno effettivamente TRUE come 0 e FALSE come 1. Ciò ha portato a & Quot; guerre di verità & Quot ;: 

/* like my constants better */
#undef TRUE
#define TRUE 1

#undef FALSE
#define FALSE 0

Se non altro, le shell bash usano ancora 0 per true e 1 per false.

Diverse funzioni nella libreria standard C restituiscono un numero intero di 'codice errore' come risultato. Poiché noErr è definito come 0, un controllo rapido può essere "se è 0, è OK". La stessa convenzione ha portato a un "codice di risultato" del processo Unix; cioè un numero intero che ha dato qualche inidicazione su come un determinato processo è terminato.

Nello scripting della shell Unix, è disponibile il codice di risultato di un comando appena eseguito, e tipicamente usato per indicare se il comando 'ha avuto successo' o no, con 0 che significa successo, e qualsiasi altra cosa una specifica condizione di non successo.

Da ciò, tutti i costrutti simili a test negli script di shell usano "successo" (ovvero un codice risultato 0) per indicare VERO e qualsiasi altra cosa per FALSO.

Su un piano totalmente diverso, i circuiti digitali utilizzano in modo errato la "logica negativa". vale a dire, anche se 0 volt viene chiamato 'binario 0' e alcuni valori positivi (comunemente + 5v o + 3.3v, ma al giorno d'oggi non è raro usare + 1,8v) è chiamato 'binario 1', alcuni eventi sono 'affermati' da un dato pin a 0. Penso che ci siano alcuni vantaggi resistenti al rumore, ma non sono sicuro dei motivi.

Nota, tuttavia, che non c'è nulla di "antico" o di "tempo di commutazione" al riguardo. Tutto ciò che so di questo si basa su vecchie convenzioni, ma oggi sono totalmente attuali e pertinenti.

Non ne sono certo, ma posso dirti questo: i trucchi che fanno affidamento sulla natura di fondo di TRUE e FALSE sono inclini a errori perché la definizione di questi valori è lasciata all'implementatore del linguaggio (o, al per lo meno, lo specificatore).

Le chiamate di sistema nella libreria standard C in genere restituiscono -1 in caso di errore e 0 in caso di successo. Anche il Fotran ha calcolato se l'istruzione salta (e probabilmente lo fa ancora) a uno dei tre numeri di riga a seconda della condizione che valuta minore, uguale o maggiore di zero.

ad es .: IF (I-15) 10,20,10

verificherebbe la condizione di I == 15 saltando alla linea 20 se vero (restituisce zero) e la linea 10 altrimenti.

Sam ha ragione sui problemi di fare affidamento su una conoscenza specifica dei dettagli di implementazione.

Regola generale:

  1. Conchiglie (DOS incluso) usano " 0 " come " No Errore & Quot; ... non necessariamente vero.

  2. I linguaggi di programmazione utilizzano diverso da zero per indicare vero.

Detto questo, se sei in una lingua che ti permette di definire VERO di FALSO, definiscilo e usa sempre le costanti.

Anche oggi, in alcune lingue (Ruby, lisp, ...) 0 è vero perché tutto tranne zero è vero. Più spesso 1 è vero. Questo è un gotcha comune e quindi a volte è considerata una buona pratica non fare affidamento sul fatto che 0 sia falso, ma fare un test esplicito. Java richiede di farlo.

Invece di questo 

int x;    
....
x = 0;
if (x)  // might be ambiguous
{
}

Rendi esplicito 

if (0 != x)
{
}

Ricordo di aver fatto un po 'di programmazione VB in un modulo di accesso in cui True era -1.

Ricordo che PL / 1 non aveva una classe booleana. Potresti creare un po 'e assegnarlo come risultato di un'espressione booleana. Quindi, per usarlo, dovevi ricordare che 1 era falso e 0 era vero.

Per la maggior parte, false è definita come 0 e true è diverso da zero. Alcuni linguaggi di programmazione usano 1, alcuni usano -1 e altri usano qualsiasi valore diverso da zero.

Per le shell Unix, tuttavia, usano la convenzione opposta.

La maggior parte dei comandi eseguiti in una shell Unix sono in realtà piccoli programmi. Restituiscono un codice di uscita in modo da poter determinare se il comando ha avuto esito positivo (un valore di 0) o se non è riuscito per qualche motivo (1 o più, a seconda del tipo di errore).

Questo è usato negli interpreti shell sh / ksh / bash all'interno dei comandi if / while / until per verificare le condizioni: 

if command
then
   # successful
fi

Se il comando ha esito positivo (ovvero restituisce un codice di uscita zero), viene eseguito il codice all'interno dell'istruzione. Di solito, il comando utilizzato è il [comando, che è un alias per il comando test.

La cosa divertente è che dipende dalla lingua con cui stai lavorando. In Lua è vero == zero interno per le prestazioni .. Lo stesso per molte syscalls in C.

È facile confondersi quando le dichiarazioni di ritorno vero / falso di bash sono al contrario: 

$ false; echo $?
1
$ true; echo $?
0

Ho sentito parlare e usato compilatori più vecchi in cui vero > 0 e false & Lt; = 0.

Questo è uno dei motivi per cui non vuoi usare if (puntatore) o if (numero) per controllare lo zero, potrebbero valutare falso inaspettatamente.

Allo stesso modo, ho lavorato su sistemi in cui NULL non era zero.

Nel linguaggio C, prima del C ++, non esisteva un booleano. I condizionali sono stati eseguiti testando gli ints. Zero significa falso e qualsiasi altro non zero significa vero. Quindi potresti scrivere 

if (2) {
  alwaysDoThis();
} else {
  neverDothis();
}

Fortunatamente il C ++ ha permesso un tipo booleano dedicato.

In qualsiasi lingua in cui abbia mai lavorato (tornando a BASIC alla fine degli anni '70), false è stata considerata 0 e true è stata diversa da zero.

Non ricordo che TRUE sia 0. 1 è qualcosa che un programmatore C tornerebbe per indicare il successo, però. Questo può essere confuso con -1.

Non è neanche sempre <=>. Può essere <=> o semplicemente diverso da zero.

Per le lingue senza un tipo booleano incorporato, l'unica convenzione che ho visto è definire TRUE come 1 e FALSE come 0. Ad esempio, in C, l'istruzione if eseguirà la clausola if se l'espressione condizionale valuta qualsiasi cosa diversa da 0.

Ho anche visto una volta un documento sulle linee guida per la codifica che diceva specificamente di non ridefinire VERO e FALSO. :)

Se stai usando un linguaggio che ha un booleano incorporato, come C ++, le parole chiave true e false fanno parte del linguaggio e non dovresti fare affidamento su come sono effettivamente implementate.

In lingue come C non esisteva un valore booleano, quindi dovevi definire il tuo. Potrebbero aver lavorato su una sostituzione BOOL non standard?

I codici DOS e di uscita delle applicazioni generalmente usano 0 per indicare il successo e diversi da zero per indicare un errore di qualche tipo!

I codici di errore DOS sono 0-255 e quando testati usando la sintassi 'errorlevel' significano qualcosa sopra o includendo il valore specificato, quindi i seguenti abbinano 2 e sopra al primo goto, 1 al secondo e 0 (successo) a l'ultimo! 

IF errorlevel 2 goto CRS
IF errorlevel 1 goto DLR
IF errorlevel 0 goto STR

Il motore di database di SQL Server ottimizza l'archiviazione delle colonne di bit. Se in una tabella sono presenti 8 o meno colonne di bit, le colonne vengono memorizzate come 1 byte. Se ci sono colonne da 9 a 16 bit, le colonne vengono archiviate come 2 byte e così via. I valori di stringa TRUE e FALSE possono essere convertiti in valori di bit: TRUE viene convertito in 1 e FALSE viene convertito in 0. La conversione in bit promuove qualsiasi valore diverso da zero in 1.

Ogni lingua può avere 0 come vero o falso Quindi smetti di usare il numero usa le parole true lol O t e f 1 byte di archiviazione

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top