"Const statica" vs "#define" vs "enum"

Quale è meglio usare tra le seguenti affermazioni in C?

static const int var = 5;

o

#define var 5

o

enum { var = 5 };

Dipende da cosa ti serve il valore. Tu (e tutti gli altri finora) hai omesso la terza alternativa:

1. static const int var = 5;
2. #define var 5
3. enum { var = 5 };

Ignorando i problemi relativi alla scelta del nome, quindi:

• Se è necessario passare un puntatore in giro, è necessario utilizzare (1).
• Poiché (2) è apparentemente un'opzione, non è necessario passare i puntatori in giro.
• Sia (1) che (3) hanno un simbolo nella tabella dei simboli del debugger, che semplifica il debug. È più probabile che (2) non abbia un simbolo, lasciandoti a chiederti di cosa si tratta.
• (1) non può essere utilizzato come dimensione per array di portata globale; entrambi (2) e (3) possono.
• (1) non può essere utilizzato come dimensione per array statici nell'ambito della funzione; entrambi (2) e (3) possono.
• Sotto C99, tutti questi possono essere utilizzati per array locali. Tecnicamente, l'uso di (1) implicherebbe l'uso di un VLA (array di lunghezza variabile), sebbene la dimensione a cui fa riferimento 'var' sarebbe ovviamente fissata alla dimensione 5.
• (1) non può essere utilizzato in luoghi come le istruzioni switch; entrambi (2) e (3) possono.
• (1) non può essere utilizzato per inizializzare le variabili statiche; entrambi (2) e (3) possono.
• (2) può modificare il codice che non si desidera modificare perché viene utilizzato dal preprocessore; entrambi (1) e (3) non avranno effetti collaterali inaspettati come quello.
• È possibile rilevare se (2) è stato impostato nel preprocessore; né (1) né (3) lo consentono.

Quindi, nella maggior parte dei contesti, preferisce l '"enum" rispetto alle alternative. Altrimenti, è probabile che il primo e l'ultimo punto elenco siano i fattori di controllo - e devi pensare di più se devi soddisfare entrambi contemporaneamente.

Se chiedessi informazioni su C ++, useresti sempre l'opzione (1) - la const statica.

Parlando in generale:

static const

Perché rispetta l'ambito ed è sicuro per i tipi.

L'unica avvertenza che ho potuto vedere: se si desidera che la variabile possa essere definita sulla riga di comando. C'è ancora un'alternativa:

#ifdef VAR // Very bad name, not long enough, too general, etc..
  static int const var = VAR;
#else
  static int const var = 5; // default value
#endif

Quando possibile, anziché macro / puntini di sospensione, utilizzare un'alternativa sicura per tipo.

Se hai davvero BISOGNO di andare con una macro (ad esempio, vuoi __FILE__o __LINE__), allora faresti meglio a nominare la tua macro MOLTO attentamente: nella sua convenzione di denominazione Boost raccomanda tutte le lettere maiuscole, a partire dal nome del progetto (qui BOOST_ ), mentre sfogli la libreria noterai che questo è (generalmente) seguito dal nome della particolare area (libreria), quindi con un nome significativo.

In genere crea nomi lunghi :)

In C, in particolare? In C la risposta corretta è: usare #define(o, se appropriato, enum)

Mentre è utile avere le proprietà di scoping e typing di un constoggetto, in realtà gli constoggetti in C (in contrapposizione a C ++) non sono costanti vere e quindi sono generalmente inutili nella maggior parte dei casi pratici.

Quindi, in C la scelta dovrebbe essere determinata da come pensi di usare la tua costante. Ad esempio, non è possibile utilizzare un const intoggetto come caseetichetta (mentre una macro funzionerà). Non è possibile utilizzare un const intoggetto come larghezza del campo bit (mentre una macro funzionerà). In C89 / 90 non è possibile utilizzare un constoggetto per specificare una dimensione dell'array (mentre una macro funzionerà). Anche in C99 non è possibile utilizzare un constoggetto per specificare una dimensione dell'array quando è necessario un array non VLA .

Se questo è importante per te, determinerà la tua scelta. Il più delle volte, non avrai altra scelta che usare #definein C. E non dimenticare un'altra alternativa, che produce vere costanti in C - enum.

In C ++ gli constoggetti sono costanti vere, quindi in C ++ è quasi sempre meglio preferire la constvariante (non c'è bisogno di esplicito staticin C ++).

La differenza tra static conste #defineè che il primo utilizza la memoria e il successivo non utilizza la memoria per l'archiviazione. In secondo luogo, non è possibile passare l'indirizzo di un #definementre è possibile passare l'indirizzo di un static const. In realtà dipende dalle circostanze in cui ci troviamo, dobbiamo selezionarne una tra queste due. Entrambi sono al meglio in circostanze diverse. Per favore, non dare per scontato che uno sia migliore dell'altro ... :-)

Se così fosse, Dennis Ritchie avrebbe tenuto da solo il migliore ... hahaha ... :-)

