Perché scrivere 1.000.000.000 come 1000 * 1000 * 1000 in C?

Nel codice creato da Apple, c'è questa riga:

CMTimeMakeWithSeconds( newDurationSeconds, 1000*1000*1000 )

C'è qualche motivo per esprimere 1,000,000,000come 1000*1000*1000?

Perché non 1000^3per quello?

Un motivo per dichiarare le costanti in modo moltiplicativo è migliorare la leggibilità, mentre le prestazioni di runtime non sono influenzate. Inoltre, per indicare che lo scrittore stava pensando in modo moltiplicativo al numero.

Considera questo:

double memoryBytes = 1024 * 1024 * 1024;

È chiaramente meglio di:

double memoryBytes = 1073741824;

poiché quest'ultimo non sembra, a prima vista, la terza potenza del 1024.

Come menzionato da Amin Negm-Awad, l' ^operatore è il binario XOR. Molte lingue mancano dell'operatore esponenziale incorporato, in fase di compilazione, da cui la moltiplicazione.

Perché no 1000^3?

Il risultato 1000^3è 1003. ^è l'operatore bit-XOR.

Anche se non si occupa della Q stessa, aggiungo un chiarimento. x^ynon non sempre valutata come x+ycome in l'esempio del interrogante. Devi xor ogni bit. Nel caso dell'esempio:

1111101000₂ (1000₁₀)
0000000011₂ (3₁₀)
1111101011₂ (1003₁₀)

Ma

1111101001₂ (1001₁₀)
0000000011₂ (3₁₀)
1111101010₂ (1002₁₀)

Ci sono ragioni per non usare 1000 * 1000 * 1000.

Con 16 bit int, 1000 * 1000straripa. Quindi l'utilizzo 1000 * 1000 * 1000riduce la portabilità.

Con 32 bit int, la seguente prima riga di overflow del codice.

long long Duration = 1000 * 1000 * 1000 * 1000;  // overflow
long long Duration = 1000000000000;  // no overflow, hard to read

Suggerire che il valore iniziale corrisponda al tipo di destinazione per leggibilità, portabilità e correttezza.

double Duration = 1000.0 * 1000 * 1000;
long long Duration = 1000LL * 1000 * 1000 * 1000;

Inoltre potrebbe usare la semplice enotazione per valori che sono esattamente rappresentabili come a double. Naturalmente questo porta a sapere se doublepuò rappresentare esattamente l'intero valore numerico - qualcosa di preoccupante con valori maggiori di 1e9. (Vedi DBL_EPSILONe DBL_DIG).

long Duration = 1000000000;
// vs.
long Duration = 1e9;

Per leggibilità.

Posizionare virgole e spazi tra gli zeri ( 1 000 000 000o 1,000,000,000) produrrebbe un errore di sintassi e avere 1000000000nel codice rende difficile vedere esattamente quanti zeri ci sono.

1000*1000*1000rende evidente che sono 10 ^ 9, perché i nostri occhi possono elaborare i blocchi più facilmente. Inoltre, non ci sono costi di runtime, perché il compilatore lo sostituirà con la costante 1000000000.

Per leggibilità. Per fare un confronto, Java supporta i _numeri per migliorare la leggibilità (proposta per la prima volta da Stephen Colebourne come risposta alla PROPOSTA di Derek Foster: Binary Literals for Project Coin / JSR 334). Si scriverebbe 1_000_000_000qui.

In ordine approssimativamente cronologico, dal supporto più vecchio al più recente:

• XPL: "(1)1111 1111"( apparentemente non per valori decimali, solo per stringhe di bit che rappresentano valori binari, quartali, ottali o esadecimali )
• PL / M: 1$000$000
• Ada: 1_000_000_000
• Perl: allo stesso modo
• Ruby: allo stesso modo
• Fantom (precedentemente Fan): allo stesso modo
• Java 7: allo stesso modo
• Swift: (stesso?)
• Python 3.6
• C ++ 14: 1'000'000'000

È una funzionalità relativamente nuova per le lingue rendersi conto che dovrebbero supportare (e poi c'è Perl). Come nell'eccellente risposta di chux @, 1000*1000...è una soluzione parziale, ma apre il programmatore ai bug di overflow della moltiplicazione anche se il risultato finale è di tipo elevato.

Potrebbe essere più semplice da leggere e ottenere alcune associazioni con il 1,000,000,000modulo.

Dal punto di vista tecnico immagino non ci sia differenza tra il numero diretto o la moltiplicazione. Il compilatore lo genererà comunque come numero di miliardi costanti.

Se parli di object-c, allora 1000^3non funzionerà perché non esiste una sintassi simile per pow (è xor). Invece, è pow()possibile utilizzare la funzione. Ma in tal caso, non sarà ottimale, sarà una funzione di runtime chiamata non una costante generata dal compilatore.

Per illustrare i motivi, prendere in considerazione il seguente programma di test:

$ cat comma-expr.c && gcc -o comma-expr comma-expr.c && ./comma-expr
#include <stdio.h>

#define BILLION1 (1,000,000,000)
#define BILLION2 (1000^3)

int main()
{
        printf("%d, %d\n", BILLION1, BILLION2);
}
0, 1003
$

Un altro modo per ottenere un effetto simile in C per i numeri decimali è utilizzare la notazione letterale in virgola mobile - purché un doppio possa rappresentare il numero desiderato senza alcuna perdita di precisione.

Il doppio IEEE 754 a 64 bit può rappresentare qualsiasi numero intero non negativo <= 2 ^ 53 senza problemi. In genere, il doppio lungo (80 o 128 bit) può andare anche oltre. Le conversioni verranno eseguite al momento della compilazione, quindi non vi è alcun sovraccarico di runtime e probabilmente si riceveranno avvisi se si verifica una perdita imprevista di precisione e si dispone di un buon compilatore.

long lots_of_secs = 1e9;