Documentação de C++
Referência concisa e baseada em exemplos de C++. Leia o conceito, veja o código e pratique em uma jornada da Coddy.
Inicie uma jornada guiada de C++Primeiros passos
- O que é C++O que C++ realmente é, por que ela compila direto para código de máquina nativo e os tipos de software de alto desempenho que são construídos com ela.
- Instalar C++Como instalar um compilador de C++ (GCC, Clang ou MSVC), escolher um conjunto de ferramentas para o seu sistema operacional e confirmar que ele funciona pela linha de comando.
- Compilando C++Como o C++ transforma código-fonte .cpp em um executável nativo: compile com g++ (ou clang++/MSVC), rode o binário e leia os erros do compilador quando algo dá errado.
- Sintaxe de C++As regras básicas de sintaxe de um programa em C++ - instruções e ponto e vírgula, blocos entre chaves, a função main e como a saída funciona - explicadas a partir de um primeiro programa.
- ComentáriosComo escrever comentários em C++ - notas de uma linha // e blocos de múltiplas linhas /* */ - além de como comentar código, por que comentários de bloco não aninham e o que faz um comentário valer a pena.
Variáveis e tipos
- VariáveisComo funcionam as variáveis em C++: declarar com um tipo, a diferença entre atribuição e inicialização, inicialização com chaves, regras de nomenclatura e o escopo que decide onde uma variável vive e morre.
- Tipos de dadosUm passeio prático pelos tipos de dados fundamentais do C++ - inteiros, ponto flutuante, char e bool - além de tamanhos, signed versus unsigned, literais e sufixos, overflow e como escolher o tipo certo.
- Palavra-chave autoComo a palavra-chave `auto` deixa o compilador deduzir o tipo de uma variável por você: o que ela descarta, onde ela brilha e as pegadinhas que pegam os iniciantes.
- Constantes e constComo declarar valores somente leitura em C++ com const, a diferença entre const e constexpr, ponteiros const versus ponteiros para const e funções-membro const.
- OperadoresAprenda os operadores de C++ - aritméticos, de comparação, lógicos, de atribuição e bit a bit - além das armadilhas da divisão inteira, da precedência e do curto-circuito.
- Conversão de tiposComo funciona a conversão de tipos em C++: conversões implícitas, a armadilha da divisão inteira e os quatro casts nomeados (static_cast, const_cast, reinterpret_cast, dynamic_cast), com os detalhes que causam perda silenciosa de dados.
Fluxo de controle
- if-elseComo tomar decisões em C++ com if, else if e else: condições, encadear ramos, aninhamento, o operador ternário, if com inicializador e as armadilhas que costumam confundir as pessoas.
- switchA instrução switch do C++ explicada: rótulos case, break e fall-through, o ramo default, agrupar cases, usar switch com enums e as armadilhas das declarações dentro dos cases.
- laço forComo repetir código com o laço for do C++: o cabeçalho de três partes, contar para cima e para baixo, percorrer arrays, aninhar, break e continue, além dos erros de deslocamento por um e de tipos sem sinal que pegam todo mundo.
- Laços whileO laço while do C++ explicado: o while que verifica a condição primeiro, o do-while que roda pelo menos uma vez, repetir até um valor sentinela, break e continue, e como evitar laços infinitos.
- for baseado em intervaloO laço for baseado em intervalo do C++ explicado: iteração limpa sobre arrays, vectors, strings e maps, por que você deve usar auto& e const auto&, e as armadilhas de cópia e invalidação de iteradores a evitar.
Funções
- FunçõesComo escrever funções em C++: a anatomia de tipo de retorno/nome/parâmetros, declarações versus definições, retornar valores, funções void e armadilhas como esquecer o return ou o protótipo.
- Parâmetros de funçãoComo os argumentos chegam às funções em C++: passagem por valor x por referência, referências const para acesso barato somente leitura, argumentos padrão, ponteiros e as armadilhas de custo de cópia que deixam os programas lentos sem você perceber.
- ReferênciasReferências em C++ explicadas: como o & em um parâmetro cria um alias, por que a passagem por referência evita cópias e permite que uma função modifique as variáveis de quem a chama, e quando usar const& e referências em vez de retornar valores.
- Sobrecarga de funçõesA sobrecarga de funções em C++ permite que várias funções compartilhem um único nome, desde que suas listas de parâmetros sejam diferentes. Aprenda como a resolução de sobrecarga escolhe a versão certa, por que o tipo de retorno sozinho não conta e as armadilhas de ambiguidade e argumentos padrão que você deve evitar.
- LambdasEscreva pequenas funções inline na hora com as lambdas de C++: a sintaxe, como as capturas funcionam, quando usar `mutable` e a armadilha da captura pendente que pega todo mundo.
Ponteiros e memória
- PonteirosPonteiros em C++ explicados do zero: declarar um ponteiro, os operadores & (endereço de) e * (dereferência), nullptr, ponteiros para arrays e as armadilhas de ponteiros pendentes e não inicializados que causam travamentos.
- Referências vs ponteirosUma comparação prática entre referências e ponteiros em C++: o que têm em comum, onde diferem (reassociação, nulo, aritmética) e uma regra clara para saber qual escolher no dia a dia.
- Memória dinâmicaComo alocar memória em tempo de execução com `new`, liberá-la com `delete` e evitar os vazamentos, ponteiros pendurados e double-frees que vêm com o gerenciamento manual da heap.
- Ponteiros inteligentesPonteiros inteligentes são donos da memória do heap e a liberam automaticamente. Aprenda `unique_ptr`, `shared_ptr`, `make_unique` e `make_shared`, e por que você quase nunca deve escrever `new`/`delete` de novo.
Strings e E/S
- StringsComo usar `std::string` em C++ - montar, juntar, buscar e fatiar texto com segurança, e por que você quase nunca quer um `char*` cru para trabalho de verdade.
- Entrada e saídaComo funciona a E/S de console em C++: imprimir com cout, ler com cin, o clássico bug da quebra de linha do getline depois do cin e como se recuperar quando a entrada falha.
- Streams de stringComo usar std::stringstream, istringstream e ostringstream para analisar texto, dividir strings por espaços em branco, converter entre strings e números e construir strings formatadas na memória.
Contêineres da STL
- ArraysOs arrays nativos de C++ explicados: como declarar e inicializar, indexar com segurança, percorrer usando o tamanho, a armadilha da decadência de array para ponteiro e por que std::array e vector costumam ser melhores.
- vectorstd::vector é o array redimensionável do C++ - o contêiner que você deve usar por padrão. Aprenda a criar, acessar, fazer crescer e percorrer um vector, além das pegadinhas de invalidação de iteradores e de acesso fora dos limites.
- mapO std::map do C++ explicado: um contêiner chave-valor ordenado com busca logarítmica. Insira, encontre, itere e evite a clássica armadilha do operator[] que insere chaves silenciosamente.
- unordered_mapAprenda std::unordered_map em C++ - o irmão de map baseado em tabela hash que oferece inserção e busca em O(1) médio. Cobre as operações básicas, a pegadinha da inserção automática do [], count versus find e quando escolhê-lo em vez de um map ordenado.
- setComo o std::set armazena valores únicos e ordenados automaticamente em C++: inserir, verificar a existência com count e find, iterar em ordem e as diferenças entre set, multiset e unordered_set.
- pair e tupleComo `std::pair` e `std::tuple` empacotam dois ou mais valores em um único objeto: como criá-los, acessar os campos, structured bindings e onde cada um se encaixa.
- IteradoresComo os iteradores de C++ funcionam como ponteiros generalizados para dentro de containers: begin() e end(), desreferenciar, avançar, as variantes const/reverse e as armadilhas de invalidação e de desreferenciar end() que causam comportamento indefinido.
Algoritmos e templates da STL
- AlgoritmosUse os algoritmos padrão do C++ - `find`, `count_if`, `transform`, `accumulate`, `remove` - para fazer trabalho de verdade sobre intervalos sem escrever laços à mão, além das pegadinhas do par de iteradores e do idiom erase-remove.
- OrdenaçãoOrdene vetores e arrays em C++ com `std::sort`: ordem padrão, comparadores personalizados, ordenar structs por um campo e a armadilha da ordenação fraca estrita que causa travamentos.
- TemplatesEscreva o código uma única vez e deixe que ele funcione com qualquer tipo usando templates de C++: templates de função, templates de classe, dedução de tipos e os confusos erros de compilação que eles causam.
Classes e objetos
- ClassesAprenda como as classes em C++ agrupam dados e comportamento em tipos reutilizáveis: declarar variáveis-membro e métodos, criar objetos, a divisão public/private e armadilhas como membros não inicializados e o ponteiro this.
- ConstrutoresUm construtor é a função-membro especial que roda quando um objeto é criado. Aprenda os construtores padrão, parametrizados e de cópia, as listas de inicialização de membros e como evitar deixar objetos pela metade.
- DestrutoresUm destrutor é executado automaticamente quando um objeto é destruído. Aprenda a sintaxe `~NomeClasse()`, quando ele dispara, por que libera recursos e a Regra de Três/Cinco.
- HerançaAprenda como a herança em C++ permite que uma classe derivada reutilize e estenda uma classe base: a sintaxe, herança pública versus privada, a ordem de construtores e destrutores e armadilhas como o fatiamento de objetos (slicing).
- Funções virtuaisAs funções virtuais permitem que um ponteiro da classe base chame, em tempo de execução, a versão do método da classe derivada. Aprenda `virtual`, `override`, classes abstratas e por que o destrutor da base precisa ser virtual.
- Sobrecarga de operadoresA sobrecarga de operadores em C++ permite que seus próprios tipos funcionem com operadores nativos como +, == e <<. Aprenda as regras de funções membro x não membro, como sobrecarregar os operadores de comparação e de fluxo, e as pegadinhas envolvendo tipos de retorno e o operador de atribuição.
- Especificadores de acessoComo public, private e protected controlam quem pode mexer nos membros de uma classe em C++ - a base do encapsulamento, com getters, setters e a saída de emergência friend.
- StructsStructs em C++ explicadas: como reunir variáveis relacionadas em um único tipo, declarar e inicializar objetos struct, dar funções membro e construtores a uma struct, e qual é a real diferença entre struct e class.
- enumsAprenda os enums de C++: como declará-los, por que o enum class com escopo é mais seguro que o enum comum, valores subjacentes personalizados, usar switch com enumeradores e converter de e para inteiros.
Erros e depuração
- ExceçõesExceções relatam erros que uma função não consegue tratar localmente. Aprenda a usar `throw`, quais são os tipos de exceção padrão, a mensagem do `what()` e por que exceções são melhores que códigos de retorno para as falhas que realmente importam.
- try-catchEnvolva o código arriscado em `try` e reaja no `catch`. Aprenda a capturar exceções por referência constante, ordenar vários tratadores, usar `catch (...)` e relançar, sem vazar recursos.
- Comportamento indefinidoComportamento indefinido (UB) é o código sobre o qual o padrão de C++ não impõe nenhuma regra: ele pode travar, corromper dados ou parecer que funciona. Aprenda as causas comuns, por que "funcionou" não prova nada e as ferramentas que detectam o UB.
