"Const estática" vs "#define" vs "enum"

¿Cuál es mejor usar entre las siguientes declaraciones en C?

static const int var = 5;

o

#define var 5

o

enum { var = 5 };

Depende de para qué necesita el valor. Usted (y todos los demás hasta ahora) omitieron la tercera alternativa:

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

Ignorando problemas sobre la elección del nombre, entonces:

• Si necesita pasar un puntero, debe usar (1).
• Dado que (2) aparentemente es una opción, no necesita pasar punteros.
• Ambos (1) y (3) tienen un símbolo en la tabla de símbolos del depurador, lo que facilita la depuración. Es más probable que (2) no tenga un símbolo, dejándote preguntando qué es.
• (1) no se puede usar como una dimensión para matrices de alcance global; ambos (2) y (3) can.
• (1) no se puede utilizar como una dimensión para matrices estáticas en el alcance de la función; ambos (2) y (3) can.
• Bajo C99, todos estos pueden usarse para arreglos locales. Técnicamente, el uso de (1) implicaría el uso de un VLA (matriz de longitud variable), aunque la dimensión referenciada por 'var', por supuesto, se fijaría en el tamaño 5.
• (1) no se puede usar en lugares como declaraciones de cambio; ambos (2) y (3) can.
• (1) no se puede usar para inicializar variables estáticas; ambos (2) y (3) can.
• (2) puede cambiar el código que no quería cambiar porque lo usa el preprocesador; ambos (1) y (3) no tendrán efectos secundarios inesperados como ese.
• Puede detectar si (2) se ha configurado en el preprocesador; ni (1) ni (3) lo permiten.

Entonces, en la mayoría de los contextos, prefiera la 'enumeración' sobre las alternativas. De lo contrario, es probable que el primer y el último punto sean los factores de control, y debe pensar más si necesita satisfacer ambos a la vez.

Si estuviera preguntando sobre C ++, usaría la opción (1), la constante estática, cada vez.

Generalmente hablando:

static const

Porque respeta el alcance y es de tipo seguro.

La única advertencia que pude ver: si desea que la variable se defina posiblemente en la línea de comando. Todavía hay una 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

Siempre que sea posible, en lugar de macros / puntos suspensivos, use una alternativa de tipo seguro.

Si realmente NECESITA ir con una macro (por ejemplo, quiere __FILE__o __LINE__), será mejor que nombre su macro MUY cuidadosamente: en su convención de nomenclatura Boost recomienda todo en mayúsculas, comenzando por el nombre del proyecto (aquí BOOST_ ), al examinar la biblioteca, notará que esto es (generalmente) seguido del nombre del área particular (biblioteca) y luego con un nombre significativo.

Generalmente hace nombres largos :)

En C, específicamente? En C la respuesta correcta es: uso #define(o, si corresponde,enum )

Si bien es beneficioso tener las propiedades de alcance y escritura de un constobjeto, en realidadconst objetos en C (a diferencia de C ++) no son constantes verdaderas y, por lo tanto, generalmente son inútiles en la mayoría de los casos prácticos.

Entonces, en C, la elección debe estar determinada por cómo planea usar su constante. Por ejemplo, no puede usar un const intobjeto como caseetiqueta (mientras que una macro funcionará). No puede usar un const intobjeto como un ancho de campo de bits (mientras que una macro funcionará). En C89 / 90 no puede usar un constobjeto para especificar un tamaño de matriz (mientras que una macro funcionará). Incluso en C99 no puede usar un constobjeto para especificar un tamaño de matriz cuando necesita una matriz que no sea VLA .

Si esto es importante para usted, determinará su elección. La mayoría de las veces, no tendrá más remedio que usarlo #defineen C. Y no olvide otra alternativa, que produce constantes verdaderas en C - enum.

En C ++, los constobjetos son constantes verdaderas, por lo que en C ++ casi siempre es mejor preferir la constvariante (sin staticembargo, no es necesario explícito en C ++).

