C Glossário

Os termos que aparecem no guia, em ordem alfabética, explicados em uma ou duas frases, cada um com o link para a aula em que é explicado com calma. Termos em inglês aparecem com a tradução. Quando o nome em inglês é o mais usado no dia a dia (como buffer ou malloc), ele é a entrada principal.

Dica

Use Ctrl+F no navegador para achar um termo, ou o índice de letras abaixo. Para consultas rápidas, veja também as referências de printf e scanf, de string.h, de tipos e limites, de operadores e de erros comuns.

A · B · C · D · E · F · G · H · I · L · M · N · O · P · R · S · T · U · V · W

A

abort: Função do stdlib.h que encerra o programa na hora, sem arrumar nada. No terminal aparece Abortado (imagem do núcleo gravada) e o código de saída é 134. É o que o assert chama quando falha. Veja: Testes (assert) e Encerrar o Programa.
Alocação dinâmica: Pedir memória enquanto o programa roda, no heap, com malloc, calloc ou realloc, em vez de declarar uma variável comum. Toda memória pedida assim tem de ser devolvida com free. Veja: malloc e free.
argc e argv: Os parâmetros da forma int main(int argc, char *argv[]): quantos argumentos vieram na linha de comando (argument count) e a lista deles, como textos (argument vector). argv[0] é o nome do programa. Veja: Argumentos da Linha de Comando.
Argumento: O valor que você entrega a uma função quando a chama: em soma(2, 3), os argumentos são 2 e 3. Do lado de dentro, eles chegam nos parâmetros. Veja: Parâmetros.
Array (vetor): Uma fileira de variáveis do mesmo tipo, lado a lado na memória, com tamanho fixo: int notas[3];. O primeiro elemento é o de índice 0. O C não confere se o índice passou do fim. Veja: Arrays e Arrays Multidimensionais.
ASCII: A tabela que dá um número a cada letra, algarismo e símbolo: 'A' é 65, 'a' é 97, '0' é 48. Tem 128 posições e nenhuma letra acentuada. Veja: Caracteres (char).
assert: Macro do assert.h que confere uma certeza do programador enquanto o programa roda: assert(qtd > 0);. Se for falsa, mostra a condição, o arquivo e a linha e aborta. É desligada com -DNDEBUG. Veja: Testes (assert).
Atributo C23: Uma etiqueta entre colchetes duplos que dá uma informação a mais ao compilador: [[nodiscard]] (não ignore o retorno), [[maybe_unused]], [[deprecated]], [[fallthrough]]. Veja: Atributos.
Atribuição: Guardar um valor numa variável que já existe, com =: idade = 31;. Não confunda com a comparação ==. Os atalhos +=, -=, *= fazem a conta e guardam. Veja: Variáveis e Operadores de Atribuição.
Aviso (warning): Mensagem do compilador sobre algo suspeito que não impede o programa de ser criado, como uma variável não usada ou um formato errado no printf. Quase sempre aponta um defeito real; ligue os avisos com -Wall -Wextra. Veja: Compilar com gcc e Avisos.

B

Biblioteca padrão: As funções que vêm com todo compilador C e fazem parte do padrão ISO, divididas em cabeçalhos: stdio.h (entrada e saída), string.h, stdlib.h, math.h… No Linux, quem as implementa é a glibc; no editor do guia, a wasi-libc. Veja: O Editor do Guia e Bibliotecas.
Bit e byte: O bit é a menor informação do computador: 0 ou 1. Um byte são 8 bits e guarda um número de 0 a 255; é a "gaveta" de memória que tem endereço. Um char ocupa 1 byte; um int, 4. Veja: Memória e Endereços e Operadores de Bits.
Bloco: Um trecho de código entre chaves { }. As variáveis criadas dentro de um bloco só existem até a } que o fecha. Veja: Sintaxe e Escopo.
bool: O tipo que só guarda true (verdadeiro, 1) ou false (falso, 0). No C23 é palavra-chave; no C99 a C17, precisa de #include <stdbool.h>. Veja: Booleanos.
break: Sai na hora do laço (for, while, do while) ou do switch em que está. Num laço dentro de outro, só sai do de dentro. Veja: break e continue.
Buffer: Uma área de memória usada para guardar dados de passagem, como o array onde o fgets põe a linha lida. A saída do printf também passa por um buffer antes de chegar à tela. Veja: fgets.
Buffer overflow (estouro de buffer): Escrever além do fim de um array, invadindo a memória vizinha: scanf("%s", nome) sem limite, strcpy sem espaço. É comportamento indefinido e uma das falhas de segurança mais antigas. Veja: Segurança.

