C Versões

O C de hoje não é igual ao de 1972. A linguagem ganhou versões novas ao longo dos anos, cada uma com um nome curto como C99 ou C23 (o número é o ano). Quando você procura ajuda na internet, encontra código de todas as épocas, e um programa escrito para uma versão às vezes não compila em outra. Nesta aula você vai conhecer cada versão, saber qual o seu compilador está usando e aprender a escolher a versão com a opção -std=.

A ideia: as regras do futebol

O futebol tem um livro de regras oficial, e de tempos em tempos ele muda: um ano surge o cartão amarelo, outro ano o goleiro deixa de poder pegar com a mão a bola recuada pelo companheiro, depois chega o árbitro de vídeo. Um jogo de 1970 e um de hoje são "futebol", mas algumas jogadas de hoje seriam estranhas em 1970, e algumas de 1970 hoje dariam falta.

O C é igual. Existe um livro de regras oficial, o padrão, que diz exatamente o que é um programa C válido e o que ele deve fazer. De tempos em tempos sai uma edição nova. Os compiladores (gcc, Clang, o da Microsoft) são como os árbitros: cada um aplica as regras, e você pode dizer a ele qual edição do livro usar.

O padrão ISO

Nos primeiros anos, o C não tinha regras oficiais: a referência era o livro de Kernighan e Ritchie, e cada fabricante de compilador fazia pequenas mudanças. Um programa que funcionava num computador podia não compilar em outro. Para acabar com a confusão, o instituto americano de normas (ANSI) reuniu um comitê e publicou, em 1989, o primeiro padrão do C. No ano seguinte, a ISO (a Organização Internacional de Normalização, a mesma das normas ISO de empresas) adotou o mesmo texto.

Desde então, o C é mantido por um comitê internacional, o WG14, com gente de empresas, universidades e projetos de compiladores. O documento oficial se chama ISO/IEC 9899; cada edição tem o ano no fim (por exemplo, ISO/IEC 9899:2024 é o C23). O comitê é bem conservador: o C muda devagar, e quase todo programa antigo continua compilando nas versões novas. Isso é proposital: existe muito código em C funcionando há décadas em aviões, bancos e sistemas operacionais.

O que cada versão trouxe

O nome curto de cada versão é o ano em que ela ficou pronta (às vezes um ano antes de ser publicada oficialmente). Você não precisa decorar a tabela: ela serve para consultar quando uma aula mostrar o selo de versão, ou quando você encontrar código antigo.

O C23 numa caixa

Este programa usa sete novidades do C23 de uma vez. Não se preocupe em entender cada uma: todas têm a sua aula (Booleanos, Ponteiro Nulo, Constantes, static_assert, Novidades do C99 ao C23). O que importa aqui é ver que o compilador do guia entende todas:

#include <stdio.h>

int main(void) {
    constexpr int ANO = 2024;
    bool aprovada = true;
    int *nada = nullptr;
    auto populacao = 1'000'000;
    typeof(populacao) dobro = populacao * 2;
    int mascara = 0b1010;
    static_assert(sizeof(int) >= 4);

    printf("C23 publicado em %d\n", ANO);
    printf("aprovada = %d\n", aprovada);
    printf("nada é nulo? %d\n", nada == nullptr);
    printf("dobro = %d\n", dobro);
    printf("mascara = %d\n", mascara);
    return 0;
}

No terminal da Ana, com o gcc 15 e o C23, a saída é a mesma:

$ gcc -std=c23 -Wall -Wextra c23.c -o c23 && ./c23
C23 publicado em 2024
aprovada = 1                                « true aparece como 1
nada é nulo? 1
dobro = 2000000
mascara = 10                                « 0b1010 em binário é 10

E com uma versão mais antiga? A opção -std=c17 pede ao gcc as regras do C17. O mesmo arquivo dá uma enxurrada de erros (aqui, só o começo):

$ gcc -std=c17 -Wall -Wextra c23.c -o c23
c23.c: In function ‘main’:
c23.c:4:5: error: ‘constexpr’ undeclared (first use in this function)   « o C17 não conhece constexpr
    4 |     constexpr int ANO = 2024;
      |     ^~~~~~~~~
c23.c:4:5: note: each undeclared identifier is reported only once for each function it appears in
c23.c:4:14: error: expected ‘;’ before ‘int’
    4 |     constexpr int ANO = 2024;
      |              ^~~~
      |              ;
c23.c:5:5: error: unknown type name ‘bool’                                « nem bool sem include
    5 |     bool aprovada = true;
      |     ^~~~
c23.c:2:1: note: ‘bool’ is defined in header ‘<stdbool.h>’; this is probably fixable by adding ‘#include <stdbool.h>’
    1 | #include <stdio.h>
  +++ |+#include <stdbool.h>
    2 |
