In lingue che non consentono il carattere di sottolineatura in costanti intere, è buona norma creare una costante per 1 miliardo?

In lingue che non consentono la sottolineatura in letterali interi , è una buona idea creare una costante per 1 miliardo? ad es. in C ++:

size_t ONE_BILLION = 1000000000;

Certamente, non dovremmo creare costanti per piccoli numeri come 100. Ma con 9 zeri, è probabilmente facile lasciare uno zero o aggiungerne uno in più in questo modo:

tv_sec = timeInNanosec / 1000000000;
tv_nsec = timeInNanosec % 1000000000;

La maggior parte delle lingue presenta una sorta di notazione esponenziale. Un milione è 1e6, (che significa 1 volte 10 alla potenza di 6). Questo sostanzialmente risolve il problema anche meglio della maggior parte delle proposizioni qui.

In molti linguaggi simili a C, la notazione scientifica sta tuttavia definendo un tipo a virgola mobile , il che è un peccato se hai davvero bisogno di un int. Tuttavia, puoi facilmente digitare il cast di quella costante per evitare conversioni implicite nel tuo formulare.

n / int(1e9) si dividerebbe per un miliardo.

Nel tuo esempio, affrontando le quantità fisiche (tempo in nanosecondi), mi chiedo generalmente se il numero intero sia il tipo giusto. In effetti un virgola mobile doublepotrebbe essere più adatto quando si tratta di quantità misurabili (anche se ci sono ovviamente casi in cui si preferisce a long long).

Creane uno chiamato NANOSECONDS_IN_ONE_SECOND invece come quello che rappresenta.

O un nome più breve e migliore se riesci a pensare a uno.

Le costanti hanno lo scopo di dare significato ai numeri. Non c'è alcun significato ulteriore ONE_BILLIONa 1000000000. In realtà, lo rende più confuso, perché in diversi linguaggi naturali, un miliardo significa qualcosa di diverso (mille milioni o un milione di milioni)! Se vuoi scriverlo più breve, ci sono buone probabilità che il tuo linguaggio di programmazione consenta l'uso della notazione scientifica, ad es 1e9. Altrimenti, sono d'accordo con @JohnB, che questo numero indica davvero il numero di nanosecondi in un secondo, quindi chiamatelo così.

Per uno o due usi, userei la convenzione:

tv_sec = timeInNanosec / (1000 * 1000 * 1000);
tv_nsec = timeInNanosec % (1000 * 1000 * 1000);

È perfettamente autoesplicativo, viene compilato in una costante ed è difficile sbagliare.

Inoltre, è molto utile in casi come:

var Time = 24 * 60 * 60;

dove è facile vedere, stiamo parlando di un giorno in pochi secondi.

La lunghezza del valore non è ciò che definisce se è necessaria o meno una costante.

Usa le costanti per evitare numeri magici , non per scrivere.

Ad esempio queste sono costanti perfettamente valide:

public static final int CLOSE_CURSORS_AT_COMMIT = 1;
public static final int CONCUR_READ_ONLY = 2;
public static final int CONCUR_UPDATABLE = 3;
public static final int FETCH_FORWARD = 4;
public static final int FETCH_REVERSE = 5; 
public static final int FETCH_UNKNOWN = 6;
public static final int HOLD_CURSORS_OVER_COMMIT = 7;
public static final int TYPE_FORWARD_ONLY = 8;
public static final int TYPE_SCROLL_INSENSITIVE = 9;
public static final int TYPE_SCROLL_SENSITIVE = 10;

Uso:

public static final int NANOSECS_PER_SECOND = 1000000000;

(esempi di codice sono in Java, traduci nella tua lingua preferita)

Un miliardo americano o europeo?