C

C23 (e C89, C99, C11, C17): As versões do padrão da linguagem, com o ano em que saíram. O guia ensina o C23 (-std=c23), que trouxe bool como palavra-chave, nullptr, constexpr, typeof, atributos e #embed. Veja: Versões do C e Novidades do C99 ao C23.
Cabeçalho (header, arquivo .h): Arquivo com declarações (protótipos, structs, constantes) que outros arquivos incluem com #include. Os da biblioteca padrão vão entre < > (<stdio.h>); os seus, entre aspas ("datas.h"). Veja: Arquivos .h e .c.
Callback: Uma função passada para outra função, por um ponteiro para função, para ser chamada lá dentro. O exemplo clássico é a função de comparação do qsort. Veja: Ponteiros para Funções.
calloc e realloc: calloc reserva memória para N itens e a enche de zeros; realloc muda o tamanho de um bloco já reservado (e pode mudá-lo de lugar). Veja: calloc e realloc e Array que Cresce.
Campo de bits: Um campo de struct com largura em bits, escrita depois de dois-pontos: unsigned int ligado : 1;. Guarda vários valores pequenos num só inteiro. Veja: Campos de Bits.
Caractere nulo ('\0'): O caractere de código 0, que marca o fim de uma string. "Ana" ocupa 4 bytes: 'A', 'n', 'a' e '\0'. Sem ele, as funções de texto continuam lendo a memória vizinha. Veja: Strings.
Cast (conversão explícita): Pedir uma conversão de tipo escrevendo o tipo entre parênteses: (double) soma / n. Veja: Conversão de Tipos.
char: O tipo de um caractere, escrito entre aspas simples: 'A'. Ocupa 1 byte e, por dentro, é um número pequeno (o código da tabela ASCII). 'ç' não cabe: em UTF-8 são 2 bytes. Veja: Caracteres (char).
Clang: Um compilador de C (do projeto LLVM), alternativa ao gcc, com as mesmas opções principais. É o compilador do editor do guia e o "gcc" do macOS. As mensagens de erro dizem a mesma coisa com outras palavras. Veja: O Editor do Guia e Compilar com gcc.
CMake: Ferramenta que descreve como montar um projeto (arquivo CMakeLists.txt) e gera os arquivos para o make ou o Ninja: cmake -B build e cmake --build build. Veja: CMake.
Código de saída (exit code): O número que o programa devolve ao terminar, visto com echo $?: 0 = sucesso. É o valor do return do main ou do exit. Quando o sistema mata o programa, é 128 + o número do sinal: 139 = falha de segmentação, 134 = abortado. Veja: Olá, Mundo e Encerrar o Programa.
Código-fonte: O texto que você escreve (ola.c), que pessoas leem e o compilador traduz para um executável. Veja: Como o C Vira Programa.
Comentário: Texto que o compilador ignora, escrito para pessoas: // até o fim da linha ou /* em bloco */. Veja: Comentários.
Compilação condicional: Trechos de código que só existem se um nome estiver definido, escolhidos pelo pré-processador antes da compilação: #ifdef, #if, #else, #endif e a opção -D do gcc. Veja: Compilação Condicional.
Compilador: O programa que traduz o código-fonte em código de máquina: no guia, o gcc (nos terminais) e o Clang (no editor). Veja: Como o C Vira Programa e Compilar com gcc.
Comportamento indefinido (undefined behavior, UB): O que acontece quando o programa quebra uma regra do C que o compilador não é obrigado a conferir: índice fora do array, variável sem valor inicial, estouro de int, ponteiro solto. O padrão não diz o que acontece: pode "funcionar", dar lixo ou travar, e mudar com -O2. Veja: Comportamento Indefinido.
const: Marca uma variável que não pode ser mudada depois de criada: const double PI = 3.14159;. Num parâmetro ponteiro (const char *s), promete que a função não muda o que é apontado. Veja: Constantes e const e Ponteiros.
constexpr C23: Uma constante de verdade, com valor conhecido na compilação, que pode ser usada até no tamanho de um array: constexpr int MAX = 10;. Veja: Constantes.
continue: Pula o resto da volta atual do laço e passa para a próxima. Veja: break e continue.
Conversão implícita: A conversão que o C faz sozinho, sem você pedir: guardar 3.9 num int vira 3; somar int com double dá double. O -Wconversion avisa quando ela perde informação. Veja: Conversão de Tipos.
Curto-circuito: O && e o || param de calcular assim que sabem a resposta: em p != NULL && *p > 0, se p for nulo, o *p nem é lido. Veja: Operadores Lógicos.