c23.c:5:21: error: ‘true’ undeclared (first use in this function)
    5 |     bool aprovada = true;
      |                     ^~~~
c23.c:5:21: note: ‘true’ is defined in header ‘<stdbool.h>’; this is probably fixable by adding ‘#include <stdbool.h>’
c23.c:6:17: error: ‘nullptr’ undeclared (first use in this function)     « nem nullptr
    6 |     int *nada = nullptr;
      |                 ^~~~~~~

Para o C17, palavras como constexpr e nullptr são nomes desconhecidos, como se a Ana tivesse inventado uma palavra. Repare que o gcc é gentil com o bool: ele diz que bool é definido no arquivo <stdbool.h> e até mostra onde acrescentar o #include (a linha com +++). No C99, C11 e C17, era assim que se usava bool.

Padrão × compilador

Uma confusão muito comum: a versão do C e a versão do compilador são coisas diferentes. O C23 é o livro de regras; o gcc 15 é um programa que segue esse livro (e os anteriores). Cada compilador tem a sua própria numeração, e cada versão nova de compilador aprende mais recursos das versões novas do C.

Ver a versão do compilador

$ gcc --version
gcc (Ubuntu 15.2.0-16ubuntu1) 15.2.0                « o compilador está na versão 15.2
Copyright (C) 2025 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

$ clang --version
Ubuntu clang version 21.1.8 (6ubuntu1)              « o Clang está na versão 21.1
Target: x86_64-pc-linux-gnu
Thread model: posix
InstalledDir: /usr/lib/llvm-21/bin

Nenhum dos dois diz "C23": o número 15.2 é do gcc, não do C. Para saber qual versão do C está valendo, é preciso perguntar ao próprio código.

Ver a versão do C: __STDC_VERSION__

Todo compilador de C define uma palavra especial chamada __STDC_VERSION__ (com dois sublinhados antes e dois depois; STDC = standard C, "C padrão"). Ela vale um número no formato ano e mês da versão do C que está sendo usada:

#include <stdio.h>

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

__STDC_VERSION__

Uma macro pré-definida: o pré-processador troca essa palavra por um número antes de compilar (como o NOME da aula Como o C Vira Programa). O número é do tipo long: no C23, é 202311L (o L no fim marca um long).

%ld

O "buraco" do printf para um long (long decimal). A aula Formatos do printf mostra todos.

A Ana compilou o mesmo arquivo pedindo cada versão:

$ gcc versao.c -o versao && ./versao
__STDC_VERSION__ = 202311                           « sem -std: o gcc 15 já usa o C23
$ gcc -std=c23 versao.c -o versao && ./versao
__STDC_VERSION__ = 202311                           « C23: novembro de 2023
$ gcc -std=c17 versao.c -o versao && ./versao
__STDC_VERSION__ = 201710                           « C17: outubro de 2017
$ gcc -std=c11 versao.c -o versao && ./versao
__STDC_VERSION__ = 201112                           « C11: dezembro de 2011
$ gcc -std=c99 versao.c -o versao && ./versao
__STDC_VERSION__ = 199901                           « C99: janeiro de 1999
$ gcc -std=c2y versao.c -o versao && ./versao
__STDC_VERSION__ = 202500                           « C2y: número provisório
$ gcc -std=c89 versao.c -o versao && ./versao
versao.c: In function ‘main’:
versao.c:4:40: error: ‘__STDC_VERSION__’ undeclared (first use in this function)
    4 |     printf("__STDC_VERSION__ = %ld\n", __STDC_VERSION__);
      |                                        ^~~~~~~~~~~~~~~~
versao.c:4:40: note: each undeclared identifier is reported only once for each function it appears in

Repare no último: no C89, o __STDC_VERSION__ nem existia (ele surgiu no complemento de 1995), então o compilador diz que é um nome não declarado. Os números servem para o código descobrir em que versão está, com #if __STDC_VERSION__ >= 202311L (aula Compilação Condicional).

$ gcc -dM -E -x c /dev/null | grep STDC_VERSION
#define __STDC_VERSION__ 202311L
$ clang -dM -E -x c /dev/null | grep STDC_VERSION
#define __STDC_VERSION__ 201710L                    « o Clang 21 ainda usa o C17 se você não pedir

A versão de cada compilador, quando você não pede nenhuma

Se você não usar -std=, cada compilador escolhe uma versão por conta própria, e essa escolha muda com o tempo:

É por isso que o guia sempre escreve o -std=c23 no comando: assim o programa se comporta igual no gcc 15, no gcc 14 (que já aceita a opção) e no Clang, em vez de depender do que cada um escolhe sozinho.

#include <stdio.h>

int main(void) {
    printf("Este código foi compilado com ???\n");
    return 0;
}

#include <stdio.h>

int main(void) {
    printf("Este código foi compilado com %ld\n", __STDC_VERSION__);
    return 0;
}

