Constantes em C: const, #define e enum

Uma constante é um valor com um nome e uma promessa de que ele não vai mudar. C te dá três mecanismos para isso, e eles são coisas genuinamente diferentes por baixo do capô - um é uma variável, um é substituição de texto e um é um tipo inteiro.

Por que dar nome a um valor

Compare estas duas linhas:

double area = 3.14159 * r * r;
double area = PI * r * r;

A segunda é melhor por três razões que aparecem depois. Ela diz o que o número significa. Ela aparece em exatamente um lugar, então mudar a precisão é uma edição em vez de uma busca. E um erro de digitação em PI é um erro de compilação, enquanto um erro de digitação em 3.14195 é uma resposta errada.

Números sem nome espalhados pelo código são chamados de números mágicos, e removê-los é uma das melhorias mais baratas que você pode fazer num programa em C.

const

A palavra-chave const marca uma variável como somente leitura:

#include <stdio.h>

int main(void) {
    const double PI = 3.14159265358979;
    const int MAX_USERS = 100;

    double r = 2.0;
    printf("Área de r=%.1f: %.4f\n", r, PI * r * r);
    printf("Capacidade: %d usuários\n", MAX_USERS);

    /* PI = 3.0;  <- descomente esta linha e o programa não vai compilar */
    return 0;
}

Descomente a atribuição e o compilador recusa: assignment of read-only variable 'PI'. Esse erro em tempo de compilação é a razão de existir disso tudo.

Uma variável const é uma variável de verdade. Ela tem um tipo, então o compilador verifica como você a usa. Ela obedece ao escopo, então um const dentro de uma função não vaza para fora. Ela tem um endereço, então você pode pegar um ponteiro para ela. E um depurador consegue mostrar seu nome e seu valor.

Uma const precisa ser inicializada no ponto da declaração - não há uma segunda chance:

const int limit;       /* erro (ou lixo para sempre): nada pode atribuir a ela depois */
const int limit = 50;  /* correto */

#define

A alternativa do pré-processador é uma macro:

#include <stdio.h>

#define PI 3.14159265358979
#define MAX_USERS 100
#define GREETING "Bem-vindo ao sistema"

int main(void) {
    double r = 2.0;
    printf("%s\n", GREETING);
    printf("Área de r=%.1f: %.4f\n", r, PI * r * r);
    printf("Capacidade: %d usuários\n", MAX_USERS);
    return 0;
}

Isto não é uma variável. Antes de o compilador rodar, o pré-processador substitui cada ocorrência de PI no código-fonte pelos caracteres 3.14159265358979. O compilador nunca vê o nome - o que é exatamente o motivo de um #define não ter tipo e não poder aparecer num depurador.

Note que não há ponto e vírgula e não há =. Uma macro é texto puro, então este erro comum:

#define MAX_USERS 100;        /* note o ponto e vírgula */

int limit = MAX_USERS + 1;    /* expande para: int limit = 100; + 1;  -> erro */

produz um erro numa linha que não se parece nada com a definição. A convenção de nomes em maiúsculas para macros existe justamente para que os leitores saibam que há uma substituição acontecendo.

Macros são convencionalmente escritas em MAIUSCULAS_COM_UNDERSCORE; variáveis const normalmente seguem a mesma convenção quando representam a mesma ideia.

Constantes de enum

A terceira forma te dá um conjunto de inteiros nomeados:

#include <stdio.h>

enum { MAX_USERS = 100, BUFFER_SIZE = 256 };

enum Weekday { MON, TUE, WED, THU, FRI };

int main(void) {
    char buffer[BUFFER_SIZE];   /* uma constante genuína de tempo de compilação */

    printf("o buffer guarda %zu bytes\n", sizeof(buffer));
    printf("MAX_USERS = %d\n", MAX_USERS);

    enum Weekday today = WED;
    printf("MON=%d TUE=%d WED=%d, hoje=%d\n", MON, TUE, WED, today);
    return 0;
}

Os valores começam em 0 e aumentam de um em um, a menos que você os atribua, então MON é 0 e FRI é 4. Um enum { ... } anônimo é um idioma comum para constantes inteiras simples.