D

Declaração × definição: Declarar é anunciar que um nome existe e qual é o seu tipo (int dobro(int x);); definir é criar de verdade (a função com o corpo, a variável com a memória). Um nome pode ser declarado várias vezes, mas definido uma só. Veja: Arquivos .h e .c e Protótipos.
Depurador (debugger): Programa que roda o seu passo a passo, para você ver as variáveis e achar a linha de um erro. No guia, o gdb; compile com -g. Veja: Depurar com gdb.
Desreferenciar: Ir até o endereço guardado num ponteiro, com *: se p aponta para x, *p é o próprio x. Desreferenciar um ponteiro nulo dá falha de segmentação. Veja: Ponteiros e Ponteiro Nulo.
do while: Laço que roda o bloco pelo menos uma vez e só depois confere a condição: do { … } while (cond);. Bom para menus e para pedir de novo uma resposta inválida. Veja: do while.
double e float: Os tipos de número com casas decimais (ponto flutuante). double tem cerca de 15 algarismos de precisão; float, cerca de 7. São aproximações: 0.1 + 0.2 não dá exatamente 0.3. Veja: float e double.

E

else e else if: O caminho alternativo de um if ("senão") e a cadeia de várias alternativas, testadas em ordem até a primeira verdadeira. Veja: if e else e else if.
Endereço: O número da "gaveta" de memória onde uma variável mora, obtido com &: &idade. É o que o scanf recebe e o que um ponteiro guarda. Mostra-se com %p. Veja: Memória e Endereços.
enum (enumeração): Um tipo com uma lista de constantes inteiras com nome: enum cor { VERMELHO, VERDE, AZUL }; (valem 0, 1 e 2). Veja: Enums e Constantes.
EOF (end of file, fim do arquivo): O valor especial (−1) que getchar e scanf devolvem quando a entrada acaba (Ctrl+D no terminal, fim de um arquivo). Por isso o getchar se guarda num int, e não num char. Veja: Caracteres (char) e Entrada com scanf.
errno e perror: errno é a variável onde as funções do sistema deixam o número do erro quando falham (ENOENT = arquivo não existe); perror mostra a frase correspondente: No such file or directory. Veja: errno e perror.
Escape (sequência de escape): Uma barra invertida seguida de uma letra, para escrever caracteres especiais num texto: \n (nova linha), \t (tabulação), \" (aspas), \\ (a própria barra), \0 (o nulo). Veja: Novas Linhas e Escapes.
Escopo: A parte do código onde um nome existe. Uma variável local só existe dentro da sua função (ou do seu bloco); uma global existe no arquivo inteiro. Veja: Escopo e Variáveis static.
Estouro de inteiro (overflow): Quando uma conta passa do limite do tipo. Num unsigned, ela "dá a volta" (definido); num int com sinal, é comportamento indefinido: 2147483647 + 1 costuma dar -2147483648. Veja: Inteiros.
Estouro de pilha (stack overflow): Quando a pilha (8 MB no Linux) acaba, em geral por uma recursão que não para ou por um array local enorme. O programa morre com falha de segmentação. Veja: Pilha e Heap e Recursão.
Executável: O programa pronto para rodar, que o compilador cria a partir do código-fonte (gcc ola.c -o ola cria ola; sem -o, a.out). Só roda no sistema para o qual foi compilado. Veja: Olá, Mundo.
exit: Função do stdlib.h que encerra o programa de qualquer lugar, com um código de saída: exit(1);. Diferente do abort, ela esvazia os buffers e roda as funções do atexit. Veja: Encerrar o Programa.
extern: Declara uma variável global que está definida em outro arquivo: extern int contador;. Veja: static e extern.