Escolher a versão: as opções -std=

A opção -std= (de standard, padrão) diz ao compilador qual livro de regras usar. Existem dois "sabores" de cada versão:

Na prática, c23 e gnu23 quase nunca fazem diferença em programas de iniciante. A diferença aparece quando o código usa uma extensão: um recurso que o gcc oferece, mas que não está (ou não estava) no padrão. Por exemplo, os números binários 0b1010 só entraram no padrão no C23, mas o gcc os aceita há muitos anos como extensão. Para o gcc avisar quando o código sai do padrão escolhido, existe a opção -pedantic ("detalhista"):

$ gcc -std=c17 -Wall -Wextra binario.c -o binario && ./binario
mascara = 10                                        « o gcc aceitou, calado
$ gcc -std=c17 -Wall -Wextra -pedantic binario.c -o binario
binario.c: In function ‘main’:
binario.c:4:19: warning: binary constants are a C23 feature or GCC extension [-Wpedantic]
    4 |     int mascara = 0b1010;
      |                   ^~~~~~
$ gcc -std=c23 -Wall -Wextra -pedantic binario.c -o binario && ./binario
mascara = 10                                        « no C23 é padrão: nenhum aviso

O aviso diz: "constantes binárias são um recurso do C23 ou uma extensão do GCC". Ou seja, o código funciona no gcc, mas outro compilador seguindo o C17 poderia recusá-lo. O -pedantic é útil quando o programa precisa compilar em muitos compiladores diferentes. Neste guia, o comando padrão é gcc -std=c23 -Wall -Wextra (a aula Compilar com gcc explica cada parte).

Qual versão usar?

O selo de versão do guia

Quando uma aula mostra um recurso que não existe em todas as versões, ela coloca um selo ao lado, assim: C99, C11, C23. O selo diz a primeira versão que tem o recurso. Por exemplo, bool sem #include C23 quer dizer: "funciona no C23 e nas seguintes; nas anteriores, use #include <stdbool.h>". A aula sempre diz a alternativa antiga, porque muito código e muitos cursos ainda usam C99 ou C11.

A caixa abaixo foi configurada para compilar com -std=c17, como um compilador um pouco mais antigo. Veja o que acontece com o bool:

#include <stdio.h>

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

#include <stdio.h>
#include <stdbool.h>

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

No editor, o Clang diz use of undeclared identifier 'bool' ("uso de identificador não declarado"); o gcc diz unknown type name ‘bool’ ("nome de tipo desconhecido") e sugere o stdbool.h. No C23, as duas versões do programa funcionam: o #include <stdbool.h> continua permitido, só não é mais necessário.

Quando dá errado

$ gcc -std=c89 -Wall -Wextra antigo.c -o antigo
antigo.c: In function ‘main’:
antigo.c:4:5: error: C++ style comments are not allowed in ISO C90
    4 |     // conta de 1 a 3
      |     ^
antigo.c:4:5: note: (this will be reported only once per input file)
antigo.c:5:5: error: ‘for’ loop initial declarations are only allowed in C99 or C11 mode
    5 |     for (int i = 1; i <= 3; i++) {
      |     ^~~
antigo.c:5:5: note: use option ‘-std=c99’, ‘-std=gnu99’, ‘-std=c11’ or ‘-std=gnu11’ to compile your code

#include <stdio.h>

main()
{
    printf("hello, world\n");
}

$ gcc hello.c -o hello
hello.c:3:1: error: return type defaults to ‘int’ [-Wimplicit-int]
    3 | main()
      | ^~~~
$ gcc -std=c89 hello.c -o hello && ./hello          « com as regras de 1989, passa
hello, world

Referência

Exercícios

Resumo

• O C tem um padrão oficial (ISO/IEC 9899), mantido por um comitê internacional. Cada edição tem um nome com o ano: C89/C90, C99, C11, C17, C23. Antes disso, havia o K&R C do livro de 1978; depois vem o C2y.
• C99 trouxe //, variáveis no for, stdbool.h e stdint.h; C11 trouxe _Generic, _Static_assert e threads; C17 só corrigiu; C23 trouxe bool sem include, nullptr, constexpr, typeof, auto, atributos, 0b1010 e 1'000.
• A versão do compilador (gcc 15.2) não é a versão do C. A versão do C aparece em __STDC_VERSION__: 202311L é o C23.
• Sem -std=, o gcc 15 usa gnu23; o Clang 21 usa gnu17. Por isso o guia sempre escreve -std=c23.
• gnu23 = C23 com extensões do GNU; -pedantic avisa quando o código sai do padrão.
• Código antigo (sem tipo no main, funções no estilo K&R) pode não compilar nos compiladores modernos; código novo (//, bool, nullptr) não compila com -std= antigo.
• Próximo passo: instalar o compilador no seu computador, em Instalar no Linux ou Instalar no Windows e macOS.