(o in termini tecnici, un miliardo in scala corta o lunga - uno è 1000 milioni, l'altro è un milione milioni).

Data questa confusione, allora direi di sì - ha senso definirlo una volta e mantenerlo, allo stesso modo si applica a qualsiasi costante su cui è necessario concordare la definizione - definirla una volta.

Ragioni per non farlo

In primo luogo, ecco un motivo per non scrivere caratteri di sottolineatura o usare alcun trucco per simularlo: rende le costanti più difficili da trovare nel codice. Supponiamo che alcuni programmi mostrino, da qualche parte nel suo funzionamento, un valore hard-code 1500000 per alcuni parametri. Voglio sapere dove si verifica effettivamente nel codice sorgente del programma, quindi grep il codice 1500000e non trovo nulla. Perché? Potrebbe essere in esadecimali (ma perché per un numero decimale tondo). A mia insaputa, la costante è in realtà scritta come 1_500_000. Avevo bisogno di regex 1_?500_?000.

Personaggi guida nel commento

Solo perché un tipo di aiuto visivo non è disponibile o non desideriamo utilizzarlo per il motivo precedente, non significa che non possiamo sfruttare le due dimensioni del file di testo per creare un aiuto visivo alternativo:

foo = bar / 1000000000;
//           --^--^--^  

Con questo possiamo facilmente convincerci che ci sono tre gruppi di tre zeri. Tuttavia, possiamo ancora grep per il codice sorgente 1000000000e trovarlo.

Sintassi da colorare

Un editor di testo con colorazione di sintassi programmabile può essere creato per colorare gruppi di cifre in costanti numeriche con colori alternati per una migliore leggibilità. Non dobbiamo fare nulla nel codice.

Preelaborazione: C, C ++, Obiettivo C

Ora, se vogliamo davvero alcune virgole tra le cifre, in C e C ++ possiamo usare un po 'di preelaborazione:

/* Four digit base TH-ousand constant macro */
/* Condensed using Horner's rule */
#define TH(A,B,C,D) ((((((A) * 1000) + (B)) * 1000) + (C)) * 1000 + D)

tv_sec = nanoseconds / TH(1,000,000,000)

Funziona per numeri come TH(1,234,567,890).

Una macro simile a TH può anche funzionare con incollare token anziché con l'aritmetica. Nel preprocessore C, l' ##operatore binario ("token paste") può essere utilizzato in un corpo macro per incollare due operandi in un singolo token. Uno o entrambi gli operandi possono essere argomenti macro. Il rovescio della medaglia qui (creando un rischio per noi) è che se la catenazione risultante non è un token valido, il comportamento non è definito.

#define TOK4(A, B, C, D) A ## B ## C ## D

Adesso

TOK4(1,000,000,000)       /* produces the single token 1000000000 */
TOK4(1,123,000,000.0E+2)  /* produces the single token 1123000000.0E+2 */
TOK4(pr,in,t,f)           /* produces the token printf */
TOK4(#,*,a,b)             /* undefined behavior, #*ab is not valid token syntax */

Esistono programmi C che incollano identificatori e usano i risultati per nominare variabili e funzioni globali e sono terribili con cui lavorare perché sono impermeabili a strumenti come GNU id-utils e ctags.

Sì, sembra un'idea ragionevole. Gli errori DIGIT off-by-one sono persino peggiori dei famigerati errori off-by-one. Tuttavia, può creare confusione per altre persone (incluso il tuo sé futuro) per leggere il codice.

Un nome più esplicativo come NANOSEC_PER_SEC sembra buono, in quanto aggiungerebbe chiarezza dove viene utilizzato per il tempo. Tuttavia, non ha senso utilizzare in contesti diversi dal tempo e non sarebbe pratico creare 1.000.000.000 separate per ogni situazione.

Quello che vuoi davvero fare, sciocco come sembra all'inizio, è "dividi in secondi". Questo lascia NANO_PER, che non è solo indipendente dalla lingua (10 ^ 9 in America ed Europa) ma anche indipendente dalla situazione (senza limitare le unità), ed è facile da scrivere e da leggere.

In generale è una cattiva idea usare costanti scalari per conversioni di unità, e se ti ritrovi a creare costanti per tali cose, stai facendo conversioni in troppi posti.

Quando hai una quantità di un'unità (diciamo, 10 secondi) e vuoi convertirla in un'altra unità (ad es. Nanosecondi); questo è precisamente il momento di utilizzare il sistema di tipi della tua lingua per garantire che le unità siano effettivamente ridimensionate come previsto.

Fai la tua funzione di prendere un Nanosecondsparametro e fornire agli operatori di conversione e / o costruttori in tale ramo Seconds, Minuteso quello che-hanno-te. Questo è dove il vostro const into #defineo 1e9visto in altre risposte appartiene.

Questo evita di avere variabili di unità ambigue che fluttuano attorno al tuo codice; e impedisce intere strisce di bug da dove è stata applicata la moltiplicazione / divisione errata, o era già stata applicata, o la quantità era effettivamente distanza anziché tempo, o ...

Inoltre, in tali classi è bene rendere privata la costruzione da semplici scalari e usare un "MakeSeconds (int)" statico o simile per scoraggiare l'uso sciatto di numeri opachi.

Più precisamente al tuo esempio, in C ++ controlla Boost.Chrono .

Personalmente non considero una buona pratica creare una costante a meno che non debba essere una costante. Se sarà in più punti e averlo definito nella parte superiore del file per modifiche / o test sarà utile, allora assolutamente.

Se è solo perché è scomodo da digitare? allora no.

Personalmente, se ottengo il codice di qualcun altro con una costante definita, in genere lo considero un aspetto importante del codice. Ad esempio tcp mantiene in vita i timer, è consentito il numero massimo di connessioni. Se dovessi eseguire il debug, probabilmente presterei molta attenzione non necessaria al tentativo di capire perché / dove viene utilizzato.

Quando pensi al motivo per cui hai scritto "1 miliardo" anziché "1000000000" nel titolo della domanda, ti renderai conto del perché la risposta è sì.

Non creare una costante per i tuoi grandi letterali. Avresti bisogno di una costante per ognuno di questi letterali, che è (a mio avviso) uno scherzo completo. Se hai un disperato bisogno di rendere i tuoi letterali più chiari senza l'aiuto di cose come l'evidenziazione della sintassi, potresti (anche se non lo farei) creare funzioni o macro per rendere la tua vita "più facile":

#define SPLIT3(x, y, z) x##y##z

int largeNumber1 = SPLIT3(123,456,789);
int largeNumber2 = 123456789;

Vorrei fare questo:

const int Million = 1000 * 1000;
const int Billion = 1000 * Million;

o

const int SciMega = 1000 * 1000; const int SciGiga = 1000 * SciMega;

Per quanto riguarda il numero di nanosecondi al secondo: nano è "l'inverso" della giga.

Kilo  Mega  Giga   etc.
10^3  10^6  10^9
Milli Micro Nano   etc.
10^-3 10^-6 10^-9

Nota "Sci" - per scientifico, come nei computer, i significati di chilo, mega, giga ecc. Sono diversi: 1024 (2 ^ 10), 1024 * 1024 (2 ^ 20), ecc. 2 megabyte non sono 2.000.000 di byte .

AGGIORNAMENTO Il commentatore ha sottolineato che esistono termini speciali per esponenti digitali di 2: http://en.wikipedia.org/wiki/Mebibyte