F

Falha de segmentação (segmentation fault): O sistema matou o programa porque ele mexeu numa memória que não é dele, como um ponteiro nulo. No terminal aparece Falha de segmentação (imagem do núcleo gravada) e o código de saída é 139. Veja: Ponteiro Nulo e Depurar com gdb.
fgets: Lê uma linha inteira, com espaços, sem passar do tamanho do array: fgets(nome, sizeof nome, stdin). O \n do Enter vem junto. É o substituto seguro do gets, que foi removido. Veja: Ler uma Linha (fgets).
FILE *, fopen e fclose: Um arquivo aberto é representado por um FILE *, devolvido pelo fopen("notas.txt", "r") (ou NULL, se falhar) e fechado com fclose. Veja: Arquivos (fopen e fclose).
for: Laço com as três partes numa linha: começo, condição e passo: for (int i = 0; i < 10; i++). O preferido para repetir um número conhecido de vezes. Veja: for.
fread e fwrite: Leem e gravam bytes "crus" num arquivo binário, como uma fotocópia da memória: um array de structs inteiro de uma vez. Veja: Arquivos Binários.
free: Devolve ao sistema a memória reservada com malloc, calloc ou realloc. Depois do free, o ponteiro não pode mais ser usado, e liberar duas vezes é erro. Veja: malloc e free.
fseek e ftell: Mudam e informam a posição de leitura e escrita dentro de um arquivo aberto, como um marcador de páginas. Veja: Posição no Arquivo.
Função: Um bloco de código com nome, que recebe parâmetros e pode devolver um valor com return: int dobro(int x) { return 2 * x; }. Todo programa C começa pela função main. Veja: Funções.
Função pura: Função que recebe tudo pelos parâmetros, devolve o resultado com return e não faz mais nada (não lê o teclado, não imprime, não muda globais). É a mais fácil de testar. Veja: Testes (assert).
Função variádica: Função que aceita um número variável de argumentos, como o printf. Declara-se com ... e lê-se com va_list, va_start e va_arg, do stdarg.h. Veja: Funções Variádicas.

G

gcc: O compilador C do projeto GNU, o mais usado no Linux. O comando padrão do guia é gcc -std=c23 -Wall -Wextra arquivo.c -o programa. Veja: Compilar com gcc e Instalar no Linux.
gdb: O depurador do projeto GNU: break (parar numa linha), next, step, print e backtrace (onde o programa caiu). Veja: Depurar com gdb.
_Generic C11: Escolhe uma expressão conforme o tipo de outra, na compilação. Serve para fazer macros que funcionam com vários tipos. Veja: _Generic.
getchar e putchar: Leem e escrevem um caractere: int c = getchar(); e putchar(c);. Veja: Caracteres (char) e Saída com printf.
Global (variável global): Variável declarada fora de qualquer função, visível no arquivo inteiro e viva durante todo o programa. Começa com zero. Use pouco: qualquer função pode mudá-la. Veja: Escopo e Variáveis static.
goto: Pula para um rótulo dentro da mesma função. Raro em código moderno; o uso aceito é sair de vários laços ou ir a um trecho de limpeza no fim da função. Veja: goto.

H

Heap (monte): A região da memória de onde vêm os blocos do malloc. É grande, e a memória fica lá até você chamar free, mesmo depois que a função que a pediu terminou. Veja: Pilha e Heap.
Hexadecimal: Números na base 16, com os algarismos 0 a 9 e as letras a a f: 0xff = 255. É como endereços e bits costumam ser mostrados (%x, %p). Veja: Inteiros e Operadores de Bits.