Constantes de enum têm uma vantagem real sobre as duas alternativas: elas são constantes inteiras de tempo de compilação que o compilador entende, e são visíveis para o depurador. A história completa está em enums em C.

Qual usar

O padrão deveria ser const. Recorra a #define quando o valor precisa existir antes da compilação, e a enum quando você precisa de um inteiro de tempo de compilação ou de um grupo nomeado.

O lugar onde isso realmente pesa são os tamanhos de array:

#include <stdio.h>

#define DEFINED_SIZE 5
enum { ENUM_SIZE = 5 };

int global_a[DEFINED_SIZE];   /* tranquilo */
int global_b[ENUM_SIZE];      /* tranquilo */

int main(void) {
    const int const_size = 5;
    int local[const_size];    /* array de tamanho variável do C99 - funciona aqui... */

    for (int i = 0; i < const_size; i++) local[i] = i * i;
    printf("local[4] = %d\n", local[4]);
    printf("globais: %zu %zu\n", sizeof(global_a), sizeof(global_b));
    return 0;
}

Um const int em C é uma variável somente leitura, não uma expressão constante de tempo de compilação. Dentro de uma função, o C99 aceita int local[const_size] fazendo dele um array de tamanho variável; em escopo de arquivo, dentro de uma struct ou como rótulo de case, ele é rejeitado de cara. enum e #define funcionam em qualquer lugar.

(Essa é uma das diferenças reais em relação ao C++, onde const int é uma expressão constante. Código que transita entre as duas linguagens tropeça nisso.)

const com ponteiros

const e ponteiros se combinam de três maneiras, e os significados não são intercambiáveis. Leia a declaração de dentro para fora, a partir do nome:

const char *p;          /* p aponta para chars que não devem ser modificados */
char * const q;         /* o próprio q não pode ser reapontado; os chars podem mudar */
const char * const r;   /* nem o ponteiro nem os chars podem mudar */

#include <stdio.h>

int main(void) {
    char text[] = "hello";

    const char *p = text;
    /* *p = 'H';  <- erro: os dados são const através de p */
    p = "world";  /* mas reapontar p é permitido */
    printf("p agora aponta para: %s\n", p);

    char * const q = text;
    q[0] = 'H';   /* modificar os dados através de q é permitido */
    /* q = "world";  <- erro: o próprio q é const */
    printf("text agora é: %s\n", text);
    return 0;
}

A forma const char * é a que você vai escrever mais, porque é o tipo correto para um parâmetro de função que lê uma string sem alterá-la:

#include <stdio.h>

/* O const promete a quem chama: esta função não vai modificar sua string. */
size_t count_vowels(const char *s) {
    size_t n = 0;
    for (size_t i = 0; s[i] != '\0'; i++) {
        char c = s[i];
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') n++;
    }
    return n;
}

int main(void) {
    printf("vogais em \"programming\": %zu\n", count_vowels("programming"));
    return 0;
}

Acrescentar const a um parâmetro somente leitura não custa nada e documenta o contrato de um jeito que o compilador faz valer. Vale a pena fazer em todo lugar.

Literais de string são const na prática

Uma armadilha sutil que o const existe para pegar:

char *s = "hello";   /* C legal, mas s aponta para memória somente leitura */
s[0] = 'H';          /* comportamento indefinido - normalmente um travamento */

Literais de string vivem numa seção somente leitura do executável. Escrever através desse ponteiro costuma causar falha de segmentação. Declarar o ponteiro como const char *s = "hello"; faz o compilador rejeitar a atribuição em vez de deixá-la travar em tempo de execução.

Se você precisa de uma string modificável, copie-a para um array:

#include <stdio.h>

int main(void) {
    const char *literal = "hello";   /* somente leitura, não pode ser modificada */
    char copy[] = "hello";           /* um array: uma cópia privada e modificável */

    copy[0] = 'H';
    printf("literal: %s\n", literal);
    printf("cópia:   %s\n", copy);
    return 0;
}