C Nomes de Variáveis

Na aula Variáveis, você criou caixas com etiquetas como idade e preco. Essas etiquetas têm um nome técnico: identificadores (de "identificar"). O mesmo tipo de nome serve para funções, structs e tudo o que você batiza no programa. Nesta aula você vai ver o que o C exige de um nome, quais palavras ele guarda para si (inclusive as novas do C23), por que nota e Nota são coisas diferentes e como escolher nomes que deixam o programa fácil de ler.

Todos os programas desta aula foram compilados com o gcc 15.2 na máquina fictícia da Ana (usuária ana, computador notebook), na pasta ~/c, com o comando padrão do guia: gcc -std=c23 -Wall -Wextra arquivo.c -o programa.

A ideia: regras × combinados

Pense no nome de uma criança no cartório. Existem regras que o cartório confere (não pode ter número, não pode ficar vazio) e existem costumes que ninguém confere, mas todo mundo segue (nome com inicial maiúscula, sobrenome no fim).

No C é igual:

• Regras: o compilador confere. Quebrou, o programa não compila.
• Convenções: combinados entre programadores para o código ficar legível. O compilador não liga, mas as pessoas que vão ler o seu código (inclusive você daqui a um mês) ligam muito.

1. As regras

• Um nome usa letras, algarismos (0 a 9) e o sublinhado _.
• O primeiro caractere é uma letra ou _. Nunca um algarismo.
• Sem espaços, sem hífen, sem pontuação (-, ., !, @…).
• Não pode ser uma palavra-chave da linguagem (seção 2).
• O tamanho é livre: quantidade_de_macas_na_prateleira é válido. (O C99 garante que pelo menos os 63 primeiros caracteres contam, muito mais do que você vai usar.)

Todos estes são válidos:

#include <stdio.h>

