cpp_academy · src/syntax · C++20
Sintaxe C++
a sintaxe padrão da linguagem, de ponta a ponta
aquecimento antes de qualquer regra
Uma linha, uma pegadinha
Dentro do main, o que Widget w(); declara?
- um
Widgetcriado pelo construtor padrão - uma função
w, sem parâmetros, que devolveWidget - um ponteiro para
Widget - nada — não compila
-Wvexing-parse), mas compila. Variável de verdade: Widget w; ou Widget w{}; — Cap. 1 · 1.2.Ao fim da aula, você explica:
por que int s{3.14}; não compila — e int t = 3.14; sim
por que QUADRADO_ERRADO(1+2) vale 5
por que -1 < 1u é false
o que roda entre o throw e o catch
src/syntax README · O que é este projeto?
O mapa da sintaxe do C++
Toda construção da linguagem — declaração, if, switch, for, função, tipo, classe, template, exceção — num só lugar, executada e comentada.
- Lê-se primeiro; volta-se como referência.
- Nada exige C++ prévio: o Cap. 0 define cada palavra.
- Onde há subprojeto dedicado, mostra a sintaxe e aponta para lá.
README aqui você vê → para se aprofundar
Aqui, a sintaxe; lá, o mecanismo
rodar da raiz do repositório
Configurar, compilar, rodar
make configuresó na 1ª vez: Conan +meson setupem./buildmake buildcompila:meson compile -C buildmake installcopia os binários para./dist/bin./dist/bin/syntaxoumake run—BIN=syntaxé o padrão
make open PROJ=syntax abre no navegador padrão — Linux, WSL, macOS ou Windows.estrutura src/syntax/
8 headers, 1 .cpp, 1 executável
- ▾src/syntax/
- ├─main.cppponto de entrada58
- ├─demo_variaveis.hpp1 · declarações470
- ├─demo_controle.hpp2 · controle de fluxo381
- ├─demo_funcoes.hpp3 · funções391
- ├─demo_tipos.hpp4 · tipos do usuário343
- ├─demo_classes.hpp5 · classes389
- ├─demo_organizacao.hpp6 · organização336
- ├─demo_expressoes.hpp7 · expressões326
- ├─demo_generico.hpp8 · genérico e erros393
- ├─meson.buildalvo
syntax8 - ├─README.mdo texto de referência
- └─apresentacao/esta aula
número = linhas do arquivo (wc -l)
Um demo = um namespace
O main.cpp só chama demo_xxx::run(), na ordem da saída — e cada demo pode ser lido sozinho.
O pré-processador cola tudo
main.cppg++ -E -P)Os 8 demos, o fmt, a biblioteca padrão e os headers do sistema: 308 headers colados (g++ -M). O compilador enxerga uma unidade de tradução.
O caminho inteiro — pré-processador → compilador → linker — é o Cap. 0.
meson.build: um alvo, um fonte
As flags vêm do meson.build da raiz: cpp_std=c++20 e warning_level=3 viram -std=c++20 -Wall -Wextra -Wpedantic.
⚠ Por que um .cpp só?
As funções demo_…() — e quase todas as auxiliares — são definidas no header sem inline. Dois .cpp incluindo o mesmo demo = duas definições:
10 funções acusadas (7 demo_…() + 3 auxiliares); run() fica de fora: inline é a licença para definições idênticas repetidas (ODR, Cap. 6 · 6.4).
main.cpp o ponto de entrada
main() é um roteiro de 8 atos
- 1Declarações171
- 2Controle de fluxo131
- 3Funções140
- 4Tipos do usuário107
- 5Classes107
- 6Organização127
- 7Expressões176
- 8Genérico e erros128
✓ Todos os demos de sintaxe concluídos!
agenda um capítulo por demo · clique para ir
O mapa da aula
teclado aperte as teclas — elas acendem aqui
Como navegar nesta aula
última tecla—
Capítulo 0 · README.md › Antes de começar
Antes de começar
Programador C++ conta a partir do zero. Antes do Cap. 1: as três máquinas que transformam texto em programa — e as palavras que o resto da aula usa.
for (int cap = 0; cap <= 8; ++cap) estudar(cap); // começa do zero
- 0.1 do código ao programa
- 0.2 unidade de tradução
- 0.3 declaração × definição
- 0.4 linkage e ODR
- 0.5 o vocabulário
- 0.6 o menor programa
- 0.7 as 11 armadilhas
- 0.8 os avisos que importam
0.1 o caminho do código até o programa
Texto entra, programa sai: três máquinas
0.1 g++ -E · g++ -c · nm · ld
As três máquinas, de verdade
Só texto: o header foi colado e VEZES virou 3. Isto é a TU. (A linha em branco é o que sobrou do #pragma once.)
Um .o por TU. U = usado aqui, definido fora: o buraco. T = código definido aqui.
Casou o U dobro(int) de main.o com o T de dobro.o. O programa devolve 3 × 2 = 6.
0.2 unidade de tradução (TU)
A TU é o .cpp com tudo colado
import): para não reprocessar o mesmo texto em cada TU.0.2 #pragma once
O mesmo header, duas vezes na mesma TU
sem guarda a TU tem dois struct Ponto
#pragma once na 1ª linha de ponto.hpp
0.3 declaração × definição
Declarar é prometer; definir é fornecer
| declaração · promete que existe | definição · fornece corpo / memória | |
|---|---|---|
| função | int dobro(int x); | int dobro(int x) { return x * 2; } |
| variável | extern int total; | int total = 0; |
| tipo | struct Motor; | struct Motor { int cv; }; |
O compilador cobra a declaração
Para checar a chamada, basta saber que dobro existe e o tipo dos parâmetros e do retorno.
O linker cobra a definição
Para preencher o buraco, precisa do corpo — o T que casa com o U. Toda definição também declara.
0.3 quem reclama de quê
Faltou a promessa — ou a entrega?
sem declaração quem reclama: o compilador
Erro de compilação: arquivo, linha, coluna — e o .o nem chega a existir.
sem definição quem reclama: o linker
Erro de link: compilou limpo; falta o T para o U dobro(int). Sem -g, nem número de linha: só o símbolo.
0.4 linkage · nm -C · ld
Linkage: quem enxerga um nome
0.4 one definition rule
ODR: N declarações, uma definição
0.5 glossário vivo · clique num termo
Palavras que aparecem o tempo todo
0.5 escopo × tempo de vida
Escopo é do nome; tempo de vida, do objeto
0.5 comportamento indefinido (UB)
UB: ausência de contrato
int não estoura ⇒ dobrar um positivo dá positivo ⇒ i > 0 é sempre verdade ⇒ laço infinito. O printf sumiu.-fsanitize=undefined acusa na hora: signed integer overflow. Com -Wall -Wextra: nenhum aviso.0.6 README › o menor programa C++ completo
O menor programa C++ completo
0.6 minimo.cpp · fmt vem do Conan
Copie, compile, rode: saída real
avisos com -Wall -Wextra -Wpedantic -Wshadow -Wconversion
achados com -fsanitize=address,undefined — nem vazamento
código de saída: main sem return devolve 0
0.6 três fatos · clique para virar
Três fatos que esse programa já ensina
main sem return?
O programa termina sem return em main. Compila? O que o shell recebe?
main devolve int e é a única função que pode omitir o return: equivale a return 0; — echo $? dá 0.
Em outra função não-void, cair do fim é UB, e o GCC avisa por padrão: -Wreturn-type.
#include importa?
#include <fmt/core.h> traz uma biblioteca já compilada para dentro do programa?
Não: é colagem de texto. As 18 linhas viram 58.226 na TU — e o compilador relê tudo em cada .cpp.
O código compilado da fmt chega depois, pelo linker: -lfmtd. Importar de verdade é o import dos módulos do C++20.
Quando o objeto morre?
Saudacao{"mundo"}.falar(); — sem nome, sem new, sem delete.
É um temporário: nasce, fala e morre no fim da expressão completa — o ;. Sem vazamento.
0.7 por que estudar isto? · armadilhas 1–6
Sintaxe mal lida: apostem antes de ver
0.7 por que estudar isto? · armadilhas 7–11
Mais cinco: apostem de novo
0.8 GCC 13.3 · as 32 combinações de flags, compiladas
Os avisos que importam não vêm ligados
quiz · capítulo 0
Quem faz o quê?
O que #include "dobro.hpp" faz, de fato?
- importa um módulo já compilado
- cola o texto do arquivo no lugar da linha
- diz ao linker onde está a definição
- cria um namespace com o nome do arquivo
Ninguém define dobro. E agora?
- erro de compilação em
main - compila; o linker falha
- roda e devolve lixo
- o linker cria uma
dobrovazia
undefined reference to `dobro(int)'.quiz · capítulo 0
UB e avisos
O que melhor descreve UB?
- o programa produz um valor aleatório
- o padrão não define nada: pode funcionar, travar ou mudar com
-O2 - um erro de compilação adiado para a execução
- um comportamento que o compilador escolhe e documenta
-O0 e virou jmp infinito em -O2. (A opção D é o implementation-defined.)Que flag acusa este case sem break?
- nenhuma: já avisa
-Wall-Wextra-Wpedantic
-Wimplicit-fallthrough vem com -Wextra — o -Wall sozinho não pega. Queda de propósito? [[fallthrough]];resumo do capítulo 0
O que fica antes de começar
#includecola texto: a TU é o .cpp com tudo colado — 18 linhas viram 58.226.- O compilador vê uma TU por vez e deixa buracos (
U); o linker os preenche. - Declarar promete (o compilador cobra); definir fornece (o linker cobra).
- Linkage externa: o programa todo enxerga. Interna (
static, namespace anônimo): só a TU. - ODR: N declarações, uma definição.
inlinerepete só se idêntico — senão, ninguém avisa. - Escopo é do nome (texto); tempo de vida é do objeto (execução).
- UB não é valor aleatório: é ausência de contrato — o
-O2pode reescrever o programa. - Os avisos que importam não vêm ligados — o mínimo civilizado:
-Wall -Wextra -Wpedantic -Wshadow -Wconversion
Capítulo 1 · demo_variaveis.hpp
Declarações, tipos e inicialização
Toda declaração tem a mesma forma — e quase toda armadilha clássica do C++ começa numa declaração mal lida.
- 1.1 tipos fundamentais
- 1.2 as 6 formas de inicializar
- 1.3 auto e decltype
- 1.4 const · constexpr · constinit
- 1.5 escopo e storage
- 1.6 ponteiros e arrays
- 1.7 typedef × using
- 1.8 literais
- 1.9 structured bindings
1.0 demo_variaveis.hpp:8
Toda declaração tem a mesma forma
constexpr double pi = 3.14159;constante de compile-time
extern int contador;sem inicializador: só promete que existe
int (*f)(int) = nullptr;o declarador pode ficar difícil → próximo slide
Quantos ponteiros int* a, b; declara?
Para o padrão, int também é especificador e o declarador é *a: o * gruda no nome. a é int*, b é int — uma declaração por linha.
1.0 regra da espiral
Comece pelo nome: direita, depois esquerda
1.0 README · regras de ouro
O monstro — e o using que desfaz o nó
int (*f[3])(int);ff é — comece no nome[3]→ array de 3*← ponteiros para — o)bloqueou(int)→ função(int) que devolveint← int
using — o leitor lê da esquerda para a direita, como prosa.1.1 demo_variaveis.hpp:45
Quantos bytes? Medido, não decorado
1.1 largura fixa
Quando o tamanho importa: <cstdint>
char, signed char e unsigned char são distintos — e se char tem sinal é escolha da plataforma (aqui, x86-64: tem).1.2 demo_variaveis.hpp:95
As seis formas de inicializar
- copy:
=, semexplicit - direct:
( ), atéexplicit - list: proíbe narrowing
- copy-list:
= {}, semexplicit - value:
{}vazio → zero garantido - default: depende de onde ⚠
{} venceu Funciona em todo contexto (variável, membro, new, return), proíbe narrowing e nunca é confundida com declaração de função.1.2 default-init
int x; vale quanto? Depende de onde
1.2 narrowing
As chaves bloqueiam o narrowing
{} sai como warning (o padrão diz "mal-formado"). Compile com -Werror=narrowing ou -pedantic-errors.| com chaves | resultado | por quê |
|---|---|---|
int x{3.0}; | erro | flutuante → inteiro: sempre estreita |
char c{65}; | ok | constante que cabe |
char c{300}; | erro | 300 não cabe em char |
unsigned u{-1}; | erro | negativo não cabe |
double d{3}; | ok | 3 é exato em double |
char c{i}; | warning | i não é constante |
1.2 a exceção que dói
( ) × { } num container
std::vector<int> a(3, 0);
→
std::vector<int> b{3, 0};
→
std::vector<int> c(3);→
std::vector<int> d{3};→
{ }, um construtor que recebe std::initializer_list tem prioridade na resolução de sobrecarga. Regra prática: { } para os elementos, ( ) para tamanho e valor.1.2 most vexing parse
Widget w(); é uma função
Se o texto pode ser lido como declaração de função, ele é declaração de função.
Widget w{};✓ variável (aggregate-init: v = 0)Widget w;✓ variável (default-init: v = 0)1.2 saída real
O que o programa imprime
- seis formas — só
int x;não tem valor =trunca;{}bloqueia{}num container = elementos()vazio = função
1.3 demo_variaveis.hpp:132
O que o auto deduz — e o que joga fora
1.3 decltype
decltype: o tipo exato — e os ( )
nome → o tipo declarado
expressão → lvalue T& · xvalue T&& · prvalue T
decltype(auto) → deduz com estas regras
decltype(auto), return (x); de um x local devolve int& para um morto — o GCC avisa: reference to local variable ‘x’ returned.1.4 demo_variaveis.hpp:189
Três promessas diferentes
"não posso modificar"
- ✓ valor pode vir de runtime
- ✗ nunca muda
- · vindo de runtime, não serve em
static_assert
"o compilador já sabe"
- ✓ usável em static_assert e NTTP
- ✗ nunca muda (implica const)
- ⚠ o inicializador tem de ser constante
"nasce pronto, mas muda"
- ✓ init garantida em compile-time
- ✓ muda depois, à vontade
- ⚠ só static / thread_local
const int n = 42; (inteiro com inicializador constante) também serve em static_assert. const double não: the value of ‘x’ is not usable in a constant expression.1.4 constinit · por quê
O fiasco da ordem de inicialização
inicialização estática: zero e constantes — constinit garante estar aqui
inicialização dinâmica: entre .cpp diferentes, a ordem não é especificada
main() começa
1.4 demo_variaveis.hpp:203
Leia da direita para a esquerda
1.4 volatile
volatile: não otimize — e só isso
Cada leitura e escrita é um efeito observável: registradores de hardware (I/O mapeado em memória), volatile std::sig_atomic_t em handler de sinal.
Threads. volatile não dá atomicidade nem ordenação — uma thread escrevendo e outra lendo um volatile int ainda é data race (UB). Use std::atomic.
1.5 demo_variaveis.hpp:240
Escopo é do nome; tempo de vida, do objeto
1.5 demo_variaveis.hpp:233
static local: nasce uma vez, vive até o fim
__cxa_guard_acquire.1.5 storage class
Quanto tempo vive, onde é visível
| forma | exemplo | vive quando | visível onde |
|---|---|---|---|
| automático | int x; no bloco | escopo do bloco | bloco |
static (local) | static int n; | programa inteiro | bloco |
static (global) | static int g; | programa inteiro | só esta .cpp |
extern | extern int g; | programa inteiro | todo o programa |
thread_local | thread_local int t; | vida da thread | conforme declarado |
static em função = duração; fora = linkage interna; em classe = um por classe (cap. 5). Para "só desta .cpp", prefira namespace { }..cpp (ODR). src/linkage/1.6 demo_variaveis.hpp:289
Ponteiro × referência: o mesmo objeto
1.6 nullptr
Nulo tem tipo: nullptr
| aspecto | ponteiro | referência |
|---|---|---|
| pode ser nulo | sim (nullptr) | não |
| reapontável | sim | não (liga uma vez) |
precisa de * | sim | não |
| aritmética | sim | não |
nullptr é comportamento indefinido — verifique antes. src/undefined_behavior/1.6 demo_variaveis.hpp:278
Array → ponteiro: o tamanho se perde
1.7 demo_variaveis.hpp:338
typedef × using: onde fica o nome
typedef · herdado do C — nome no meio
using · C++11 — nome à esquerda
1.8 demo_variaveis.hpp:371
052 não é 52
1.8 sufixos e strings
O sufixo decide o tipo
| literal | tipo | bytes |
|---|---|---|
42u | unsigned | 4 |
42L | long | 8 |
42LL | long long | 8 |
3.14f | float | 4 |
3.14 | double | 8 |
3.14L | long double | 16 |
bytes: saída real (42u → unsigned (4B)…)
int → long → long long que couber (2147483648 é long). Hex/octal/binário tentam também unsigned (0x80000000 é unsigned int).1.9 demo_variaveis.hpp:425 C++17
Desempacote com nomes
quiz · 1 de 3
Teste: o que foi declarado?
O que Widget w(); declara?
- um
Widgetinicializado com valor - um
Widgetcom lixo - uma função que devolve
Widget - nada: não compila
Widget w{};Quanto vale int x = 052;?
- 52
- 42
- 82
- não compila
08 é erro: invalid digit "8".quiz · 2 de 3
Teste: tipos e chaves
Com int i = 0;, decltype((i)) é…
intint&int&&const int&
(i) é uma expressão lvalue → int&. Sem os parênteses, decltype(i) = int.std::vector<int> v{3, 0}; — v.size()?
- 3
- 2
- 0
- não compila
{}, o construtor de initializer_list vence: elementos 3 e 0. Três zeros: v(3, 0).quiz · 3 de 3
Teste: o que imprime?
Saída do programa:
- 20
- 5
- 8
- 4
int arr[5] é, na verdade, int*: sizeof = 8. O GCC avisa: ‘sizeof’ on array function parameter ‘arr’ will return size of ‘int*’.resumo do capítulo 1
O que fica
- Leia declarações pela espiral: nome → direita → esquerda. Ilegível?
using. - O padrão só garante ordem e larguras mínimas: meça com
sizeof; use<cstdint>. - Inicialize sempre, com
{}: proíbe narrowing;int x;local é lixo. v{3, 0}≠v(3, 0)eWidget w();é função.autodescarta&e const de topo;decltype((x))éT&.constnão muda ·constexpré compile-time ·constinitnasce pronto e muda.- Escopo é do nome; tempo de vida, do objeto;
staticlocal nasce uma vez. - Array decai para ponteiro; referência não religa;
052é octal.
Capítulo 2 · demo_controle.hpp
Controle de fluxo
Seis construções e quatro saltos fazem qualquer programa.
O C++ moderno deu a elas, sobretudo, escopo menor.
- 2.1 if · else · init
- 2.2 if constexpr
- 2.3 switch
- 2.4 while · do · for
- 2.5 range-for
- 2.6 break · continue · goto
- 2.7 ?: · && · vírgula
2.0 demo_controle.hpp
Seis construções. E só.
if / elseswitchdois caminhos por condição · N caminhos por valor
whiledo-whileforrange-fortesta antes · testa depois · conta · percorre
breakcontinuereturngotosai do laço/switch · pula a volta · sai da função · vai a um rótulo
Afora o range-for (C++11), o C++ moderno não trouxe construção nova — trouxe escopo menor:
- C++98
for (int i = 0; …)i morre no fim do for - C++98
if (T* p = f())declaração na condição - C++17
if (init; cond)idemswitch— init separado - C++20
for (init; x : v)idem no range-for
2.1 demo_controle.hpp
A primeira condição verdadeira vence
- Os testes rodam de cima para baixo.
- O primeiro verdadeiro executa; os de baixo nem são testados.
- O
elsefinal é “nenhuma das anteriores”. - Por isso a ordem importa: do teste mais restrito para o mais amplo.
Arraste o controle de nota e use o botão de ordem para explorar.
2.1 armadilha
Sem chaves, o if governa uma instrução
Com a == false, nada roda: o else é do if (b).
warning: suggest explicit braces to avoid ambiguous ‘else’ [-Wdangling-else]
GCC 13, -Wall. Com chaves, a dúvida nem existe.
-Wall só avisa quando a indentação engana — sem -Wall, silêncio total.2.1 caso real · Apple, 2014 · código simplificado
goto fail; — uma linha a mais
2.1 C++17 demo_controle.hpp
init-statement: o nome morre no fim do if
2.2 C++17 demo_controle.hpp
if constexpr: o galho descartado
2.2 a diferença
O if comum compila os dois galhos
error: request for member ‘size’ in ‘valor’, which is of non-class type ‘const int’
✓ compila: para T = int, o galho do .size() nem existe
if constexpr (false) { x.size(); } com int x ainda é erro.else if é if comum: compila os dois galhos. Tire o 3º de descrever() e descrever("abc") não compila — .size() em const char[4].2.3 switch
As cinco regras do switch
| # | Regra | Se violar — GCC 13 |
|---|---|---|
| 1 | A condição é integral ou enum — nada de string ou double. | error: switch quantity not an integer |
| 2 | Cada case: constante de compile-time e única. | error: duplicate case valueerror: ‘limite’ is not a constant expression |
| 3 | Sem break, o controle cai no próximo case. Queda intencional: [[fallthrough]]. | warning: this statement may fall through(-Wextra) |
| 4 | Variável com inicialização num case exige { chaves }. | error: jump to case labelnote: crosses initialization of ‘const char* motivo’ |
| 5 | Com enum class, omitir o default faz o compilador avisar o enumerador esquecido. | warning: enumeration value ‘Reiniciar’ not handled in switch(-Wswitch, no -Wall) |
Por que as regras 2, 3 e 4? Porque o switch é um salto para um rótulo — próximo slide.
2.3 demo_controle.hpp · executar(Comando)
O switch é um salto para um rótulo
2.3 demo_controle.hpp
Agrupar casos e o switch com init
[[fallthrough]] e o -Wextra não reclama.2.4 while · do-while · for
Onde fica o teste?
2.4 for
As três cláusulas do for
continue no for ainda executa o inc. No while escrito à mão, ele pula o incremento → pode virar laço infinito.- Todas opcionais:
for (;;)= condiçãotrue. int i = 0, j = 9é uma declaração só;++i, --jé o operador vírgula.
2.4 laços aninhados
continue pula, break sai de um nível
return (extraindo a função) ou goto — próximo bloco, 2.6.2.5 range-for
Por valor, const& ou &
for (int x : v)
Mexer em x não muda v. Bom para tipos baratos.
for (const auto& x : v)
Sem cópia, sem escrita. O padrão para ler.
for (auto& x : v) x *= 10;
Para modificar o container.
2.5 por baixo do capô
Como o compilador reescreve o range-for
2.5 idiomas e armadilhas
Mapas, init do C++20 e o que não fazer
Se realocar, __b e __e apontam para memória liberada; mesmo sem realocar, o __e guardado já não vale. ASan: heap-use-after-free.
auto&& __r = carregar().lista(); — o temporário morre no fim dessa declaração. ASan: stack-use-after-scope. O C++23 estende a vida dele (P2718) — o GCC 13 ainda não.
2.6 break · goto · return
Sair de dois laços de uma vez
2.6 goto
As regras do goto — e por que quase nunca vale
error: jump to label ‘fim’
note: crosses initialization of ‘int total’
O salto entraria no escopo de total sem passar pela inicialização. Saltar para trás pode.
error: label ‘la’ used but not defined
Um rótulo só existe dentro da própria função. Para sair dela: return ou exceção.
2.7 ternário
?: é uma expressão — tem valor
?: escolhe um valor; if/else escolhe uma ação. Ternário dentro de ternário vira enigma — aí prefira uma função.| Galhos | Tipo comum |
|---|---|
c ? 1 : 2.5 | double — converte o int |
c ? "adulto" : "menor" | const char* |
(a < b ? a : b) = 0; | dois lvalues → lvalue: zera o menor |
c ? 1 : "texto" | error: operands to ‘?:’ have different types ‘int’ and ‘const char*’ |
2.7 && e ||
Curto-circuito: o segundo operando pode nem rodar
2.7 operador vírgula
A vírgula que é operador
| Vírgula em… | É… |
|---|---|
(f(), 42) | operador — vale 42 |
for (…; …; ++i, --j) | operador — o uso legítimo |
int i = 0, j = 9; | separador de declaradores |
f(a, b) | separador de argumentos |
a[i, j] | ⚠ C++20: obsoleto (-Wcomma-subscript) · C++23: chama operator[](i, j) |
quiz · 1 de 3
O que imprime?
Com x = 1:
- um
- um dois
- um dois outro
- não compila
break, o controle cai pelos rótulos até o fim do switch. Compila — o -Wextra avisaria.E este laço?
- 3 2 1
- 2 1 0
- 2 1
- 3 2 1 0
n vale −1.quiz · 2 de 3
Quem roda, quem vale?
f() devolve 7. Quanto vale a?
- 7
- 42
- 49
- não compila
f() (o efeito acontece), descarta o 7 e devolve o último: 42.Esta linha chama f()?
- Sim, sempre
- Não — garantido
- Depende da otimização
- Só em modo debug
& seria.)quiz · 3 de 3
Isto compila?
- Compila;
total= lixo - Compila;
total= 0 - Não compila
- Compila, mas é UB
switch: um case também é um rótulo, e o salto do switch não pode pular uma inicialização.Saltar para trás por cima de uma declaração é permitido: a variável é destruída e inicializada de novo.
resumo do capítulo 2
O que fica
- Chaves sempre: sem elas o
ifgoverna uma instrução (goto fail). if (auto x = f(); cond)— o nome morre no fim doif/else.if constexprdescarta o galho falso — só dentro de template.switch= salto para rótulo: integral,caseconstante, sembreakcai.enum classsemdefault: o-Wswitchacha o caso esquecido.- range-for =
begin/end+ iterador — não insira nem remova elementos dentro dele. breaksai de um nível; prefira função +returnaogoto.?:tem valor;&&/||param cedo; a vírgula devolve o último.
Capítulo 3 · demo_funcoes.hpp
Funções: a assinatura é um contrato
Quem chama só enxerga a assinatura. Cada palavra dela muda o que a chamada faz — e o que o compilador cobra.
- 3.1 declaração × definição
- 3.2 passagem
- 3.3 argumentos padrão
- 3.4 sobrecarga
- 3.5 retorno
- 3.6 especificadores
- 3.7 variádicas
- 3.8 funções como valores
- 3.9 recursão
anatomia demo_funcoes.hpp:8
Anatomia de uma assinatura
3.1 demo_funcoes.hpp
Declarar é prometer; definir é cumprir
A promessa. Pode aparecer N vezes: quem inclui o header sabe chamar.
O corpo. Exatamente uma no programa: compila uma vez, linka em todos.
3.1 ODR · nm -C e ld de verdade
N declarações, uma definição
3.2 demo_funcoes.hpp:66
Cinco formas de passar um argumento
3.2 README · Como passar
Qual forma usar?
| Forma | Copia? | Modifica? | Aceita nulo? | Quando usar |
|---|---|---|---|---|
T | sim | não (a cópia) | não | tipos baratos, sink |
T& | não | sim | não | saída, in-out |
const T& | não | não | não | leitura — o padrão |
T* | não | sim | sim | opcional, API C |
T&& | não | consome | não | move; se T for deduzido, forwarding |
const T& para ler · T para tipos pequenos (int, double, ponteiro) · T& só quando a saída é o objetivo.T por valor e faça std::move para dentro.3.2 README · a origem de muita confusão
T&& tem dois significados
Aceita tudo e guarda em T se veio lvalue ou rvalue; std::forward<T>(x) repassa preservando isso.
std::move(e) é só um cast para rvalue. Quem move é o construtor de movimento — no demo, std::string roubado = std::move(s);.3.3 demo_funcoes.hpp:109
Argumentos padrão: o compilador completa
3.3 mensagens reais · g++ 13.3
Três regras — e o compilador cobra
Depois do primeiro padrão, todos à direita precisam de um.
O padrão pertence à declaração; repeti-lo na definição é erro.
O valor é colado em cada chamada. Não há named args: não dá para pular o 2º.
formatar("abc", 10) compila sem nenhum aviso (nem com -Wconversion): o 10 vai para preenchimento e a largura fica 20 — sai abc + 17 caracteres de código 10 ('\n').3.3 ⚠ armadilha · verificado
Padrão + virtual: duas metades
3.4 demo_funcoes.hpp:135
Mesmo nome, seis funções
tipo_de('a') · tipo_de(3.14f) · tipo_de(42u) — não existe sobrecarga para char, float nem unsigned…3.4 resolução de sobrecarga · verificada com g++ 13.3
A escada da resolução
3.4 a assinatura
O retorno não entra na assinatura
note: old declaration ‘int f(int)’
Numa chamada como f(1); o retorno nem é usado: o compilador só tem os argumentos para escolher.
| Muda a assinatura? | exemplo | |
|---|---|---|
| nome | sim | f × g |
| tipos dos parâmetros | sim | f(int) × f(double) |
const / & do método | sim | get() × get() const |
| tipo de retorno | não | int f(int) = bool f(int) |
| nomes dos parâmetros | não | f(int a) = f(int x) |
const de topo | não | f(int) = f(const int) |
| argumento padrão | não | f(int = 1) = f(int) |
noexcept, atributos | não | não criam sobrecarga |
3.5 demo_funcoes.hpp:171
Retorno no fim — ou deduzido
decltype(a + b) ainda não conhece a e b:return 1; e return 2.0; juntos:3.5 demo_funcoes.hpp:179 · structured bindings
Vários valores, com nome
parâmetros de saída: int& q, int& r
auto [q, r] = divmod(17, 5);
std::get<2>(t) — o que era o 2?
e.media — o nome diz
3.5 ⚠ dangling · programa real
Nunca devolva referência para local
f() nem devolve o endereço de x: devolve nullptr (movl $0, %eax). Ler r derruba o programa — em -O0, -O1 e -O2. Outro compilador pode ler lixo: UB não tem resultado “certo”.3.5 elisão de cópia · medida com g++ 13.3
Devolver por valor é barato
return T{}; constrói o objeto direto no destino: nem desligando a elisão aparece cópia ou move.
T t; return t; — o GCC elide por padrão; desligando, aparece 1 move e nenhuma cópia: no return, o local já é tratado como rvalue.
3.6 demo_funcoes.hpp:216
Especificadores: o que não significam
inline“expanda o corpo no lugar da chamada”
inlinepode ter definição repetida (idêntica) em várias TUs. Expandir é decisão do otimizador — a palavra é só uma sugestão.
constexpr“sempre roda em compile-time”
constexprpode rodar em compile-time, se os argumentos forem constantes; senão, é chamada normal. consteval obriga.
noexcept“o compilador garante que não lança”
noexcepté uma promessa. Uma exceção tentou sair dela? std::terminate — nenhum catch de fora pega.
[[nodiscard]]“proíbe ignorar o retorno”
[[nodiscard]]só avisa (warning). Vira erro com -Werror.
static (escopo de arquivo)“função que guarda estado”
staticlinkage interna: o nome some fora desta .cpp. O README prefere namespace anônimo.
[[deprecated]]“remove a função”
[[deprecated]]continua funcionando; cada uso gera warning com a sua mensagem.
3.6 prova no assembly · g++ -S
O que o compilador realmente faz
inline não manda expandir
constexpr: a conta já foi feita
inline garante a regra da ODR (3.1); expandir ou não, o otimizador decide sozinho. constexpr é sobre poder calcular antes de rodar — e o static_assert prova que calculou.3.6 noexcept · programa real
noexcept quebrado: terminate
noexcept: o programa chama std::terminate e aborta.3.6 demo_funcoes.hpp:226
Avisos de verdade, linkage de verdade
3.7 demo_funcoes.hpp:262
Variádicas: as duas formas
va_arg acredita no que você diz. C++: cada argumento tem o seu.sizeof...(args), em compile-time.-Wall -Wextra. C++: na compilação.3.7 fold expression · C++17
O pacote se desdobra em compile-time
3.8 demo_funcoes.hpp:303
Funções como valores
como ler int (*op)(int, int)
“op é um ponteiro para função que recebe (int, int) e devolve int.”
using Op = int (*)(int, int);3.8 ponteiro × lambda × std::function · sizeof medido
Onde cada chamável cabe
3.9 demo_funcoes.hpp:346 · chamadas contadas
Recursão: a árvore que explode
fib_recursivo(20) = 6765 — e fib_iterativo(20) também.3.9 demo_funcoes.hpp:357
Caso base e recursão mútua
-Wall, o GCC até avisa — warning: infinite recursion detected [-Winfinite-recursion] — e o programa estoura a pilha.3.9 pilha · tail call · programa real
A pilha é finita — e TCO não é garantida
-O2 o GCC transformou a recursão num laço: o assembly de soma_ate não tem nenhum call. Em -O0, 10 milhões de quadros não cabem em 8 MiB.quiz · 1 de 3
Assinatura e sobrecarga
No mesmo escopo: int f(int); e bool f(int);
- duas sobrecargas válidas
- erro de compilação
- compila; a chamada escolhe pelo retorno
- só um warning
Com as 6 sobrecargas do demo, tipo_de('a') chama…
tipo_de(int)tipo_de(double)tipo_de(bool)- erro: não há
tipo_de(char)
char → int é promoção (degrau 2); para double e bool seria conversão (degrau 3).quiz · 2 de 3
Padrão e noexcept
Isto compila?
- sim
- não: o padrão vai só na declaração
- sim, e o padrão da definição vence
int f(int a, int b).Uma função noexcept lança e não trata; quem chamou está dentro de um try/catch. O que acontece?
- o
catchcaptura normalmente std::terminate: o programa aborta- a exceção é ignorada
- comportamento indefinido
noexcept — std::terminate. Saída real: terminate called after throwing…quiz · 3 de 3
Conte as chamadas
Quantas vezes fib_recursivo é chamada (contando a primeira) para calcular fib_recursivo(5)?
- 5
- 9
- 15
- 32
f(1) e f(0).resumo do capítulo 3
O que fica
- Declare no
.hpp, defina no.cpp; header-only →inline. - Leia com
const T&; tipos pequenos por valor;T&só para saída. T&&: rvalue — ou forwarding, seTfor deduzido.- Padrão só na declaração, colado no chamador — nunca em virtual.
- Exata › promoção › conversão › usuário ›
...; o retorno não conta. - Devolva por valor; nunca referência para local.
constexprpode,noexceptpromete,[[nodiscard]]avisa.- Variádicas: parameter pack + fold, não
va_list. - Ponteiro cru não guarda estado;
std::functionguarda qualquer chamável. - Recursão: caso base, pilha finita, TCO não garantida.
Capítulo 4 · demo_tipos.hpp
Tipos definidos pelo usuário
struct, class, enum e union: quatro jeitos de dizer ao compilador o que é o seu dado — quem pode tocá-lo e quantos bytes ele ocupa.
- 4.1 struct × class
- 4.2 agregados e designated initializers
- 4.3 enum × enum class
- 4.4 union → std::variant
- 4.5 bitfields
- 4.6 aninhados e forward declaration
- 4.7 trivial · standard-layout · POD
abertura demo_tipos.hpp
Quatro maneiras de criar um tipo
dados agrupados — membros públicos por padrão
struct Ponto { int x, y; };
o mesmo — mas membros privados por padrão
class Conta { double saldo; };
um conjunto fechado de valores com nome
enum class Cor { Vermelho, Verde, Azul };
vários membros no mesmo espaço — um de cada vez
union Valor { int32_t i; float f; };
struct e class são a mesma construção: muda só o acesso padrão.4.1 demo_tipos.hpp
struct × class: a única diferença
4.1 saída real
Mesma construção, convenções diferentes
Tudo público, sem invariante a proteger.
Os métodos mantêm o objeto sempre válido.
4.2 demo_tipos.hpp
O que faz um tipo ser um agregado
4.2 demo_tipos.hpp
Por ordem dos membros — e o resto zera
struct Retangulo { int largura; int altura; };
r1{10, 20}
r2{}
r3{5}
Retangulo r;
↑ o demo cala este aviso com o único #pragma GCC diagnostic do subprojeto — de propósito: aqui, omitir campos é a lição.
4.2 demo_tipos.hpp C++20
Designated initializers: nomear os campos
4.2 saída real
O C++ é mais rígido que o C
| forma | C (C99/C11) | C++20 | o que o GCC 13 diz no C++ |
|---|---|---|---|
{.tls = true, .porta = 443} | qualquer ordem | só na ordem | designator order for field ‘Config::porta’ does not match declaration order in ‘Config’ |
{"api", .porta = 443} | misturar | tudo ou nada | either all initializer clauses should be designated or none of them should be |
{.a.x = 1} | aninhado | use .a = {.x = 1} | expected primary-expression before ‘.’ token |
{[2] = 7} | índice de array | não existe | aceita como extensão; -Wpedantic: “ISO C++ does not allow C99 designated initializers” |
4.3 demo_tipos.hpp
enum clássico: os nomes vazam
4.3 README · demo 4
enum × enum class
| enum | enum class C++11 | |
|---|---|---|
| escopo | vaza para fora | exige Cor::Verde |
converte p/ int | sozinho | só com static_cast |
| tipo subjacente | implementação | você escolhe: : uint8_t |
| colisão de nomes | acontece | impossível |
using enum Cor; traz os nomes para o escopo onde aparece (uma função, o corpo de um switch…) — quando você quiser, e não sempre.4.3 demo_tipos.hpp
Tipo subjacente: quanto o enum ocupa
CorAntiga c = Verde;
4 bytes · tipo escolhido pelo compilador
Cor m = Cor::Verde; // Cor : std::uint8_t
1 byte · tipo escolhido por você
:?enum class → int, garantido. Enum clássico → um inteiro em que os valores caibam, à escolha do compilador — no GCC 13, unsigned int.4.3 demo_tipos.hpp
enum como flags: um bit por permissão
4.4 demo_tipos.hpp
union: todos no mesmo endereço
type punning e outros comportamentos indefinidos: src/undefined_behavior/
4.4 demo_tipos.hpp C++17
Tagged union à mão × std::variant
std::variant, std::optional e std::any em detalhe: src/vocabulary_types/
4.5 demo_tipos.hpp
Bitfields: 32 bits com nome
4.5 saída real
Três avisos sobre bitfields
reg.codigo_erro = 20; guarda 4 — e só a constante gera aviso.
®.pronto e unsigned& r = reg.pronto; não compilam — daí o +reg.pronto (um int temporário).
Ordem dos bits e padding variam entre compiladores: para arquivo ou rede, monte os bits à mão — src/bits/
4.6 demo_tipos.hpp
Tipos aninhados: nomes dentro da classe
de fora: Carro::Rodas · Carro::Cambio::Manual
sizeof(Carro) = 16: 4 (Rodas) + 4 (Cambio) + 8 (Motor*). Para o ponteiro, o tamanho de Motor não importa.
4.6 demo_tipos.hpp
O tipo incompleto: o que dá para fazer?
4.6 dependências entre headers
Forward declaration quebra o ciclo
4.7 demo_tipos.hpp
Duas propriedades independentes
os dois → era o POD
trivial, mas mistura acessos nos dados
o construtor faz trabalho
nenhum dos dois
criar sem inicializar; copiar com memcpy (todo trivial é trivially copyable)
offsetof; interoperar com struct de C
= os dois juntos; std::is_pod_v agora gera aviso de deprecated
4.7 saída real
A tabela real — e o meio dela
padding, alignof e o custo do vptr: src/layout/
E ComVirtual perde tudo por 8 bytes escondidos… →
ComConstrutor não é trivial — o construtor põe 42 em a — e mesmo assim pode ir para memcpy.std::is_trivially_copyable_v<T>, não “é trivial?”.4.7 demo_tipos.hpp
O preço do virtual: 8 bytes escondidos
quiz · 1 de 3
Quanto ocupa? Quanto sobra?
Qual o sizeof desta union?
- 12
- 4
- 9
- 1
O que fica guardado em codigo_erro?
- 20
- 15
- 4
- não compila
quiz · 2 de 3
Compila?
Com o Config do demo (host, porta, tls, timeout):
- sim — a ordem não importa
- não — a ordem tem de seguir a declaração
- sim, mas host fica "localhost"
host vem antes de porta. O GCC 13:E esta?
- sim, x = 1
- sim, x = 0
- não — precisa de static_cast
int sozinho; com static_cast<int>, dá 1.quiz · 3 de 3
De onde vem o padrão?
Que herança é esta — e d.x = 1; compila?
- public — compila
- private — não compila
- depende de Base ser class: private
struct → public. Base ser class não importa.Por que ComConstrutor pode ir para memcpy e ComVirtual não?
clique para virar
A cópia de ComConstrutor é a implícita: só bytes. A de ComVirtual precisa escrever o vptr da classe certa — não é trivial.
resumo do capítulo 4
O que fica
structeclass: só muda o acesso padrão — dos membros e da herança.- Agregado = sem construtor declarado (nem
= default, C++20), sem dados privados, sem virtual. - Designated initializers nomeiam campos — na ordem da declaração.
- Use
enum class: escopo próprio, sem conversão, tipo subjacente escolhido. union: o tamanho do maior membro (+ alinhamento); ler o inativo é UB →std::bit_castestd::variant.- Bitfields truncam, não têm endereço e têm layout da implementação.
- Tipo incompleto: ponteiro e referência sim; tamanho e membros não.
- Para
memcpy, pergunteis_trivially_copyable_v; POD aposentou.
para se aprofundar
Capítulo 5 · demo_classes.hpp
Classes: a anatomia completa
Dados + as operações que os mantêm válidos. O compilador escreve metade de uma classe por você — se você deixar.
- 5.1 anatomia de uma classe
- 5.2 lista de inicialização
- 5.3 = default · = delete
- 5.4 const e ref-qualifiers
- 5.5 herança e polimorfismo
- 5.6 Regra do 0 / 3 / 5
5.1 motivação · a invariante
Por que esconder o saldo?
struct com tudo público
Qualquer linha, em qualquer arquivo, pode quebrar a regra — e o bug aparece longe de onde nasceu.
saldo ≥ 0. O construtor a estabelece; os métodos a preservam.class: dado privado + métodos
5.1 o esqueleto · topo do demo_classes.hpp
Tudo o que uma classe pode conter
5.1 demo_classes.hpp
Construtores: delegar, converter, inicializar
Dois construtores. Um deles só repassa o trabalho ao outro.
Avance: delegante → argumento padrão → lista → corpo.
ContaBancaria padrao; vira ContaBancaria("sem-titular", 0.0). O alvo roda inteiro — lista e corpo — e só então o corpo do delegante.A lista de um delegante só pode conter a delegação: mem-initializer for ‘…’ follows constructor delegation.
b{"bruno"} usa saldo_inicial = 0.0. Como pode ser chamado com um argumento, sem o explicit viraria uma conversão implícita de std::string (próximo slide).titular_, saldo_, numero_. operacoes_ não está aqui: pega o = 0 escrito na classe.{ abre, todos os membros já existem. Aqui só dá para atribuir — a seção 5.2 mostra quanto isso custa.5.1 explicit
explicit: nenhuma conversão surpresa
std::string viraria uma conta bancária sem ninguém pedir.ContaBancaria e = "ana";
compila sem o explicit?
Seriam duas conversões do usuário em fila: const char* → std::string → ContaBancaria. O C++ faz no máximo uma, implícita.
explicit, salvo se a conversão for desejada.5.1 métodos · const · mutable
Métodos: a invariante mora dentro
Depois de criada, toda mudança de saldo_ passa por depositar / sacar, que recusam o inválido. Furo: o construtor do demo aceita saldo_inicial negativo.
Só métodos const podem ser chamados por um const ContaBancaria&. Lá dentro, this é const ContaBancaria*.
Cache, contador, mutex — nunca estado lógico. Por isso consultas() é const e conta.
5.1 static · friend
Da classe, não do objeto — e quem vê o privado
static — um só, para todos
friend — acesso concedido
- concedido pela classe — nunca tomado de fora
- não é herdado nem recíproco
- uso legítimo: operador como função livre —
operator<<,==simétrico,trocar(a, b) - muitos
friend? o problema costuma ser a interface pública
5.1 demo_anatomia() passo a passo
A vida de três contas
5.1 saída real
O que o programa imprime
a e b: construtor explícito; padrao: delegante.auditar() leu três membros privados.depositar(50) já tinha contado 1 operação.}: padrao, b, a — ordem inversa.5.2 demo_classes.hpp
A lista de inicialização não é açúcar
5.2 const · referência · sem construtor padrão
Membros que precisam nascer com valor
uninitialized reference member in ‘int&’
no matching function for call to ‘Rastreado::Rastreado()’
assignment of read-only member ‘Ruim::id_’
O inicializador na classe também é inicialização: const int id_ = 0; vale — só não dá para atribuir depois.
5.2 ⚠ a armadilha da ordem
Quem nasce primeiro: a ordem de declaração
5.3 demo_classes.hpp
= default e = delete: gere ou proíba
Torna aquele uso um erro de compilação — com nome e linha. Vale para qualquer função, não só as especiais.
T() = default;
T() {}
= default não é “seu”: o tipo pode continuar trivial, e T t{} zera os membros. T() {} é código seu: nunca trivial, e T t{} não zera.
5.3 = delete numa sobrecarga
Deletar uma sobrecarga barra a conversão silenciosa
A função deletada participa da resolução de sobrecarga — se ela vencer, é erro de compilação.
| chamada | p/ int | p/ double | resultado |
|---|---|---|---|
so_aceita_int(42) | exata | conversão | int → imprime so_aceita_int(42) |
so_aceita_int(3.14) | conversão | exata | use of deleted function |
so_aceita_int(3.14f) | conversão | promoção | deletada: float → double é promoção, vence |
so_aceita_int('a') | promoção | conversão | int → imprime 97 |
so_aceita_int(42L) | conversão | conversão | empate: call … is ambiguous |
template <class T> void so_aceita_int(T) = delete; — qualquer outro tipo deduz um T exato e cai no deletado.5.4 demo_classes.hpp
O mesmo operator[], escolhido pela constância
const Buffer&:passing ‘const Buffer’ as ‘this’ argument discards qualifiers
5.4 ref-qualifiers & e &&
Ref-qualifiers: empresta ou rouba
5.4 por que a versão && existe
Sem a versão &&: referência pendurada
std::vector<int> vetor() && devolve por valor: o laço recebe o vetor inteiro → soma = 565.5 demo_classes.hpp
Herança e despacho dinâmico
descrever() não é virtual, mas chama nome() e area(), que são: decide o tipo real do objeto, não o do ponteiro.unique_ptr<Forma> deleta pelo ponteiro da base — sem destrutor virtual, isso é UB.5.5 por dentro · GCC / Itanium ABI
Por dentro do virtual: vptr e vtable
5.5 virtual · = 0 · override · final
Quatro palavras — e o erro que cada uma pega
| palavra | significado | se você errar (g++) |
|---|---|---|
virtual | pode ser substituída; despacho pelo tipo real | esquecer: compila — e o tipo do ponteiro decide |
= 0 | pura: a classe vira abstrata, não instanciável | Forma f; cannot declare variable ‘f’ to be of abstract type ‘Forma’ |
override | “estou substituindo” — o compilador confere | double area() override ‘double Elipse::area()’ marked ‘override’, but does not override |
final | ninguém mais substitui (método) / herda (classe) | class Cubo : public Quadrado cannot derive from ‘final’ base ‘Quadrado’ in derived type ‘Cubo’ |
std::string nome() sem o const não substitui nada: cria uma função nova, que esconde a da base. Compila. O GCC 13 só avisa com -Wall: was hidden [-Woverloaded-virtual=].5.5 os três tipos de herança
public, protected, private — três heranças
| herança | public de B vira | protected de B vira | B* p = &d fora |
|---|---|---|---|
: public B | public | protected | compila |
: protected B | protected | protected | não |
: private B | private | private | não |
- public — “D é-um B” (o normal)
- protected — só D e as derivadas de D veem a base
- private — “D é-implementado-em-termos-de B” (quase sempre: prefira um membro)
O private de B nunca é acessível em D, em nenhuma das três: existe, ocupa bytes, mas D não tem acesso a ele.
class dá private; em struct, public. Escreva sempre.5.5 ⚠ destrutor virtual
Base polimórfica sem destrutor virtual: UB
delete p nem compila: ‘Base::~Base()’ is protected within this context).Com virtual ~Base(): ~Derivada, depois ~Base — e a string é liberada.
5.6 as cinco operações especiais
As cinco operações especiais
| # | operação | assinatura |
|---|---|---|
| 1 | destrutor | ~T() |
| 2 | construtor de cópia | T(const T&) |
| 3 | atribuição de cópia | T& operator=(const T&) |
| 4 | construtor de move | T(T&&) |
| 5 | atribuição de move | T& operator=(T&&) |
- Regra dos 3 (C++98): precisou de uma, precisa das três
- Regra dos 5 (C++11): somou-se o move — declarar uma suprime outras
- Regra do 0: não declare nenhuma
5.6 a tabela de Howard Hinnant
O que o compilador declara por você
5.6 demo_classes.hpp
Regra do 0: componha e não escreva nada
Cada membro já sabe copiar, mover e liberar a si mesmo — então a classe sabe também.
src/value_semantics/sizeof, medido (GCC 13 · x86-64) · largura ∝ bytes
com unique_ptr: 64 bytes e move-only — a cópia vira = delete sozinha.
quiz · 5.2
Teste: lista de inicialização
O que a lista teria economizado?
- Nada: o otimizador junta os dois passos
- Uma operação inteira: 1 em vez de 2
- Só faz diferença para membros
int - A chamada do destrutor do membro
: membro(r), só CÓPIA de fonte.Quanto vale a_?
- 1
- 0
- Indeterminado — lê
b_antes de ele ser inicializado - Não compila
a_ é declarado primeiro, então nasce primeiro. Compila (com -Wall, dois avisos) — é UB.quiz · 5.5
Teste: herança e classe abstrata
Herança sem a palavra: compila?
- compila: herança é public
- não compila
class, a herança padrão é private: ‘B’ is an inaccessible base of ‘D’. Com struct, compilaria.Forma tem area() = 0. Qual linha compila?
Forma f;Forma f{};auto p = std::make_unique<Forma>();Circulo c{2.0}; Forma& r = c;
quiz · 5.6
Teste: o que o compilador fez?
Nenhum aviso com -Wall -Wextra -Wpedantic.
O que T b = std::move(a); faz com nome?
- Move:
brouba o buffer,a.nomefica vazio - Copia: aloca outro buffer,
a.nomefica intacto - Não compila: o move não foi declarado
- Comportamento indefinido
~T() {} e o buffer é roubado.resumo do capítulo 5
O que fica
- Classe = dados + invariante; o privado protege a regra.
- Construtor de um argumento:
explicit, salvo conversão desejada. - Inicialize na lista, na ordem da declaração (
-Wreorder). conste referência: inicialize, nunca atribua.= deletevale para qualquer função — até uma sobrecarga.- Método que só lê:
const. Temporário? ref-qualifier&&. - Base polimórfica: destrutor
virtual; derivada:override. - Regra do 0: componha; declarar uma especial muda as outras.
para se aprofundar
-Wall avisa) · destrutor que desliga o move (nem o -Wextra) · base sem destrutor virtual (só o -Wall) · herança private por omissão em class.Capítulo 6 · demo_organizacao.hpp
Organização: texto, nomes e símbolos
Antes do compilador, o pré-processador reescreve o arquivo; depois dele, o linker casa os símbolos. Este capítulo mora nessas costuras.
- 6.1 namespaces e ADL
- 6.2 pré-processador e macros
- 6.3 atributos [[…]]
- 6.4 linkage, ODR e extern "C"
- 6.5 static_assert e comentários
6 demo_organizacao.hpp
Três problemas diferentes, três camadas
Pré-processador
Cola #include, expande #define, apaga os galhos de #if falsos.
Não conhece escopo, tipo nem namespace.
6.2
Compilador
Namespaces separam nomes iguais; a ADL acha a função pelo tipo do argumento.
Atributos e static_assert conversam com ele.
6.1 6.3 6.5
Linker
static e o namespace anônimo escondem símbolos; inline deixa repetir; extern "C" tira o mangling.
6.4
6.1 demo_organizacao.hpp
Namespaces: cinco formas de escrever
- Aninhado: o nome completo é o caminho —
empresa::produto::v1::versao() - Numa linha C++17 —
a::b::c; o C++20 aceita atéa::inline b - Anônimo: só esta TU enxerga — o substituto moderno do
staticglobal - inline: os membros “vazam” para o pai — é o mecanismo de versionamento de ABI
- Alias:
pv1é só outro nome para o mesmo caminho
6.1 resolvendo nomes qualificados
Resolver um nome é descer caixas
6.1 versionamento de ABI
inline namespace: o novo, sem quebrar o velho
biblioteca::api()→ v2: quem chama sem versão ganha a atualbiblioteca::v1::api()→ a legada continua lá, pelo nome completo- No símbolo a versão aparece (
…10biblioteca2v23api…): código já compilado contra a v1 continua ligando com a v1
A mesma void imprimir(const std::string&), duas ABIs: a std::string nova mora no inline namespace std::__cxx11. Como ela está na assinatura, misturar objetos das duas dá erro de link — não um crash em produção.
6.1 demo_organizacao.hpp
using: um nome × todos os nomes
No demo, os dois vivem dentro de um bloco { }: o efeito acaba no }. O perigo é o escopo global…
⚠ Nunca using namespace no escopo global de um header:
6.1 argument-dependent lookup
ADL: a busca vai até o argumento
6.1 saída real · e uma surpresa
Por que o std:: às vezes some
O iterador é uma classe — __normal_iterator<…, std::vector<int>> — e o argumento de template traz std para a busca.
Aqui o iterador é int*: ponteiro cru não tem namespace associado. Moral: escreva std::sort.
6.2 o pré-processador
#include é colagem de texto
6.2 demo_organizacao.hpp
Onde ele procura — e como não colar duas vezes
"…": primeiro a pasta do próprio arquivo, depois-iquote, depois a lista do<…><…>: só-Ie o sistema — comconfig.hppnos dois lugares,"config.hpp"pegou o vizinho e<config.hpp>, o deinclude/
cor.hpp nasceu de ponto.hpp e herdou PONTO_HPP: incluído depois dele, some inteiro, em silêncio — error: ‘Cor’ was not declared in this scope.
6.2 macros de objeto e de função
Macro é substituição de texto
6.2 saída real
Duas armadilhas, um substituto
| macro | substituto melhor | o que se ganha |
|---|---|---|
#define PI 3.14 | constexpr double pi = 3.14; | tipo e escopo |
#define MAX(a,b) … | template <class T> T max(T, T) | avalia cada argumento uma vez |
#define DEBUG_ON | constexpr bool + if constexpr | o galho desligado continua compilando |
| ainda é macro | o que exige texto: guardas de inclusão, __LINE__, portabilidade (#ifdef _WIN32) | |
6.2 demo_organizacao.hpp
#, ## e __VA_ARGS__: o código como dado
| você escreve | o pré-processador entrega (g++ -E) | saída real |
|---|---|---|
MOSTRAR(a * b) | fmt::print(" {} = {}\n", "a * b", (a * b)) | a * b = 42 |
DECLARAR_VAR(temporaria) | int variavel_temporaria = 0 | criou variavel_temporaria |
LOG("sem argumentos") | fmt::print(" [log] " "sem argumentos" "\n" ) | [log] sem argumentos |
LOG("com {} e {}", 1, "dois") | fmt::print(" [log] " "com {} e {}" "\n" , 1, "dois") | [log] com 1 e dois |
__VA_OPT__(,) C++20 só emite a vírgula quando há argumentos. Sem ele, LOG("sem argumentos") deixaria "\n", ) — e o g++ responde error: expected primary-expression before ‘)’ token.
6.2 a macro como UMA instrução
Por que do { … } while (0)?
6.2 #if · #ifdef · #elif
O galho falso some antes do compilador
6.2 saída real
Macros predefinidas — e um impostor
__FILE__ e __LINE__ foram trocados; __func__ passou intacto — é um static const char[] que o compilador cria em cada função.
Dentro de um #if __cplusplus < 202002L: a compilação falha, com a sua mensagem. No C++20, std::source_location faz o papel de __FILE__/__LINE__ sem macro.
6.3 [[atributos]]
Atributos: bilhetes para o compilador
6.3 saída real
Padrão, portável — e ignorável
[[inventado]] int a; compila (status 0); o g++ só avisa: ‘inventado’ attribute directive ignored [-Wattributes]
__attribute__((always_inline)) (GCC/Clang) · __declspec(noinline) (MSVC) · ou, na sintaxe padrão, [[gnu::always_inline]] — que um compilador que não conhece o gnu:: só ignora.
6.4 linkage · nm linkage.o
Linkage, lido direto do objeto
6.4 variáveis em header
No header, static multiplica e inline unifica
main.cpp chama incrementa_em_a() duas vezes — os ++ rodam no código de a.cpp — e depois lê os dois contadores.
inline int variavel_global_do_header = 100; — e o programa lembra: antes do C++17 isto exigia extern no .hpp + a definição num .cpp.O static deu a cada TU o seu objeto (endereços diferentes); o inline (C++17) é um objeto só, mesmo definido no header — no nm, letra u.
6.4 one definition rule
ODR: duas definições, nenhum aviso
6.4 nm · c++filt
Name mangling: o tipo vai no nome
6.4 demo_organizacao.hpp
extern "C": a porta para C, Python e plugins
Dois extern "C" soma — int e double:
error: conflicting declaration of C function ‘double soma(double, double)’
chama_cpp.py pergunta se a libcpp.so tem soma_para_c (não) e _Z11soma_para_cii (sim): o ctypes procura pelo nome literal.
O mesmo vale para plugins: em src/plugin_registry uma macro gera três funções extern "C" que o dlsym(h, "plugin_name") acha pelo nome.
6.5 demo_organizacao.hpp
Verificar antes ou durante?
static_assert — na compilação. Falhar é erro de compilação; custo em runtime: zero. Mensagem opcional desde o C++17.
assert (<cassert>) — na execução. Falhar imprime e aborta; com -DNDEBUG, a linha some.
6.5 demo_organizacao.hpp
Comentário bom diz o porquê
/* /* */ */ não compila
/* não aninha: o primeiro */ fecha tudo e o */ que sobra vira código → dentro de uma função, error: expected primary-expression before ‘/’ token
#if 0 … #endif: os #if se aninham, e um /* … */ lá dentro não atrapalha.
++i; // incrementa i++i; // incrementa iRepete o código. Quando o código mudar, vai mentir.
// a API devolve centavos: converter só na borda// a API devolve centavos: converter só na bordaExplica uma decisão que o código não consegue dizer.
“O melhor comentário explica o PORQUÊ; o código já diz o QUÊ.” — a última linha do demo. Os /// e /** */ viram documentação em src/doxygen
quiz · 1 de 2
Texto ou símbolo?
Com #define QUADRADO_ERRADO(x) x* x, quanto vale QUADRADO_ERRADO(1+2)?
- 9
- 5
- 3
- não compila
1+2* 1+2: a multiplicação vem antes → 1 + 2 + 2 = 5.Num header, no escopo global: const int limite = 10; — qual o linkage?
- externa: um objeto no programa
- interna: um objeto por TU
- nenhum: vira um literal
- depende de
-O
const global é interno em C++ (quando o objeto é emitido, o nm mostra r minúsculo). Para um só: inline constexpr.quiz · 2 de 2
Quem enxerga o quê?
O que o g++ -E faz com __FILE__, __LINE__ e __func__?
- troca os três
- troca
__FILE__e__LINE__; deixa__func__ - troca só
__LINE__ - não troca nenhum
__func__ não é macro: é uma variável que o compilador cria dentro de cada função.O que imprime?
- 1 1
- 2 1
- 2 2
- ambíguo
inline namespace valem como se fossem de lib; a v1 continua pelo nome completo.resumo do capítulo 6
O que fica
- Namespaces separam nomes;
a::b::ce alias encurtam. usingde um nome; nuncausing namespaceglobal em header.inline namespace: a versão nova, sem quebrar a antiga.- ADL procura nos namespaces dos argumentos.
#includecola texto;#pragma oncecola uma vez.- Macro é texto: parênteses, dupla avaliação →
constexpr. do { … } while (0): a macro vale uma instrução.- Atributos
[[…]]são padrão; o desconhecido só avisa. static, anônimo,constglobal: internos.- ODR violada não avisa;
extern "C"tira o mangling.
Capítulo 7 · demo_expressoes.hpp
Expressões, operadores e conversões
Toda linha de C++ é feita delas — e o compilador as lê ao pé da letra, mesmo quando você queria outra coisa.
- 7.1 operadores
- 7.2 precedência
- 7.3 categorias de valor
- 7.4 conversões implícitas
- 7.5 os quatro casts
- 7.6 sizeof & cia.
- 7.7 new / delete
7 · abertura demo_expressoes.hpp
Expressão vale algo; instrução faz algo
a + ba + bproduz um valor: 7, um int (se a = 3 e b = 4)
a + b;a + b;calcula e joga fora — GCC: statement has no effect
x = 5x = 5vale o próprio x: (x = 5) + 1 dá 6
throw errothrow errotipo void: cabe num ?:
x = 5 é expressão: vale x, que vira bool; 5 é true.7 · abertura tipo e categoria
Toda expressão responde a duas perguntas
O que é o valor? int, double, std::string…
decide as operações e as conversões (7.4)
lvalue: tem endereço. rvalue: temporário — ou marcado como descartável (std::move).
decide o que vai à esquerda do = e o que pode ser movido (7.3)
| expressão | tipo | categoria |
|---|---|---|
x | int | lvalue |
x + 1 | int | prvalue |
'A' + 1 | int (não char!) | prvalue |
x = 5 | int | lvalue é o próprio x |
"abc" | const char[4] | lvalue (!) |
std::move(x) | int | xvalue |
x e x + 1: o mesmo tipo, categorias diferentes.7.1 demo_expressoes.hpp aritméticos
Divisão inteira trunca — não arredonda
a % 0 e a / 0 com inteiros: comportamento indefinido.(a/b)*b + a%b == a — também com negativos.7.1 relacionais e lógicos
Curto-circuito: && e || param no meio
a <=> b devolve uma ordem (std::strong_ordering para int), que se compara com 0: (17 <=> 5) > 0 → true
if (p && p->x > 0) só é seguro por causa do curto-circuito.7.1 bit a bit
Bit a bit: coluna por coluna
& e | avaliam os DOIS lados, sempre.uint8_t u = 17, ~u já é int: −18. O demo corta para 8 bits → 238.Clique nos bits de a e b e nos botões para explorar.
7.1 atribuição composta
x op= y é x = x op y, com x avaliado uma vez
v[idx()] += 1; → idx() roda 1 vez
v[idx()] = v[idx()] + 1; → idx() roda 2 vezes
7.1 incremento
++i × i++: quem paga a cópia
7.1 os outros
Os outros operadores — você já usa todos
::resolução de escopo&endereço-de (unário).->acesso a membro[]()índice e chamada*desreferência (unário)?:o único ternário,avalia os dois, devolve o último.*->*ponteiro para membro
7.2 precedência e associatividade
Precedência decide a forma da árvore
7.2 saída real
A escada de 17 níveis — que ninguém decora
O -Wall avisa nos casos clássicos:
1 << 2 + 3suggest parentheses around ‘+’ inside ‘<<’x & 1 == 0suggest parentheses around comparison in operand of ‘&’!m == nlogical not is only applied to the left hand side of comparison3 > 2 > 1comparisons like ‘X<=Y<=Z’ do not have their mathematical meaning7.2 ordem de avaliação
Precedência ≠ ordem de avaliação
| expressão | quem roda primeiro |
|---|---|
a && b a || b a , b a ? b : c | a, sempre |
a[b] a << b a >> b a->*b | a (C++17) |
a = b a += b | b (C++17) |
f(a, b) | f; depois a e b em ordem livre |
a + b a * b a == b … | não especificado |
i = i++ + 1: UB até o C++14; definido desde o C++17 (o lado direito vem antes). O GCC 13 ainda avisa -Wsequence-point: não escreva isso.7.3 demo_expressoes.hpp categorias de valor
lvalue mora em algum lugar; rvalue está de passagem
&x ✓ &42 ✗ &(x+1) ✗
error: lvalue required as unary ‘&’ operand
devolve_referencia() = 99 ✓
devolve_valor() = 99 ✗
error: lvalue required as left operand of assignment
7.3 README · Demo 7
Duas perguntas, três categorias, dois guarda-chuvas
| categoria | identidade? | saqueável? | exemplos |
|---|---|---|---|
| lvalue | sim | não | x *p arr[0] f()→T& |
| xvalue | sim | sim | std::move(x) f()→T&& |
| prvalue | não | sim | 42 x + 1 T{} f()→T |
"Saquear" = mover: roubar as entranhas de um objeto que ninguém mais vai usar. É a base do move semantics. Esta tabela é a mesma de src/value_semantics/
7.3 o teste do decltype
Classifique: lvalue, xvalue ou prvalue?
7.4 demo_expressoes.hpp conversões implícitas
Antes de operar, os dois lados viram o mesmo tipo
7.4 a armadilha que mais aparece em produção
-1 < 1u é false
7.4 truncamento e perda de precisão
Compila, roda, quase nunca avisa — e perde dados
int t = 3.99;int t = 3.99;3trunca para zero, não arredondaint t = -3.99;int t = -3.99;−3para ZERO — não −4float f = 16'777'217;float f = 16'777'217;16777216acima de 2²⁴ o float pulabool b = -5;bool b = -5;truesó 0 é falseunsigned u = -1;unsigned u = -1;4294967295módulo 2³²short s = 2'000'000'000;short s = 2'000'000'000;−27648módulo 2¹⁶ (C++20) — o único que avisa: -Woverflowerror: narrowing conversion of ‘3.9900000000000002e+0’ from ‘double’ to ‘int’ [-Wnarrowing]
De uma variável (int t{d};) o GCC só avisa — use -Werror=narrowing.
7.4 int grande → float
Acima de 2²⁴, o float pula números
7.5 demo_expressoes.hpp casts
Quatro casts, quatro intenções
| cast | faz | verifica |
|---|---|---|
static_cast | conversões razoáveis: número ↔ número, descer na hierarquia sem checar… | compile-time |
dynamic_cast | desce na hierarquia | runtime (exige virtual) |
const_cast | remove const | nada — escrever é UB |
reinterpret_cast | reinterpreta os bits | nada |
7.5 de perto
dynamic_cast confere; const_cast confia
sem virtual: error: cannot ‘dynamic_cast’ … (source type is not polymorphic)
char* mas só lê. Ler é ok; escrever num objeto que nasceu const é UB7.5 [expr.cast]/4
(T)x tenta cinco casts, em ordem, e não conta qual
7.6 demo_expressoes.hpp operadores de tipo
Perguntas que o compilador responde
N15demo_expressoes8AlinhadoE
$ c++filt -t N15demo_expressoes8AlinhadoE
demo_expressoes::Alinhado
sizeof, decltype e noexcept(e): compile-time, operando não avaliado (alignof só aceita um tipo). typeid de um polimórfico: runtime.
7.6 as duas armadilhas
sizeof não executa — e o array decai
warning: ‘sizeof’ on array function parameter ‘a’ will return size of ‘int*’ [-Wsizeof-array-argument]
std::size(arr) ou passe um std::span<int> — o tamanho viaja junto.7.6 alignof e padding
A ordem dos membros muda o sizeof
7.7 demo_expressoes.hpp new e delete
Cada new pede o seu delete — o par certo
-Wall o GCC avisa (-Wmismatched-new-delete); o ASan acusa alloc-dealloc-mismatch.7.7 por que você não vai usar new
new cru + exceção = vazamento
quiz · 1 de 3
Prevendo o compilador
int a = -1; unsigned b = 1;
quanto vale a < b?
- true
- false
- não compila
- UB
a é convertido para unsigned: vira 4294967295. O -Wall avisa (-Wsign-compare).Quanto vale 1 << 2 + 3?
- 7
- 32
- 20
- 6
+ (nível 6) vence << (nível 7): 1 << 5 = 32.quiz · 2 de 3
Categorias e operandos não avaliados
Qual destas expressões é um lvalue?
std::move(x)x + 1"abc"42
std::move(x) é xvalue; os outros, prvalues.std::size_t n = sizeof(f());
quantas vezes f roda?
- 1
- 0
- só em debug
- não compila
sizeof não avalia o operando: só olha o tipo de retorno. Medido: zero chamadas.quiz · 3 de 3
O par trocado
int* a = new int[5]{}; … delete a;
- libera os 5 ints normalmente
- libera só o primeiro int
- comportamento indefinido
- erro de compilação
new[] exige delete[]: misturar é UB. Compila (sem flags, calado; com -Wall, aviso -Wmismatched-new-delete); o ASan acusa alloc-dealloc-mismatch.std::vector<int> a(5);ou
auto a = std::make_unique<int[]>(5);Quem não escreve new não erra o par.
resumo do capítulo
O que fica das expressões
- Expressão tem tipo e categoria; a atribuição também é expressão —
if (x = 5)compila. - Divisão inteira trunca para zero;
&&/||fazem curto‑circuito,&/|não. - Prefira
++it: o pós-incremento copia o antigo. - Precedência dá a forma da árvore, não a ordem de avaliação. Na dúvida: parênteses.
- Se tem nome, é lvalue — mesmo declarado
T&&.std::movegera um xvalue. intcomunsignedviraunsigned:-1 < 1ué false. Usestd::cmp_less.{}barra o narrowing; os casts nomeados dizem a intenção — o cast C esconde.sizeofnão avalia; membros do maior para o menor; nada denewcru.
Capítulo 8 · demo_generico.hpp
Código genérico e o caminho do erro
Duas construções que mudam a forma do código: o compilador escreve uma versão por tipo, e a função ganha uma segunda saída.
- 8.1 template de função
- 8.2 classe e CTAD
- 8.3 NTTP e padrões
- 8.4 especialização
- 8.5 variádicos e nomes dependentes
- 8.6 concepts
- 8.7 exceções
abertura demo_generico.hpp
Duas construções que mudam a forma
O compilador escreve uma versão por tipo, a partir de um molde.
A função ganha um segundo caminho de saída.
Aqui está a sintaxe. A semântica a fundo: src/templates/ src/concepts/ src/errors/
8.1 demo_generico.hpp
Uma função para qualquer T
maior(3, 7) → T = int.typename diz melhor o que é: qualquer tipo, não só classes.auto deduz o retorno de a + b: misturar(1, 2.5) = 3.5.8.1 dedução e instanciação
O molde e as instâncias
8.1 ⚠ a armadilha
maior(3, 7.5) não compila
maior<double>(3, 7.5)
Nada a deduzir; o 3 vira 3.0.
maior(3.0, 7.5)
Os dois argumentos propõem double.
misturar(3, 7.5)
A = int, B = double → 10.5.
8.1 por dentro do arquivo objeto
Nada existe até alguém chamar
maior<double>(3, 7.5) reaproveitou a de double.maior<int> leva uma cópia; o linker fica com uma só (ODR).maior<int>. Por isso o corpo do template mora no header.8.1 saída real
O que o programa imprime
banana: para std::string,>compara char a char (ordem lexicográfica): "banana" vem depois de "abacaxi".7.5com<double>: o 3 virou 3.0 por conversão comum, porque T já estava decidido.ab: A = std::string, B = const char*; o+de string concatena.
8.2 demo_generico.hpp
Pilha<T>: o tipo vira parâmetro
8.2 CTAD · C++17
CTAD: o compilador deduz os <…>
8.2 deduction guide
O guia de dedução
Dupla d{42, "resposta"s}; | sem o guia | com o guia |
|---|---|---|
| -std=c++17 | deduction failed | Dupla<int, string> |
| -std=c++20 | dedução de agregado | Dupla<int, string> |
NomeDoTemplate(params) -> Tipo<…>; — "quando construírem assim, o tipo é este".std::make_pair(1, 2.0) → std::pair p{1, 2.0}; (idem make_tuple).8.3 demo_generico.hpp
Um valor como parâmetro de template
8.3 argumentos padrão de template
Vetor<> é Vetor<int, 4>
Vetor<>
Vetor<double, 3>
| onde | Vetor sem <> |
|---|---|
Vetor v; | CTAD usa os padrões |
struct P { Vetor v; }; | membroinvalid use of template-name ‘Vetor’ without an argument list |
void f(Vetor v); | parâmetromissing template argument list after ‘Vetor’; … |
using V = Vetor; | alias‘auto’ not allowed in alias declaration |
std::vector<Vetor> | argumentotype/value mismatch at argument 1 … |
Mensagens reais do GCC 13.3 (-std=c++20), resumidas: cada contexto reclama de um jeito. Na dúvida, escreva <>.
8.4 demo_generico.hpp
Especialização total e parcial
template <> + argumentos concretos. Não sobra nada livre.nome() chama NomeDoTipo<T>::nome(): o compilador instancia a cadeia inteira.8.4 qual especialização casa?
Vence a mais especializada que casa
8.4 ⚠ só classes e variáveis
Função não aceita especialização parcial
8.5 demo_generico.hpp
Pacotes, variáveis e apelidos
C++11 variádico
C++14 de variável
C++11 de alias
std::is_same_v<A, B> substituiu std::is_same<A, B>::value: um template de variável por cima do de classe.8.5 nomes dependentes
Avisando o parser: typename e template
Tipo ou valor?
T::value_type × p: um VALOR vezes uma variável que não existe.
error: ‘p’ was not declared in this scope (já ao ler o template). Ao instanciar: error: dependent-name ‘T::value_type’ is parsed as a non-type, but instantiation yields a type · note: say ‘typename T::value_type’ if a type is meant
Template ou menor-que?
p.convertida < double: comparação com um tipo.
warning: expected ‘template’ keyword before dependent template name [-Wmissing-template-keyword] · error: expected primary-expression before ‘double’
8.5 demo_generico.hpp
O typename do demo e o que o C++20 afrouxou
sem typename, em… | C++17 | C++20 |
|---|---|---|
| tipo de retorno (o demo) | erro | ok |
using X = T::value_type; | erro | ok |
| membro de classe | erro | ok |
| variável no corpo | erro | erro |
| parâmetro de função livre | erro | erro |
GCC 13.3: need ‘typename’ before ‘T::value_type’ because ‘T’ is a dependent scope. No parâmetro, void h(T::value_type);, é pior: variable or field ‘h’ declared void (o parser leu uma variável).
typename é sempre correto, em qualquer versão. O C++20 só o dispensa onde nada além de um tipo caberia.8.6 demo_generico.hpp
Um concept é um predicado sobre tipos
- Um nome para um conjunto de exigências: vale
trueoufalsepor tipo. - Parâmetros de mentira: nada roda, só se pergunta se compila.
- A expressão
a + btem de ser válida… - …e o resultado tem de converter para T.
| T | Somavel<T> |
|---|---|
int, double | true |
std::string | true |
char | true · char+char é int |
const char* | false |
std::vector<int> | false |
8.6 requires · C++20
Quatro formas da mesma restrição
8.6 soma(x, y) com dois std::vector · GCC 13.3
O ganho real: a mensagem de erro
o erro aponta para DENTRO de soma + 14 candidatos de operator+
o erro aponta para a CHAMADA e diz qual exigência falhou
8.7 demo_generico.hpp
throw sai, catch recebe
throwabandona a função na hora: oreturnnão roda.- Os
catchsão testados de cima para baixo; o primeiro compatível ganha. - Compatível = mesmo tipo ou uma classe base pública (e não ambígua) dele.
8.7 stack unwinding
O destrutor roda antes do catch
8.7 <stdexcept> e afins
A hierarquia: qual catch pega?
8.7 relançar
catch (...) e throw;
relançar × lançar uma cópia
Dentro de catch (const std::exception& e), throw e; lança uma cópia do tipo estático: a exceção chega fatiada.
8.7 regra prática
Lance por valor, capture por const&
o objeto lançado: std::invalid_argument
a cópia em catch (std::exception e)
O resto foi fatiado: what() perde a mensagem.
O GCC avisa com -Wall: catching polymorphic type ‘class std::exception’ by value [-Wcatch-value=]
8.7 std::terminate
Quando não há segunda chance
ruim.cpp: ‘throw’ will always call ‘terminate’ [-Wterminate] · in C++11 destructors default to ‘noexcept’.p = new int[100]; usar(p); delete[] p; — se usar lançar, o delete não roda. Use std::vector ou make_unique.quiz · 1 de 3
Compila? Mesmo tipo?
Com template <typename T> T maior(T, T), o que faz maior(3, 7.5)?
- Compila: T = double
- Compila: T = int, trunca 7.5
- Não compila
- Compila com aviso
BufferFixo<int, 8> e BufferFixo<int, 16> são o mesmo tipo? (std::is_same_v)
- true
- false
quiz · 2 de 3
Especialização e catch
Os primários de X, f e e existem. Qual linha não compila?
template <> struct X<int> {};template <class T> struct X<T*> {};template <class T> void f<T*>(T*) {}template <class T> bool e<T*> = 1;
if constexpr ou concepts.catch (const std::exception&) vem antes de catch (const std::invalid_argument&). dividir(1, 0) cai em…
- invalid_argument: o mais específico
- std::exception: o primeiro que casa
- nos dois, em sequência
- erro de compilação
-Wexceptions.quiz · 3 de 3
Quando roda ~Sentinela()?
O destrutor de s…
- nunca roda: o throw pula o fim da função
- roda depois do catch
- roda antes do catch, no stack unwinding
- só no fim do programa
resumo do capítulo
O que fica
- Template é molde: uma instância por combinação de tipos usada. O corpo mora no header.
- A dedução não faz int → double:
maior(3, 7.5)não compila. Diga o T ou use dois parâmetros. - CTAD (C++17) deduz os
<…>de classes; o deduction guide ensina casos novos. - NTTP: o valor faz parte do tipo,
BufferFixo<int,8>≠BufferFixo<int,16>. - Especialização parcial: só classe e variável. Função usa sobrecarga,
if constexprou concepts. typenameetemplatedizem ao parser o que é um nome dependente.- Concepts põem o contrato na interface: o erro sai na chamada (17 × 106 linhas).
- catch do específico ao geral; destrutores rodam no unwinding. Lance por valor, capture por
const&.
src/templates/ src/concepts/ src/errors/ src/compile_time/ src/vocabulary_types/
Encerramento · src/syntax
O escopo fecha
No }, os destrutores põem tudo em ordem. Aqui: o que fica, como conferir — e para onde ir.
- a aula em 9 frases
- 17 regras de ouro
- como validar
- referências
- próximos passos
resumo um capítulo, uma frase
A aula em 9 frases
- 0
#includecola texto; função ou variável não-inlinetem uma definição no programa (ODR). - 1Inicialize sempre, com
{}: barra o narrowing e zera o que não tem valor. - 2
ifeswitchcom init prendem o nome no escopo;if constexprdescarta o galho. - 3
const T¶ ler,Tpara o barato; a sobrecarga se resolve ao compilar. - 4
enum classnão converte nem vaza nomes; 20 num bitfield de 4 bits vira 4. - 5A lista de inicialização constrói; Regra do 0: deixe as 5 operações ao compilador.
- 6Namespace anônimo para o que é local; macro só quando a linguagem não resolve.
- 7
intcomunsignedviraunsigned; use os 4 casts nomeados, nunca(T)x. - 8Templates geram código por tipo; concepts dão nome às exigências;
throwdesempilha.
regras de ouro 1/2 · declarar · controlar · funções
Situação → faça
01declarar
1.2Declarando variável
Inicialize sempre, de preferência com {}
1.7Declaração ilegível: int (*f[3])(int)
Dê nome com using
02controlar
2.1if, for, while de uma linha
Use chaves mesmo assim
2.1Valor usado só dentro do if
if (auto x = f(); cond)
2.3switch sobre enum class
Sem default: deixe o compilador avisar
2.3Queda intencional no switch
[[fallthrough]]
03funções
3.2Parâmetro que você só lê
const T& (ou T, se for barato)
3.6 · 6.3Retorno que não pode ser ignorado
[[nodiscard]]
regras de ouro 2/2 · classes · organização · memória e build
Situação → faça
05classes
5.1Construtor de um argumento
explicit, salvo se a conversão for desejada
5.5Classe com método virtual
Destrutor virtual
5.5Sobrescrevendo um virtual
override, sempre
5.1Membro que muda em método const
mutable — cache, mutex; nunca estado lógico
06organização
6.1Símbolo só desta .cpp
Namespace anônimo, não static
6.2Constante global
constexpr / inline constexpr, nunca #define
6.2Escrevendo uma macro
Pergunte-se qual construção da linguagem resolve
07memória e build
7.7Alocando memória
make_unique / container — não new cru
0.8Compilando qualquer coisa
-Wall -Wextra -Wpedantic no mínimo
como validar 1 · rodar o programa instalado
Rodar e conferir a saída
- 8 blocos, cada um com o cabeçalho em turquesa
- os trechos reais que o README cita
- a última linha, em verde-lima
como validar 2 · todos os avisos · 3 · sanitizers
Três portões, zero achados
como validar o detalhe · demo_tipos.hpp
Zero avisos — e um #pragma com motivo
5x0). Todo o resto compila limpo, no C++20 padrão da raiz, sem override_options.referências README · Referências
Onde continuar lendo
neste repositório
bit_cast, a ordem do cast Csizeof, padding, trivial medidosexpected, error_codefontes canônicas
Declarations · Statements · Expressions · Value categories · CTAD
ES.20 sempre inicialize · ES.23 prefira {} · ES.45 nada de constantes mágicas · NR as "não-regras"
[expr.cast]/4 a ordem do cast C · [basic.def.odr] a ODR · [basic.lval] categorias de valor · [class.bit] bitfields
A Tour of C++, Bjarne Stroustrup — a visão geral da linguagem em ~200 páginas.
próximos passos a trilha do src/meson.build
O syntax é o mapa; estes são os territórios
$ ./dist/bin/syntax … 1.088 linhas depois …
✓ Todos os demos de sintaxe concluídos!
Perguntas?
cpp_academy · src/syntax · make open PROJ=syntax