In C #defineè molto più popolare. Ad esempio, è possibile utilizzare questi valori per dichiarare le dimensioni dell'array:

#define MAXLEN 5

void foo(void) {
   int bar[MAXLEN];
}

ANSI C non ti consente di utilizzare static consts in questo contesto per quanto ne so. In C ++ dovresti evitare le macro in questi casi. Tu puoi scrivere

const int maxlen = 5;

void foo() {
   int bar[maxlen];
}

e addirittura tralasciamo staticperché il collegamento interno è constgià implicito [solo in C ++].

Un altro svantaggio di constin C è che non è possibile utilizzare il valore per inizializzare un altro const.

static int const NUMBER_OF_FINGERS_PER_HAND = 5;
static int const NUMBER_OF_HANDS = 2;

// initializer element is not constant, this does not work.
static int const NUMBER_OF_FINGERS = NUMBER_OF_FINGERS_PER_HAND 
                                     * NUMBER_OF_HANDS;

Anche questo non funziona con una const poiché il compilatore non la vede come una costante:

static uint8_t const ARRAY_SIZE = 16;
static int8_t const lookup_table[ARRAY_SIZE] = {
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}; // ARRAY_SIZE not a constant!

Sarei felice di usare dattiloscritto constin questi casi, altrimenti ...

Se riesci a cavartela, static constha molti vantaggi. Obbedisce ai normali principi dell'ambito, è visibile in un debugger e generalmente obbedisce alle regole alle quali le variabili obbediscono.

Tuttavia, almeno nello standard C originale, in realtà non è una costante. Se lo usi #define var 5, puoi scrivere int foo[var];come una dichiarazione, ma non puoi farlo (tranne che come estensione del compilatore "con static const int var = 5;. Questo non è il caso in C ++, dove la static constversione può essere usata ovunque la #defineversione possa, e credo che questo è anche il caso di C99.

Tuttavia, non nominare mai una #definecostante con un nome minuscolo. Sostituirà qualsiasi possibile uso di quel nome fino alla fine dell'unità di traduzione. Le costanti macro devono trovarsi in quello che è effettivamente il loro spazio dei nomi, che è tradizionalmente tutte le lettere maiuscole, forse con un prefisso.

È SEMPRE preferibile usare const, invece di #define. Questo perché const viene trattata dal compilatore e #define dal preprocessore. È come se #define non facesse parte del codice (in termini approssimativi).

Esempio:

#define PI 3.1416

Il nome simbolico PI non può mai essere visto dai compilatori; può essere rimosso dal preprocessore prima che il codice sorgente arrivi anche a un compilatore. Di conseguenza, il nome PI potrebbe non essere inserito nella tabella dei simboli. Questo può essere fonte di confusione se durante la compilazione viene visualizzato un errore che comporta l'uso della costante, poiché il messaggio di errore può fare riferimento a 3.1416, non a PI. Se il PI fosse definito in un file di intestazione che non hai scritto, non avresti idea da dove provenisse quel 3.1416.

Questo problema può anche insorgere in un debugger simbolico, perché, di nuovo, il nome con cui stai programmando potrebbe non essere nella tabella dei simboli.

Soluzione:

const double PI = 3.1416; //or static const...

#define var 5ti causerà problemi se hai cose del genere mystruct.var.

Per esempio,

struct mystruct {
    int var;
};

#define var 5

int main() {
    struct mystruct foo;
    foo.var = 1;
    return 0;
}

Il preprocessore lo sostituirà e il codice non verrà compilato. Per questo motivo, lo stile di codifica tradizionale suggerisce che tutte le costanti #defineusano lettere maiuscole per evitare conflitti.

Ho scritto un programma di test rapido per dimostrare una differenza:

#include <stdio.h>

enum {ENUM_DEFINED=16};
enum {ENUM_DEFINED=32};

#define DEFINED_DEFINED 16
#define DEFINED_DEFINED 32

int main(int argc, char *argv[]) {

   printf("%d, %d\n", DEFINED_DEFINED, ENUM_DEFINED);

   return(0);
}

Questo compila con questi errori e avvertenze:

main.c:6:7: error: redefinition of enumerator 'ENUM_DEFINED'
enum {ENUM_DEFINED=32};
      ^
main.c:5:7: note: previous definition is here
enum {ENUM_DEFINED=16};
      ^
main.c:9:9: warning: 'DEFINED_DEFINED' macro redefined [-Wmacro-redefined]
#define DEFINED_DEFINED 32
        ^
main.c:8:9: note: previous definition is here
#define DEFINED_DEFINED 16
        ^

Si noti che enum genera un errore quando define dà un avviso.

La definizione

const int const_value = 5;