La diferencia entre static consty #definees que el primero usa la memoria y el segundo no usa la memoria para el almacenamiento. En segundo lugar, no puede pasar la dirección de un #definemientras que puede pasar la dirección de unstatic const . En realidad, dependiendo de las circunstancias en que nos encontremos, debemos seleccionar uno de estos dos. Ambos están en su mejor momento bajo diferentes circunstancias. Por favor, no asuma que uno es mejor que el otro ... :-)

Si ese hubiera sido el caso, Dennis Ritchie habría mantenido el mejor solo ... jajaja ... :-)

En C #definees mucho más popular. Puede usar esos valores para declarar tamaños de matriz, por ejemplo:

#define MAXLEN 5

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

ANSI C no le permite usar static consts en este contexto hasta donde yo sé. En C ++ debe evitar las macros en estos casos. Puedes escribir

const int maxlen = 5;

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

e incluso dejar de lado staticporque el enlace interno ya está implícito const[solo en C ++].

Otro inconveniente de consten C es que no puede usar el valor para inicializar otro 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;

Incluso esto no funciona con una constante, ya que el compilador no lo ve como una constante:

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!

Me encantaría usar mecanografiado consten estos casos, de lo contrario ...

Si puede salirse con la suya, static consttiene muchas ventajas. Obedece a los principios del alcance normal, es visible en un depurador y generalmente obedece las reglas que obedecen las variables.

Sin embargo, al menos en el estándar C original, en realidad no es una constante. Si lo usa #define var 5, puede escribir int foo[var];como una declaración, pero no puede hacerlo (excepto como una extensión del compilador "con static const int var = 5;. Este no es el caso en C ++, donde la static constversión se puede usar en cualquier lugar que la #defineversión pueda, y creo que esto Es también el caso de C99.

Sin embargo, nunca nombre una #defineconstante con un nombre en minúscula. Anulará cualquier posible uso de ese nombre hasta el final de la unidad de traducción. Las constantes macro deberían estar en lo que efectivamente es su propio espacio de nombres, que tradicionalmente son todas letras mayúsculas, quizás con un prefijo.

SIEMPRE es preferible usar const, en lugar de #define. Eso es porque const es tratado por el compilador y #define por el preprocesador. Es como si #definir en sí mismo no formara parte del código (más o menos).

Ejemplo:

#define PI 3.1416

El nombre simbólico PI nunca puede ser visto por los compiladores; puede ser eliminado por el preprocesador incluso antes de que el código fuente llegue a un compilador. Como resultado, es posible que el nombre PI no se ingrese en la tabla de símbolos. Esto puede ser confuso si obtiene un error durante la compilación que implica el uso de la constante, porque el mensaje de error puede referirse a 3.1416, no a PI. Si PI se definiera en un archivo de encabezado que no escribió, no tendría idea de dónde vino ese 3.1416.

Este problema también puede surgir en un depurador simbólico, porque, nuevamente, el nombre con el que está programando puede no estar en la tabla de símbolos.

Solución:

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

#define var 5te causará problemas si tienes cosas como mystruct.var.

Por ejemplo,

struct mystruct {
    int var;
};

#define var 5

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

El preprocesador lo reemplazará y el código no se compilará. Por esta razón, el estilo de codificación tradicional sugiere que todas las constantes #defineusan letras mayúsculas para evitar conflictos.

Escribí un programa de prueba rápida para demostrar una diferencia:

#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);
}

Esto compila con estos errores y advertencias:

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
        ^

Tenga en cuenta que enum da un error cuando define da una advertencia.

La definición

const int const_value = 5;

no siempre define un valor constante. Algunos compiladores (por ejemplo, tcc 0.9.26 ) simplemente asignan memoria identificada con el nombre "const_value". Usando el identificador "const_value" no puede modificar esta memoria. Pero aún podría modificar la memoria utilizando otro identificador:

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.

Esto significa la definición

#define CONST_VALUE 5

es la única forma de definir un valor constante que no puede modificarse de ninguna manera.