I

Identificador: O nome que você dá a uma variável, função ou tipo. Começa com letra ou _, não pode ser palavra-chave, e maiúsculas e minúsculas são diferentes (Nota ≠ nota). Veja: Nomes de Variáveis.
if: Executa um bloco só se a condição for verdadeira (diferente de zero): if (nota >= 6) { … }. Veja: if e else.
#include: Ordem do pré-processador que cola outro arquivo naquele ponto: #include <stdio.h> traz as declarações do printf. Veja: Pré-processador.
Include guard: As linhas #ifndef DATAS_H / #define DATAS_H / #endif em volta de um .h, para ele não ser incluído duas vezes no mesmo arquivo. Veja: Compilação Condicional e Arquivos .h e .c.
Índice: A posição de um elemento num array, começando em 0: num int v[5], os índices vão de 0 a 4. Usar v[5] é passar do fim. Veja: Arrays.
Inicializar: Dar um valor à variável no momento em que ela é criada: int total = 0;. Uma variável local sem valor inicial contém lixo. Veja: Variáveis.
inline: Uma dica ao compilador para copiar o corpo de uma função pequena no lugar de cada chamada. Num .h, use static inline. Veja: Funções inline.
int: O tipo inteiro do dia a dia: 4 bytes no gcc do laboratório e no editor, de −2147483648 a 2147483647. Os parentes são short, long, long long e as versões unsigned. Veja: Inteiros e Tipos de Dados.

L

Laço (loop, repetição): Um bloco que se repete enquanto uma condição for verdadeira: while, do while e for. Um laço cuja condição nunca fica falsa é um laço infinito. Veja: while, for e Laços Aninhados.
Ligador (linker, ld): A última etapa da compilação: junta os arquivos .o e as bibliotecas num executável. Os erros dele (referência não definida para "soma", em inglês undefined reference) aparecem quando falta uma função ou há duas iguais. Veja: Como o C Vira Programa e Vários Arquivos.
Lista ligada: Uma sequência de nós criados com malloc, em que cada um guarda um valor e um ponteiro para o próximo; o último aponta para NULL. Cresce e encolhe sem copiar nada. Veja: Listas Ligadas.
Literal: Um valor escrito direto no código: 42, 3.14, 'A', "Ana", 0xff. Um literal de string não pode ser alterado. Veja: Inteiros e Strings.
long e long long: Inteiros maiores que o int. O long long tem 8 bytes em todo lugar; o long tem 8 no Linux de 64 bits e 4 no Windows e no editor do guia. Para um tamanho garantido, use int64_t. Veja: Inteiros e stdint.h.
lvalue: Algo que pode ficar à esquerda do =, porque tem um lugar na memória: uma variável, v[2], *p. O resultado de um ternário ou de uma conta não é. O gcc avisa com lvalue required as left operand of assignment. Veja: Operador Ternário.

M

Macro: Um nome definido com #define que o pré-processador troca por um texto antes da compilação: #define MAX 100, ou com parâmetros, #define DOBRO(x) ((x) * 2). Não confere tipos, e o argumento pode ser calculado duas vezes. Veja: Pré-processador e Macros com Parâmetros.
main: A função por onde todo programa C começa: int main(void), ou int main(int argc, char *argv[]) para receber argumentos. O return dela vira o código de saída. Veja: Olá, Mundo.
make e Makefile: O make lê um arquivo Makefile com as regras de como montar o programa e recompila só o que mudou. Veja: Makefile.
malloc (memory allocation): Reserva um bloco de memória no heap e devolve o endereço dele, ou NULL se faltar memória: int *v = malloc(n * sizeof *v);. A memória vem com lixo. Todo malloc tem o seu free. Veja: malloc e free.
Máscara de bits e flag: Um número com só alguns bits ligados, usado para ligar (x |= m), desligar (x &= ~m), inverter (x ^= m) ou testar (x & m) esses bits. Cada bit pode ser uma opção sim/não, uma flag ("bandeira"). Veja: Máscaras e Flags.
memcpy e memmove: Copiam N bytes de um lugar da memória para outro. O memcpy exige que as áreas não se sobreponham; o memmove aceita. Na dúvida, memmove. Veja: volatile e restrict e string.h.
Montador (assembler): A etapa que transforma o código de montagem (.s) em código de máquina, num arquivo objeto (.o). Veja: Como o C Vira Programa.