int main(void) {
    int idade = 29;
    int item2 = 7;
    int _total = 100;
    int nomeCompleto = 1;
    int nome_completo = 2;
    int NOTA_MAXIMA = 10;
    printf("%d %d %d %d %d %d\n", idade, item2, _total,
           nomeCompleto, nome_completo, NOTA_MAXIMA);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra validos.c -o validos
$ ./validos
29 7 100 1 2 10

Repare que nomeCompleto e nome_completo convivem no mesmo programa: para o C, são nomes diferentes. (Fazer isso de propósito é péssima ideia; aqui é só para provar a regra.) O printf ocupa duas linhas: o C não se importa com a quebra de linha no meio da lista de valores.

Começar com algarismo

#include <stdio.h>

int main(void) {
    int 2lugar = 1;
    printf("%d\n", 2lugar);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra a.c -o a
a.c: In function ‘main’:
a.c:4:9: error: invalid suffix ‘lugar’ on integer constant
    4 |     int 2lugar = 1;
      |         ^~~~~~
a.c:4:9: error: expected identifier or ‘(’ before numeric constant
a.c:5:20: error: invalid suffix ‘lugar’ on integer constant
    5 |     printf("%d\n", 2lugar);
      |                    ^~~~~~

invalid suffix ‘lugar’ on integer constant

"Sufixo inválido lugar numa constante inteira". Ao ver o 2, o compilador entendeu "aqui começa um número". Números podem ter sufixos de uma ou duas letras (como o L de 2L, visto em Inteiros), e lugar não é um deles.

expected identifier or ‘(’ before numeric constant

"Esperava um identificador (um nome) ou ( antes da constante numérica". Depois de int vem um nome, e o compilador achou um número.

Conserto: segundo_lugar ou lugar2.

Hífen e espaço

#include <stdio.h>

int main(void) {
    int minha-variavel = 1;
    printf("%d\n", minha-variavel);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra b.c -o b
b.c: In function ‘main’:
b.c:4:14: error: expected ‘=’, ‘,’, ‘;’, ‘asm’ or ‘__attribute__’ before ‘-’ token
    4 |     int minha-variavel = 1;
      |              ^
b.c:4:15: error: ‘variavel’ undeclared (first use in this function)
    4 |     int minha-variavel = 1;
      |               ^~~~~~~~
b.c:4:15: note: each undeclared identifier is reported only once for each function it appears in
b.c:5:20: error: ‘minha’ undeclared (first use in this function)
    5 |     printf("%d\n", minha-variavel);
      |                    ^~~~~

O hífen é o sinal de menos. O compilador leu minha - variavel: uma conta entre duas variáveis, minha e variavel, que não existem. Por isso os dois erros undeclared. Na linha 4, depois do nome minha ele esperava =, , ou ; (o asm e o __attribute__ são recursos avançados do gcc; ignore-os) e achou o -.

$ gcc -std=c23 -Wall -Wextra c.c -o c       « int minha variavel = 1;
c.c: In function ‘main’:
c.c:4:15: error: expected ‘=’, ‘,’, ‘;’, ‘asm’ or ‘__attribute__’ before ‘variavel’
    4 |     int minha variavel = 1;
      |               ^~~~~~~~
c.c:4:15: error: ‘variavel’ undeclared (first use in this function)
c.c:4:15: note: each undeclared identifier is reported only once for each function it appears in
c.c:5:20: error: ‘minha’ undeclared (first use in this function)
    5 |     printf("%d\n", minha variavel);
      |                    ^~~~~
c.c:5:25: error: expected ‘)’ before ‘variavel’
    5 |     printf("%d\n", minha variavel);
      |           ~             ^~~~~~~~~
      |                         )

O espaço termina o nome. O compilador viu uma variável chamada minha e depois uma palavra solta, variavel, onde esperava = ou ;. Um único espaço gerou cinco mensagens: é comum um errinho virar uma cascata. Conserte o primeiro erro e compile de novo (veja Lendo Erros do Compilador).

Conserto: junte as palavras com sublinhado: minha_variavel.

#include <stdio.h>

int main(void) {
    int 1colocado = 95;
    int nota-final = 87;
    printf("Primeiro: %d\n", 1colocado);
    printf("Nota final: %d\n", nota-final);
    return 0;
}

#include <stdio.h>

int main(void) {
    int primeiro_colocado = 95;
    int nota_final = 87;
    printf("Primeiro: %d\n", primeiro_colocado);
    printf("Nota final: %d\n", nota_final);
    return 0;
}

2. Palavras-chave

Algumas palavras já têm significado para o C: int, if, return… Elas se chamam palavras-chave (keywords) ou palavras reservadas, e nenhuma delas pode ser nome de variável:

int main(void) {
    int return = 1;
}

$ gcc -std=c23 -Wall -Wextra h.c -o h
h.c: In function ‘main’:
h.c:2:9: error: expected identifier or ‘(’ before ‘return’
    2 |     int return = 1;
      |         ^~~~~~

Expected identifier = "esperava um identificador (um nome)". O compilador achou uma palavra-chave onde deveria vir um nome. No editor, o Clang diz só expected identifier or '(', apontando a mesma palavra.

As 54 palavras-chave do C23

O C é uma linguagem pequena: o C23 tem 54 palavras-chave (o C++ tem 92). No laboratório, cada uma foi testada como nome de variável (int PALAVRA = 1;), e o gcc 15 com -std=c23 recusou todas. Você não precisa decorá-las: a maioria você vai aprender aula a aula, e os editores costumam pintá-las de outra cor.

Por que algumas começam com _ e maiúscula, como _Generic? Quando o C ganha uma palavra nova, ela pode quebrar programas antigos que já usavam aquele nome. Por isso, por muito tempo, as palavras novas eram escritas num formato que ninguém deveria estar usando (seção 4): o C99 trouxe _Bool, o C11 trouxe _Static_assert, _Alignas, _Alignof e _Thread_local. O C23 finalmente deu a elas a forma bonita (bool, static_assert, alignas…), e as antigas continuam valendo como sinônimos.

As onze novas do C23 C23

Estas onze palavras não eram palavras-chave até o C17:

bool, true, false, nullptr, constexpr, typeof, typeof_unqual, static_assert, alignas, alignof, thread_local.

Isso quer dizer que um programa antigo que usava uma delas como nome compilava antes e não compila mais. Veja este código "da época do C17":

#include <stdio.h>

int main(void) {
    int bool = 1;
    int true = 0;
    printf("%d %d\n", bool, true);
    return 0;
}

$ gcc -std=c17 -Wall -Wextra velho.c -o velho
$ ./velho
1 0                      « no C17, bool e true eram nomes comuns
$ gcc -std=c23 -Wall -Wextra velho.c -o velho
velho.c: In function ‘main’:
velho.c:4:9: error: ‘bool’ cannot be used here
    4 |     int bool = 1;
      |         ^~~~
velho.c:4:9: note: ‘bool’ is a keyword with ‘-std=c23’ onwards
velho.c:4:14: error: expected identifier or ‘(’ before ‘=’ token
    4 |     int bool = 1;
      |              ^
velho.c:5:9: error: expected identifier or ‘(’ before ‘true’
    5 |     int true = 0;
      |         ^~~~
velho.c:6:23: error: expected expression before ‘bool’
    6 |     printf("%d %d\n", bool, true);
      |                       ^~~~

‘bool’ cannot be used here

"bool não pode ser usado aqui".

note: ‘bool’ is a keyword with ‘-std=c23’ onwards

"bool é palavra-chave do -std=c23 em diante". O gcc reconhece o caso e explica a causa. Lembre que o gcc 15 já usa o C23 mesmo sem o -std (veja Versões do C).

expected expression before ‘bool’

Na linha 6, onde deveria vir um valor, ele achou o nome de um tipo.

O Clang do editor diz de outro jeito: cannot combine with previous 'int' declaration specifier ("não dá para combinar com o int anterior"), porque para ele int bool são dois tipos seguidos.

#include <stdio.h>

int main(void) {
    int bool = 1;
    int false = 0;
    printf("Loja aberta: %d\n", bool);
    printf("Clientes: %d\n", false);
    return 0;
}

#include <stdio.h>

int main(void) {
    int aberta = 1;
    int clientes = 0;
    printf("Loja aberta: %d\n", aberta);
    printf("Clientes: %d\n", clientes);
    return 0;
}

main, printf e scanf não são palavras-chave

printf é o nome de uma função da biblioteca padrão; main é só o nome que o sistema procura para começar. Nenhum dos dois é palavra-chave. Por isso o C deixa você criar uma variável chamada printf, e ela esconde a função:

#include <stdio.h>

int main(void) {
    int printf = 5;
    printf("%d\n", printf);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra sombra.c -o sombra
sombra.c: In function ‘main’:
sombra.c:5:5: error: called object ‘printf’ is not a function or function pointer
    5 |     printf("%d\n", printf);
      |     ^~~~~~
sombra.c:4:9: note: declared here
    4 |     int printf = 5;
      |         ^~~~~~

A declaração da linha 4 foi aceita. O problema veio na linha 5: dentro do main, printf agora é um int, e o compilador reclama que "o objeto chamado printf não é uma função". Moral: não use nomes de funções da biblioteca (printf, scanf, abs, time, index…) como nomes de variáveis.

3. Maiúsculas e minúsculas fazem diferença

Para o C, nota, Nota e NOTA são três nomes diferentes. Isso se diz assim: o C é case-sensitive ("sensível à caixa", isto é, a letras maiúsculas e minúsculas). Uma letra trocada já basta para o compilador não achar a variável:

#include <stdio.h>

int main(void) {
    int nota = 8;
    printf("%d\n", Nota);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra caixa.c -o caixa
caixa.c: In function ‘main’:
caixa.c:5:20: error: ‘Nota’ undeclared (first use in this function); did you mean ‘nota’?
    5 |     printf("%d\n", Nota);
      |                    ^~~~
      |                    nota
caixa.c:5:20: note: each undeclared identifier is reported only once for each function it appears in
caixa.c:4:9: warning: unused variable ‘nota’ [-Wunused-variable]
    4 |     int nota = 8;
      |         ^~~~

‘Nota’ undeclared

"Nota não declarada": com N maiúsculo, ela não existe.

did you mean ‘nota’?

"Você quis dizer nota?" O gcc procura um nome parecido e sugere. A linha de baixo, com nota embaixo do ^~~~, mostra como ficaria a correção.

warning: unused variable ‘nota’

Consequência do mesmo engano: como o programa nunca usou nota (com n minúsculo), o compilador avisa que ela foi criada à toa.

As palavras-chave também são sensíveis: Int ou RETURN não são palavras do C. Tudo o que é da linguagem e da biblioteca padrão é escrito em minúsculas (com exceção das palavras do tipo _Generic e de algumas macros, como EOF e INT_MAX).

4. Nomes reservados: válidos, mas proibidos para você

Alguns nomes passam pelas regras da seção 1, compilam sem reclamação, e mesmo assim a norma do C diz que eles pertencem ao compilador e à biblioteca padrão. Usar esses nomes é pedir para um dia colidir com algo interno:

O gcc compila esses nomes sem reclamar. O Clang tem um aviso específico, que não vem no -Wall, o -Wreserved-identifier. No laboratório:

$ cat res.c
int main(void) {
    int _Total = 1;
    int __x = 2;
    return _Total + __x;
}
$ gcc -std=c23 -Wall -Wextra res.c -o res          « nenhum aviso
$ clang -std=c23 -Wall -Wextra -Wreserved-identifier res.c -o res
res.c:2:9: warning: identifier '_Total' is reserved because it starts with '_' followed by a capital letter [-Wreserved-identifier]
    2 |     int _Total = 1;
      |         ^
res.c:3:9: warning: identifier '__x' is reserved because it starts with '__' [-Wreserved-identifier]
    3 |     int __x = 2;
      |         ^
2 warnings generated.

"O identificador _Total é reservado porque começa com _ seguido de letra maiúscula" e "__x é reservado porque começa com __". Nada impede o programa de funcionar hoje; o problema é o dia em que uma versão nova do compilador criar algo com esse nome.

E um nome global que já existe na biblioteca vira erro na hora, se o cabeçalho dele estiver incluído. O abs ("absoluto") é uma função do stdlib.h:

$ cat abs.c
#include <stdio.h>
#include <stdlib.h>

int abs = 10;

int main(void) {
    printf("%d\n", abs);
    return 0;
}
$ gcc -std=c23 -Wall -Wextra abs.c -o abs
abs.c:4:5: error: ‘abs’ redeclared as different kind of symbol
    4 | int abs = 10;
      |     ^~~
In file included from abs.c:2:
/usr/include/stdlib.h:1008:12: note: previous declaration of ‘abs’ with type ‘int(int)’
 1008 | extern int abs (int __x) __THROW __attribute__ ((__const__)) __wur;
      |            ^~~

"abs declarado de novo como outro tipo de símbolo". A note mostra a declaração original, lá dentro do arquivo /usr/include/stdlib.h do sistema: uma função que recebe e devolve int. Repare no __x e no __THROW: a biblioteca usa justamente os nomes reservados, para nunca colidir com os seus.

5. Convenções: como escrever nomes de várias palavras

Como não pode haver espaço, os programadores juntam as palavras de um destes jeitos:

Nenhum é "o certo" para o compilador. O importante é escolher um por projeto e seguir sempre. Se você entra num projeto que já existe, use o estilo que ele já usa.

6. Nomes bons e nomes ruins

Um nome bom responde à pergunta "o que tem nesta caixa?" sem que o leitor precise caçar o resto do código. Compare duas versões do mesmo programa:

int a = 3;
int b = 8;
int c = a * b;

int quantidade = 3;
int preco_unitario = 8;
int total = quantidade * preco_unitario;

As duas fazem exatamente a mesma conta e geram o mesmo programa. Mas só a segunda dá para entender sem explicação.

7. Acentos nos nomes: o gcc 15 aceita int ação?

Aceita. O C99 já permitia letras de outros alfabetos em nomes (escritas com códigos como ç), e o C23 definiu exatamente quais valem: as letras do padrão Unicode, um catálogo de todos os caracteres do mundo (a aula Acentos e UTF-8 explica). O gcc 15 aceita até no modo exigente:

#include <stdio.h>

int main(void) {
    int ação = 3;
    double preço = 4.5;
    double π = 3.14159;
    printf("%d %.1f %.5f\n", ação, preço, π);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra acento.c -o acento
$ ./acento
3 4.5 3.14159
$ gcc -std=c23 -Wall -Wextra -Wpedantic acento.c -o acento    « nem o modo exigente reclama

O Clang do editor também aceita. E um emoji (int 😀 = 1;)? A norma diz que não, porque emoji não é letra. O Clang recusa (unexpected character <U+1F600>); o gcc deixa passar como extensão própria e só recusa com -Wpedantic.

Por que, mesmo assim, evitar acentos

Uma letra acentuada pode ser guardada no arquivo de dois jeitos: o ç "pronto" (um caractere só) ou um c seguido de um "cedilha solto" que se encaixa nele. Na tela, os dois são idênticos. Para o compilador, são nomes diferentes. Veja o que acontece quando a declaração foi digitada de um jeito e o uso, de outro (isso acontece ao copiar e colar de páginas web, PDFs ou do macOS):

$ gcc -std=c23 -Wall -Wextra normal.c -o normal
normal.c: In function ‘main’:
normal.c:4:12: warning: ‘prec\U00000327o’ is not in NFC [-Wnormalized=]
    4 |     double prec<U+0327>o = 4.5;
      |            ^~~~~~~~~~~~~
normal.c:5:22: error: ‘preço’ undeclared (first use in this function); did you mean ‘preço’?
    5 |     printf("%.1f\n", preço);
      |                      ^~~~~
      |                      preço
normal.c:5:22: note: each undeclared identifier is reported only once for each function it appears in
normal.c:4:12: warning: unused variable ‘preço’ [-Wunused-variable]
    4 |     double preço = 4.5;
      |            ^~~~~

• is not in NFC: o gcc avisa que o nome não está na forma "pronta" (NFC, a forma normal composta). Repare como ele mostra o cedilha solto: prec<U+0327>o.
• ‘preço’ undeclared; did you mean ‘preço’?: "preço não foi declarada; você quis dizer preço?". Os dois nomes parecem iguais, e mesmo assim são diferentes. É um erro dificílimo de achar a olho nu.

Somando isso a outros motivos práticos (nem todo teclado digita ç com facilidade, programadores de outros países vão ler o código, algumas ferramentas antigas não lidam bem com acentos), a recomendação do guia é: nomes sem acento. Escreva preco, acao, endereco. Acentos ficam dentro dos textos entre aspas, como "Preço: ", onde são bem-vindos.

Quando dá errado

Referência rápida

Exercícios

Missão final: nomes que se explicam

#include <stdio.h>

int main(void) {
    int a = 6;
    int b = 4;
    int c = a * b;
    printf("Total: %d\n", c);
    return 0;
}

#include <stdio.h>

int main(void) {
    int quantidade_macas = 6;
    int preco_unitario = 4;
    int total_compra = quantidade_macas * preco_unitario;
    printf("Total: %d\n", total_compra);
    return 0;
}

Se você esqueceu de trocar o nome em alguma linha, o compilador avisou com um undeclared: é a seção 3 em ação, e é por isso que renomear com calma (ou com o "renomear" do seu editor, aula Editores e IDEs) vale a pena.

Resumo

• Nome = letras, algarismos e _, começando com letra ou _. Sem espaço, hífen ou pontuação.
• As 54 palavras-chave do C23 não podem ser nomes. Onze delas são novas no C23 (bool, true, false, nullptr, constexpr, typeof…), e código antigo que as usava como nome não compila mais.
• printf e main não são palavras-chave, mas não reaproveite nomes da biblioteca.
• O C diferencia maiúsculas de minúsculas: nota ≠ Nota. O gcc costuma sugerir did you mean.
• _ + maiúscula e __ são reservados em qualquer lugar; _ no começo é reservado em nomes globais. Regra prática: não comece com _.
• Em C, o costume é snake_case para variáveis e funções e MAIUSCULAS para macros e constantes. Escolha nomes que digam o que a caixa guarda.
• O gcc 15 aceita acentos em nomes, mas o guia recomenda evitar.