Aunque la pregunta era sobre enteros, vale la pena señalar que #define y las enumeraciones son inútiles si necesita una estructura o cadena constante. Ambos se pasan generalmente a funciones como punteros. (Con cadenas es necesario; con estructuras es mucho más eficiente).

En cuanto a los enteros, si está en un entorno incrustado con memoria muy limitada, es posible que deba preocuparse sobre dónde se almacena la constante y cómo se compilan los accesos a ella. El compilador puede agregar dos consts en tiempo de ejecución, pero agrega dos #defines en tiempo de compilación. Una constante #define puede convertirse en una o más instrucciones MOV [inmediatas], lo que significa que la constante se almacena efectivamente en la memoria del programa. Una constante constante se almacenará en la sección .const en la memoria de datos. En sistemas con una arquitectura de Harvard, podría haber diferencias en el rendimiento y el uso de la memoria, aunque probablemente serían pequeños. Pueden ser importantes para la optimización de núcleo duro de los bucles internos.

No creo que haya una respuesta para "lo que siempre es mejor" pero, como dijo Matthieu

static const

Es de tipo seguro. Sin #defineembargo, mi mayor motivo de molestia es cuando al depurar en Visual Studio no se puede ver la variable. Da un error que el símbolo no se puede encontrar.

Por cierto, una alternativa a #define, que proporciona un alcance adecuado pero se comporta como una constante "real", es "enum". Por ejemplo:

enum {number_ten = 10;}

En muchos casos, es útil definir tipos enumerados y crear variables de esos tipos; si eso se hace, los depuradores pueden mostrar variables de acuerdo con su nombre de enumeración.

Sin embargo, una advertencia importante para hacerlo: en C ++, los tipos enumerados tienen compatibilidad limitada con los enteros. Por ejemplo, por defecto, uno no puede realizar operaciones aritméticas sobre ellos. Me parece un comportamiento curioso por defecto para las enumeraciones; si bien hubiera sido bueno tener un tipo "enum estricto", dado el deseo de tener C ++ generalmente compatible con C, creo que el comportamiento predeterminado de un tipo "enum" debería ser intercambiable con enteros.

Una simple diferencia:

En el tiempo de preprocesamiento, la constante se reemplaza por su valor. Por lo tanto, no puede aplicar el operador de referencia a una definición, pero puede aplicar el operador de referencia a una variable.

Como es de suponer, definir es más rápido que la constante estática.

Por ejemplo, tener:

#define mymax 100

No puedes hacer printf("address of constant is %p",&mymax);.

Pero teniendo

const int mymax_var=100

que puede hacer printf("address of constant is %p",&mymax_var);.

Para ser más claro, la definición se reemplaza por su valor en la etapa de preprocesamiento, por lo que no tenemos ninguna variable almacenada en el programa. Solo tenemos el código del segmento de texto del programa donde se utilizó la definición.

Sin embargo, para const estática tenemos una variable que se asigna en algún lugar. Para gcc, las constantes estáticas se asignan en el segmento de texto del programa.

Arriba, quería contar sobre el operador de referencia, así que reemplace la desreferencia con referencia.

Observamos el código de ensamblador producido en el MBF16X ... Ambas variantes dan como resultado el mismo código para operaciones aritméticas (ADD Inmediato, por ejemplo).

Por const intlo tanto, se prefiere para la verificación de tipo, mientras que #definees de estilo antiguo. Tal vez es específico del compilador. Así que verifique su código de ensamblador producido.

No estoy seguro de tener razón, pero en mi opinión, llamar al #definevalor d es mucho más rápido que llamar a cualquier otra variable normalmente declarada (o valor constante). Es porque cuando el programa se está ejecutando y necesita usar alguna variable normalmente declarada, necesita saltar al lugar exacto en la memoria para obtener esa variable.

Al contrario, cuando usa el #definevalor d, el programa no necesita saltar a ninguna memoria asignada, solo toma el valor. Si #define myValue 7y el programa llama myValue, se comporta exactamente igual que cuando solo llama 7.