N

NDEBUG: Se este nome estiver definido (-DNDEBUG), todos os assert somem do programa. Por isso, nada que precise acontecer pode ficar dentro de um assert. Veja: Testes (assert).
Nó: Cada "pedaço" de uma lista ligada ou de uma árvore: uma struct com o valor e um ou mais ponteiros para outros nós. Veja: Listas Ligadas e Árvores Binárias.
NULL e nullptr: O ponteiro nulo, que não aponta para lugar nenhum. NULL é a forma antiga (uma macro); nullptr é a palavra-chave do C23. Funções como malloc e fopen devolvem nulo quando falham. Veja: Ponteiro Nulo.

O

Operador: Um símbolo que faz uma operação: aritméticos (+ - * / %), de comparação (== != < >), lógicos (&& || !), de bits (& | ^ ~ << >>) e de atribuição (= +=). Veja: Operadores Aritméticos e Referência de Operadores.
Operador ternário (? :): Escolhe um entre dois valores numa expressão: maior = a > b ? a : b;. É o único operador do C com três partes. Veja: Operador Ternário.
Otimização (-O2): Com -O2, o compilador reescreve o programa por dentro para ele ficar mais rápido: guarda valores em registradores, apaga contas sem efeito. Um programa com comportamento indefinido pode mudar de resultado com -O2. Veja: Compilar com gcc e volatile e restrict.

P

Padrão ISO: O documento oficial que define a linguagem C, mantido por um comitê internacional. Cada edição é uma versão (C99, C11, C17, C23); os compiladores seguem o padrão e acrescentam extensões. Veja: Versões do C.
Palavra-chave: Uma palavra reservada da linguagem, que não pode ser nome de variável: int, if, while, return, struct… Veja: Nomes de Variáveis.
Parâmetro: A variável, na definição da função, que recebe o valor do argumento: em int dobro(int x), x é o parâmetro. Veja: Parâmetros.
Passagem por valor e por ponteiro: Em C, a função sempre recebe uma cópia dos argumentos (por valor) e não consegue mudar as variáveis de quem chamou. Para mudar, passa-se o endereço (&x) e a função usa um ponteiro. Veja: Parâmetros e Passar por Ponteiro.
Pilha (memória, stack): A região da memória onde ficam as variáveis locais. Cada chamada de função ganha uma "bandeja" que some quando a função termina. É rápida, mas pequena (8 MB no Linux). Veja: Pilha e Heap.
Pilha e fila (estruturas de dados): Na pilha, o último que entra é o primeiro que sai (push e pop, como pratos empilhados); na fila, o primeiro que entra é o primeiro que sai (como a fila do banco). Veja: Pilhas e Filas.
Ponteiro: Uma variável que guarda um endereço: int *p = &x;. Com *p você lê e muda o x à distância. Veja: Ponteiros, Ponteiros e Arrays e Ponteiro para Ponteiro.
Ponteiro para função: Um ponteiro que guarda o endereço de uma função, para chamá-la depois ou passá-la a outra: int (*op)(int, int) = soma;. Veja: Ponteiros para Funções.
Ponteiro solto (dangling pointer): Um ponteiro que ainda guarda um endereço que não vale mais: memória já liberada com free, ou uma variável local de uma função que terminou. Usá-lo é comportamento indefinido. Veja: Comportamento Indefinido e Valor de Retorno.
Pré-processador: A primeira etapa da compilação: executa as linhas que começam com # (#include, #define, #ifdef) e entrega o texto resultante ao compilador. gcc -E mostra o resultado. Veja: Pré-processador.
Precedência: A ordem em que os operadores são aplicados: 2 + 3 * 4 é 2 + (3 * 4). Na dúvida, use parênteses. Veja: Precedência.
printf (print formatted): Mostra um texto na tela, com lacunas (%d, %f, %s…) preenchidas pelos valores seguintes: printf("%s tem %d anos\n", nome, idade);. Veja: Saída com printf, Formatos do printf e Referência do printf.
Protótipo: A declaração de uma função sem o corpo, terminada em ;: int dobro(int x);. Permite chamar a função antes da definição, ou em outro arquivo. Os .h são listas de protótipos. Veja: Protótipos.

