Folha de Consulta C
Última atualização
Hello World e estrutura do programa
Todo programa C começa em main e retorna um int.
| Elemento | Código |
|---|---|
| Incluir um cabeçalho | #include <stdio.h> |
| Ponto de entrada | int main(void) { ... } |
| Com argumentos de linha de comando | int main(int argc, char *argv[]) { ... } |
| Exibir uma linha | printf("Hello, World!\n"); |
| Retornar sucesso | return 0; |
| Comentário de uma linha | // comment |
| Comentário de bloco | /* comment */ |
Tipos de dados
Os tamanhos dependem da plataforma; os mínimos abaixo são garantidos pelo padrão.
| Tipo | Descrição |
|---|---|
int | Inteiro, pelo menos 16 bits (geralmente 32) |
unsigned int | Inteiro não negativo |
long / long long | Inteiros mais largos (pelo menos 32 / 64 bits) |
float / double | Ponto flutuante de precisão simples / dupla |
char | Byte único, também usado para caracteres |
_Bool (bool via <stdbool.h>) | true ou false |
size_t | Tipo sem sinal para tamanhos e índices |
void | Sem tipo - usado para funções e ponteiros genéricos |
Especificadores de formato printf e scanf
Marcadores que correspondem ao tipo de cada argumento.
| Especificador | Corresponde a |
|---|---|
%d / %i | int com sinal |
%u | int sem sinal |
%ld / %lld | long / long long |
%f | double (e float em printf) |
%.2f | double com 2 casas decimais |
%c | Um único char |
%s | String (char *) |
%p | Endereço de ponteiro |
%x | int sem sinal em hexadecimal |
%zu | size_t |
Operadores
| Operador | Significado |
|---|---|
+ - * / % | Aritméticos (% é o resto inteiro) |
== != | Igual / diferente |
< > <= >= | Comparação |
&& || ! | E / ou / não lógico |
& | ^ ~ << >> | E, ou, xor, não bit a bit, deslocamentos |
++ -- | Incremento / decremento |
+= -= *= /= | Atribuição composta |
cond ? a : b | Condicional ternário |
sizeof(x) | Tamanho de um tipo ou variável em bytes |
Controle de fluxo
| Instrução | Sintaxe |
|---|---|
| If / else | if (x > 0) { ... } else { ... } |
| Else if | else if (x == 0) { ... } |
| Switch | switch (n) { case 1: ...; break; default: ...; } |
| Laço while | while (i < n) { ... } |
| Laço do-while | do { ... } while (i < n); |
| Laço for | for (int i = 0; i < n; i++) { ... } |
| Break / continue | break; sai de um laço, continue; pula para a próxima iteração |
| Goto (raro) | goto label; ... label: |
Funções
Declare antes de usar, ou adicione um protótipo no topo do arquivo.
| Operação | Sintaxe |
|---|---|
| Definir uma função | int add(int a, int b) { return a + b; } |
| Protótipo (declaração) | int add(int a, int b); |
| Sem valor de retorno | void greet(void) { ... } |
| Sem parâmetros | int rand_seed(void) { ... } |
| Passagem por ponteiro (mutar) | void inc(int *p) { (*p)++; } |
| Passar um array | int sum(int arr[], int n) { ... } |
| Estática (local ao arquivo) | static int helper(void) { ... } |
Ponteiros e memória
Um ponteiro guarda um endereço. A memória do heap precisa ser liberada manualmente.
| Operação | Sintaxe |
|---|---|
| Declarar um ponteiro | int *p; |
| Endereço de | p = &x; |
| Desreferenciar (ler/escrever) | int y = *p; / *p = 10; |
| Ponteiro nulo | int *p = NULL; |
| Alocar no heap | int *a = malloc(n * sizeof(int)); |
| Alocar + zerar | int *a = calloc(n, sizeof(int)); |
| Redimensionar uma alocação | a = realloc(a, newSize); |
| Liberar memória do heap | free(a); |
| Aritmética de ponteiros | *(a + i) é o mesmo que a[i] |
Arrays e strings
Strings em C são arrays de char terminados por \0.
| Operação | Sintaxe |
|---|---|
| Declarar um array | int nums[5]; |
| Inicializar um array | int nums[] = {1, 2, 3}; |
| Acessar um elemento | nums[0] = 10; |
| Tamanho do array (arrays na pilha) | sizeof(nums) / sizeof(nums[0]) |
| Literal de string | char s[] = "hello"; |
| Comprimento da string | strlen(s) (exclui \0) |
| Copiar uma string | strcpy(dst, src); |
| Comparar strings | strcmp(a, b) == 0 significa igual |
| Concatenar strings | strcat(dst, src); |
Structs e stdlib comuns
| Operação | Sintaxe |
|---|---|
| Definir uma struct | struct Point { int x; int y; }; |
| Declarar e acessar | struct Point p; p.x = 1; |
| Acessar via ponteiro | p->x = 1; (igual a (*p).x) |
| Apelido de tipo | typedef struct Point Point; |
| Ler entrada | scanf("%d", &n); |
| Converter string para int | int n = atoi("42"); |
| Valor absoluto / potência | abs(x) (int), pow(x, y) de <math.h> |
| Ordenar um array | qsort(arr, n, sizeof(int), cmp); |
A sintaxe, os especificadores de formato e os padrões de ponteiros de C que você mais usa, em uma única página. Esta folha de consulta C é uma referência rápida para escrever C - os tipos de dados, os especificadores de printf/scanf, os operadores, o controle de fluxo e as operações de ponteiro e memória que costumam confundir as pessoas.
Tudo aqui é C padrão (C99/C11) e compila com gcc ou clang. Copie o que precisar ou teste qualquer trecho ao vivo no playground de C - sem compilador para instalar. Aprendendo C? O curso interativo de C gratuito da Coddy cobre ponteiros, memória e a biblioteca padrão na prática.
Perguntas frequentes sobre a folha de consulta C
Esta folha de consulta C é gratuita?
Sim. Esta folha de consulta C é totalmente gratuita, sem necessidade de cadastro. Salve nos favoritos e volte sempre que precisar consultar um tipo, um especificador de formato ou uma operação de ponteiro.
Qual é a diferença entre a pilha e o heap em C?
malloc ou calloc, vive até você chamar free, e é usada quando você precisa de memória que sobreviva à função atual ou cujo tamanho só é conhecido em tempo de execução. Esquecer de chamar free na memória do heap causa um vazamento de memória.Por que o scanf precisa de um e comercial (&) mas o printf não?
scanf escreve o valor de volta na sua variável, então precisa do endereço da variável - é isso que &x fornece. O printf apenas lê o valor, então você passa o próprio valor. A exceção são as strings: um array de char já decai para um ponteiro, então você passa scanf("%s", name) sem o &.Posso praticar C online?
Sim. Abra o playground de C para compilar e executar qualquer trecho desta folha de consulta no seu navegador - sem compilador para instalar. Quando quiser estrutura, o curso interativo e gratuito de C da Coddy leva você passo a passo de variáveis e laços a ponteiros e gerenciamento de memória.
Esta folha de consulta é boa para iniciantes?
Sim. Ela está organizada dos blocos de construção mais comuns (tipos, printf, controle de fluxo) até os avançados (ponteiros, memória, structs), de modo que você pode usar as seções de cima já no primeiro dia e ir avançando para o resto.
Recursos relacionados
Mais folhas de consulta