non definisce sempre un valore costante. Alcuni compilatori (ad esempio tcc 0.9.26 ) allocano solo la memoria identificata con il nome "const_value". Utilizzando l'identificatore "const_value" non è possibile modificare questa memoria. Ma potresti comunque modificare la memoria usando un altro identificatore:

const int const_value = 5;
int *mutable_value = (int*) &const_value;
*mutable_value = 3;
printf("%i", const_value); // The output may be 5 or 3, depending on the compiler.

Questo significa la definizione

#define CONST_VALUE 5

è l'unico modo per definire un valore costante che non può essere modificato in alcun modo.

Sebbene la domanda riguardasse numeri interi, vale la pena notare che #define ed enum sono inutili se hai bisogno di una struttura o stringa costante. Entrambi vengono in genere passati a funzioni come puntatori. (Con le stringhe è richiesto; con le strutture è molto più efficiente.)

Per quanto riguarda gli interi, se ti trovi in ​​un ambiente incorporato con una memoria molto limitata, potresti doverti preoccupare di dove è memorizzata la costante e di come vengono compilati gli accessi ad essa. Il compilatore potrebbe aggiungere due contro in fase di esecuzione, ma aggiungere due #define in fase di compilazione. Una costante #define può essere convertita in una o più istruzioni MOV [immediate], il che significa che la costante è effettivamente memorizzata nella memoria del programma. Una costante const verrà memorizzata nella sezione .const nella memoria dati. Nei sistemi con architettura Harvard, potrebbero esserci differenze nelle prestazioni e nell'utilizzo della memoria, anche se probabilmente sarebbero piccole. Possono essere importanti per l'ottimizzazione del core degli anelli interni.

Non pensare che ci sia una risposta per "che è sempre la cosa migliore" ma, come ha detto Matthieu

static const

è sicuro. Il mio più grande problema con gli animali domestici #define, tuttavia, è quando il debug in Visual Studio non è possibile guardare la variabile. Dà un errore che il simbolo non può essere trovato.

Per inciso, un'alternativa a #define, che fornisce l'ambito corretto ma si comporta come una costante "reale", è "enum". Per esempio:

enum {number_ten = 10;}

In molti casi, è utile definire tipi enumerati e creare variabili di tali tipi; in tal caso, i debugger potrebbero essere in grado di visualizzare le variabili in base al nome dell'enumerazione.

Un avvertimento importante nel farlo, tuttavia: in C ++, i tipi enumerati hanno una compatibilità limitata con numeri interi. Ad esempio, per impostazione predefinita, non è possibile eseguire l'aritmetica su di essi. Trovo che sia un curioso comportamento predefinito per gli enum; mentre sarebbe stato bello avere un tipo "enum rigoroso", dato il desiderio di avere C ++ generalmente compatibile con C, penso che il comportamento predefinito di un tipo "enum" dovrebbe essere intercambiabile con numeri interi.

Una semplice differenza:

Al momento della pre-elaborazione, la costante viene sostituita con il suo valore. Quindi non è possibile applicare l'operatore di dereference a una definizione, ma è possibile applicare l'operatore di dereference a una variabile.

Come si suppone, definire è più veloce della const statica.

Ad esempio, avendo:

#define mymax 100

non puoi fare printf("address of constant is %p",&mymax);.

Ma avendo

const int mymax_var=100

puoi fare printf("address of constant is %p",&mymax_var);.

Per essere più chiari, la definizione viene sostituita dal suo valore nella fase di pre-elaborazione, quindi non abbiamo alcuna variabile memorizzata nel programma. Abbiamo solo il codice dal segmento di testo del programma in cui è stato utilizzato il parametro di definizione.

Tuttavia, per const statici abbiamo una variabile che è allocata da qualche parte. Per gcc, const statici sono allocati nel segmento di testo del programma.

Sopra, volevo parlare dell'operatore di riferimento, quindi sostituisci la dereferenza con il riferimento.

Abbiamo esaminato il codice assemblatore prodotto sull'MBF16X ... Entrambe le varianti danno lo stesso codice per le operazioni aritmetiche (ad esempio ADD Immediate).

Quindi const intè preferito per il controllo del tipo mentre #defineè vecchio stile. Forse è specifico del compilatore. Quindi controlla il tuo codice assemblatore prodotto.

Non sono sicuro di avere ragione, ma secondo me chiamare il #definevalore d è molto più veloce che chiamare qualsiasi altra variabile (o valore const) normalmente dichiarata. È perché quando il programma è in esecuzione e deve usare alcune variabili normalmente dichiarate, deve saltare al posto esatto in memoria per ottenere quella variabile.

Al contrario, quando usa il #definevalore d, il programma non ha bisogno di saltare a nessuna memoria allocata, prende semplicemente il valore. Se #define myValue 7e il programma chiama myValue, si comporta esattamente come quando chiama 7.