R

Recursão: Uma função que chama a si mesma, com um problema menor a cada vez, até chegar a um caso simples (o caso base). Sem caso base, estoura a pilha. Veja: Recursão e Árvores Binárias.
Registrador: Uma "gaveta" dentro do próprio processador, muito mais rápida que a memória. Com -O2, o compilador guarda nos registradores os valores mais usados. Veja: volatile e restrict.
restrict C99: Promessa, num parâmetro ponteiro, de que aquela memória não é acessada por nenhum outro ponteiro durante a função: int *restrict a. Permite otimizar; quebrar a promessa é comportamento indefinido. Veja: volatile e restrict.
return: Encerra a função e devolve um valor a quem chamou: return a + b;. No main, o valor vira o código de saída. Veja: Valor de Retorno.

S

Sanitizer: Um "fiscal" que o compilador põe dentro do programa e que para tudo, com um relatório, no primeiro erro de memória (-fsanitize=address) ou de comportamento indefinido (-fsanitize=undefined). Veja: Sanitizers.
scanf (scan formatted): Lê valores do teclado conforme um formato e os guarda nos endereços recebidos: scanf("%d", &idade). Devolve quantos campos leu: confira sempre. Veja: Entrada com scanf e Validar a Entrada.
setjmp e longjmp: setjmp marca um ponto do programa; longjmp volta para ele de dentro de outras funções, como um ponto de salvamento de jogo. Veja: setjmp e longjmp.
Sinal (signal): Um aviso que o sistema manda ao programa: o Ctrl+C (SIGINT), um alarme (SIGALRM), o acesso proibido à memória (SIGSEGV). Com signal você escolhe uma função para tratá-lo. Veja: Sinais.
size_t: O tipo inteiro sem sinal dos tamanhos: é o que sizeof e strlen devolvem. Mostra-se com %zu. Tem 8 bytes no Linux de 64 bits e 4 no editor. Veja: Tamanho dos Tipos e stdint.h.
sizeof: Operador que diz quantos bytes um tipo ou uma variável ocupa: sizeof(int) é 4. Num array, dá o tamanho inteiro; num ponteiro, só o do ponteiro. Veja: Tamanho dos Tipos.
snprintf: Como o printf, mas escreve numa string, sem passar do tamanho informado: snprintf(buf, sizeof buf, "%d", n). É o substituto seguro do sprintf. Veja: Texto ↔ Número.
static: Dentro de uma função, cria uma variável que lembra o valor entre as chamadas. Fora das funções, esconde uma função ou variável global dos outros arquivos. Veja: Escopo e Variáveis static e static e extern.
static_assert: Confere uma condição na compilação: se for falsa, o programa nem é criado. static_assert(sizeof(int) == 4);. Veja: static_assert.
stdin, stdout e stderr: Os três canais que todo programa recebe ao começar: a entrada (o teclado), a saída (a tela) e a saída de erros. fprintf(stderr, …) escreve mensagens de erro. Veja: stdin, stdout e stderr.
stdint.h: O cabeçalho dos inteiros com tamanho escrito no nome: int32_t, uint8_t, int64_t, iguais em todo computador. Veja: Inteiros de Tamanho Fixo.
String: Em C, um texto é um array de char terminado em '\0': char nome[] = "Ana";. Não se compara com == (use strcmp) nem se copia com = (use snprintf ou strcpy). Veja: Strings e Funções de String.
strlen, strcpy, strcmp: Funções do string.h: o tamanho de uma string (sem o '\0'), a cópia (cuidado com o espaço do destino) e a comparação (0 = iguais). Veja: Funções de String e string.h.
struct (estrutura): Um tipo novo que junta vários campos, como uma ficha de cadastro: struct aluno { char nome[40]; double nota; };. Acessa-se com . (a.nota) ou, por um ponteiro, com -> (p->nota). Veja: Structs e Structs e Ponteiros.
switch: Escolhe um caminho conforme o valor inteiro de uma expressão, com um case para cada valor e default para os outros. Sem break, a execução continua no próximo case. Veja: switch.

