Folha de Consulta C++
Última atualização
Hello World e estrutura do programa
A execução começa em main, que retorna um int.
| Elemento | Código |
|---|---|
| Incluir um cabeçalho | #include <iostream> |
| Ponto de entrada | int main() { ... } |
| Exibir uma linha | std::cout << "Hello, World!" << std::endl; |
| Ler entrada | std::cin >> x; |
| Usar o namespace std | using namespace std; |
| Retornar sucesso | return 0; |
| Comentários | // line e /* block */ |
Tipos de dados
| Tipo | Descrição |
|---|---|
int | Inteiro (geralmente 32 bits) |
long / long long | Inteiros mais largos |
float / double | Números de ponto flutuante |
char | Byte único / caractere |
bool | true ou false |
std::string | Texto dinâmico de <string> |
auto | O compilador infere o tipo |
std::size_t | Tipo sem sinal para tamanhos e índices |
Variáveis e referências
Referências são apelidos; ponteiros guardam endereços.
| Operação | Sintaxe |
|---|---|
| Declarar e inicializar | int x = 5; |
| Inicialização com chaves | int x{5}; |
| Constante | const double PI = 3.14159; |
| Constante de tempo de compilação | constexpr int N = 10; |
| Referência (apelido) | int &r = x; |
| Ponteiro | int *p = &x; |
| Desreferenciar um ponteiro | *p = 10; |
| Inferência de tipo | auto y = 3.14; |
Controle de fluxo
| Instrução | Sintaxe |
|---|---|
| If / else | if (x > 0) { ... } else { ... } |
| 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++) { ... } |
| For baseado em intervalo | for (auto x : vec) { ... } |
| For por intervalo por referência | for (auto &x : vec) { ... } |
| Break / continue | break; sai de um laço, continue; pula para a próxima iteração |
Funções
| Operação | Sintaxe |
|---|---|
| Definir uma função | int add(int a, int b) { return a + b; } |
| Sem valor de retorno | void greet() { ... } |
| Argumentos padrão | int pow(int b, int e = 2) { ... } |
| Passagem por referência | void inc(int &x) { x++; } |
| Referência const (sem cópia) | void print(const std::string &s) { ... } |
| Sobrecarga | int max(int a, int b); e double max(double a, double b); |
| Lambda | auto f = [](int x) { return x * 2; }; |
| Lambda com captura | auto g = [n](int x) { return x + n; }; |
Classes e OOP
| Operação | Sintaxe |
|---|---|
| Definir uma classe | class Dog { ... }; |
| Especificadores de acesso | public:, private:, protected: |
| Variável de membro | std::string name; |
| Construtor | Dog(std::string n) : name(n) {} |
| Destrutor | ~Dog() { ... } |
| Função de membro | void bark() { ... } |
| Criar um objeto | Dog d("Rex"); |
| Herança | class Puppy : public Dog { ... }; |
| Função virtual | virtual void speak(); |
Contêineres da STL
Contêineres comuns da biblioteca padrão.
| Contêiner | Uso e exemplo |
|---|---|
std::vector<int> | Array dinâmico: v.push_back(1); v.size(); |
std::string | Texto: s += "!"; s.length(); |
std::array<int, 3> | Array de tamanho fixo com info de limites |
std::map<K, V> | Chave-valor ordenado: m["a"] = 1; |
std::unordered_map<K, V> | Hash map (busca mais rápida, sem ordem) |
std::set<T> | Valores únicos ordenados: s.insert(5); |
std::pair<A, B> | Dois valores: make_pair(1, "x") |
std::queue / std::stack | Adaptadores de fila FIFO / pilha LIFO |
Algoritmos e iteradores da STL
De <algorithm>; a maioria recebe um intervalo de iteradores begin/end.
| Operação | Sintaxe |
|---|---|
| Iteradores begin / end | v.begin(), v.end() |
| Ordenar | std::sort(v.begin(), v.end()); |
| Ordenar de forma decrescente | std::sort(v.begin(), v.end(), std::greater<int>()); |
| Encontrar um valor | auto it = std::find(v.begin(), v.end(), 5); |
| Contar correspondências | std::count(v.begin(), v.end(), 5); |
| Elemento mínimo / máximo | std::max_element(v.begin(), v.end()); |
| Somar um intervalo | std::accumulate(v.begin(), v.end(), 0); |
| Transformar cada elemento | std::transform(v.begin(), v.end(), v.begin(), fn); |
Smart pointers e C++ moderno
Prefira smart pointers a new/delete manuais para limpeza automática.
| Recurso | Sintaxe |
|---|---|
| Posse exclusiva | auto p = std::make_unique<Dog>("Rex"); |
| Posse compartilhada | auto p = std::make_shared<Dog>("Rex"); |
| Referência sem posse | std::weak_ptr<Dog> w = p; |
| Semântica de movimento | auto v2 = std::move(v1); |
| Nullptr | int *p = nullptr; |
| Vinculações estruturadas | auto [key, val] = *it; |
| Valor opcional | std::optional<int> maybe; |
| Templates | template <typename T> T add(T a, T b) { return a + b; } |
A sintaxe, os contêineres da STL e os recursos modernos 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, as referências, as classes, os contêineres e algoritmos da biblioteca padrão e os smart pointers que substituem new/delete manuais.
Tudo aqui é C++ padrão (C++11 e posterior) e compila com g++ ou clang++. Copie o que precisar ou teste qualquer trecho ao vivo no playground de C++ - sem compilador para instalar.
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 uma sintaxe, um contêiner da STL ou um smart pointer.
Qual é a diferença entre um ponteiro e uma referência em C++?
Um ponteiro é uma variável que guarda um endereço; ele pode ser nulo, ser reatribuído para apontar para outro lugar, e você o desreferencia com
*p. Uma referência (int &r = x) é um apelido para uma variável existente - precisa ser vinculada na declaração, nunca pode ser nula nem revinculada, e é usada como a própria variável. Use referências para parâmetros de passagem por referência mais limpos e ponteiros quando precisar de indireção opcional ou reatribuível.Devo usar new/delete ou smart pointers?
Prefira smart pointers.
std::unique_ptr e std::shared_ptr (via make_unique/make_shared) liberam sua memória automaticamente quando saem de escopo, o que evita os vazamentos e double-frees que vêm com new/delete manuais. Recorra a new/delete brutos apenas em código de baixo nível que tenha um motivo específico.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 classes e à STL.
Esta folha de consulta é boa para iniciantes?
Sim. Ela está organizada dos blocos de construção mais comuns (tipos, controle de fluxo, funções) até os avançados (a STL e os smart pointers), 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