T

Tabela hash (tabela de espalhamento): Estrutura que guarda pares chave–valor e acha uma chave quase na hora, calculando a posição dela com uma função de hash. Veja: Tabela Hash.
Teste automático: Um programa separado que chama as suas funções com exemplos de resposta conhecida e confere os resultados, sempre que você quiser. Veja: Testes (assert).
Tipo: O que uma variável guarda e quanto espaço ocupa: int, double, char, bool, ponteiros, structs… Em C, o tipo é decidido na compilação e não muda. Veja: Tipos de Dados e Tipos e Limites.
typedef: Dá um apelido a um tipo: typedef struct aluno Aluno; permite escrever só Aluno. Veja: typedef.
typeof C23: Dá o tipo de uma expressão, para declarar outra variável igual: typeof(x) copia = x;. Veja: Novidades do C99 ao C23.

U

UB: Sigla de undefined behavior: veja Comportamento indefinido. Veja: Comportamento Indefinido.
union (união): Parecida com a struct, mas todos os campos dividem a mesma memória: só um deles vale de cada vez. Veja: Unions.
unsigned (sem sinal): Inteiro que não aceita negativos e, em troca, vai mais longe no positivo: unsigned int vai de 0 a 4294967295. Misturar com e sem sinal numa comparação dá surpresas. Veja: Inteiros e Conversão de Tipos.
UTF-8: O jeito de guardar texto usado hoje: as letras sem acento ocupam 1 byte (como no ASCII) e as acentuadas, 2 ou mais. Por isso strlen("ação") dá 6. Veja: Acentos e UTF-8 e Caracteres (char).

V

Valgrind: Ferramenta que roda o programa "por dentro" de um simulador e aponta vazamentos, leituras fora do lugar (Invalid read) e valores sem inicializar. Use com valgrind --leak-check=full ./programa. Veja: Valgrind.
Variável: Um espaço na memória com nome e tipo, que guarda um valor que pode mudar: int idade = 30;. Veja: Variáveis.
Vazamento de memória (memory leak): Memória reservada com malloc e nunca liberada com free. Num programa que roda por muito tempo, o consumo só cresce. O Valgrind e o -fsanitize=address acham. Veja: Vazamentos de Memória e Valgrind.
VLA (variable length array) C99: Um array local cujo tamanho vem de uma variável: int v[n];. Fica na pilha, então um n grande demais estoura a pilha. Veja: Arrays.
void: "Nenhum valor": o tipo de retorno de uma função que não devolve nada (void mostrar(void)) e, nos parênteses, "sem parâmetros". Veja: Funções e Tipos de Dados.
void * (ponteiro genérico): Um ponteiro que aceita o endereço de qualquer tipo, mas não pode ser desreferenciado sem conversão. É o que o malloc devolve. Veja: Ponteiro void*.
volatile: Avisa o compilador que a variável pode mudar "por fora" (hardware, um tratador de sinal): cada leitura e escrita tem de acontecer de verdade. Para sinais, volatile sig_atomic_t. Não serve para threads. Veja: volatile e restrict.

W

-Wall -Wextra: As opções do compilador que ligam os avisos mais úteis. O guia compila sempre com elas. Veja: Compilar com gcc e Avisos.
WebAssembly: Um formato de programa que roda dentro do navegador. O editor do guia compila o seu C com o Clang para WebAssembly e o roda na própria página. Veja: O Editor do Guia.
while: Laço que repete o bloco enquanto a condição for verdadeira, conferindo antes de cada volta: pode rodar zero vezes. Veja: while.