Feito por Lucas Lima

cpp_academy · src/syntax · C++20

Sintaxe C++

a sintaxe padrão da linguagem, de ponta a ponta

8blocosum por demo — e por capítulo
1.090linhasde saída colorida
0avisos-Wall -Wextra -Wpedantic
0achadosASan + UBSan

aquecimento antes de qualquer regra

Uma linha, uma pegadinha

Dentro do main, o que Widget w(); declara?

  1. um Widget criado pelo construtor padrão
  2. uma função w, sem parâmetros, que devolve Widget
  3. um ponteiro para Widget
  4. nada — não compila
É o most vexing parse: o que pode ser lido como declaração de função, é. O GCC 13 avisa (-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

Cap. 1 · 1.2

por que QUADRADO_ERRADO(1+2) vale 5

Cap. 6 · 6.2

por que -1 < 1u é false

Cap. 7 · 7.4

o que roda entre o throw e o catch

Cap. 8 · 8.7

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

src/syntaxo mapa 13 subprojetos em volta
casts/7.5

static_cast<T>(x) e os outros três casts

value_semantics/7.3 · 5.6

lvalue vs rvalue, Regra do 0/3/5

vocabulary_types/4.4

union → std::variant

templates/8.1–8.5

template <typename T>, especialização, NTTP

concepts/8.6

concept, requires

compile_time/1.4 · 6.5

constexpr, static_assert

oop/5.5

virtual, override, final, classe abstrata

smart-pointers/memory/7.7

new / delete e o que os substitui

errors/8.7

try / throw / catch, a hierarquia padrão

lambdas/3.8

capturas de lambda, std::function

layout/4.7 · 7.6

padding, alignof, o custo de virtual em bytes

linkage/6.4

linkage, ODR e o linker por dentro

rodar da raiz do repositório

Configurar, compilar, rodar

  1. make configuresó na 1ª vez: Conan + meson setup em ./build
  2. make buildcompila: meson compile -C build
  3. make installcopia os binários para ./dist/bin
  4. ./dist/bin/syntaxou make run — BIN=syntax é o padrão
Esta aulamake 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

58linhas no main.cpp
70.439linhas na TU (g++ -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

main.cpp:24C++
linhas por bloco
  1. 1Declarações171
  2. 2Controle de fluxo131
  3. 3Funções140
  4. 4Tipos do usuário107
  5. 5Classes107
  6. 6Organização127
  7. 7Expressões176
  8. 8Genérico e erros128
1.090linhas no total

✓ 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

andar
→espaçoavança: próximo passo ou slide
←PgUpvolta um passo
⇧ →⇧ ←pula o slide inteiro
HomeEndprimeiro / último slide
achar
Osumário, com busca em todo o conteúdo
12Entervai direto ao slide 12
Escfecha o que está aberto; sem nada aberto, abre o sumário
apresentar
Nnotas do apresentador + cronômetro
Pjanela do apresentador (2ª tela)
Lponteiro laser
Btela preta (pausa)
Ftela cheia
estudar
Ttema claro / escuro
Rrefaz os passos do slide
?todos os atalhos
CtrlPPDF com todos os passos visíveis
cliquewidgets, quizzes e cartas respondem

última tecla—

00

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

① pré-processador · g++ -E

Só texto: o header foi colado e VEZES virou 3. Isto é a TU. (A linha em branco é o que sobrou do #pragma once.)

② compilador · g++ -c

Um .o por TU. U = usado aqui, definido fora: o buraco. T = código definido aqui.

③ linker · g++ *.o

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

Por isso existem os headers pré-compilados (PCH) e os módulos do C++20 (import): para não reprocessar o mesmo texto em cada TU.

0.2 #pragma once

O mesmo header, duas vezes na mesma TU

main.cpp forma.hpp reta.hpp ponto.hpp #include colado 2×

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 existedefinição · fornece corpo / memória
funçãoint dobro(int x);int dobro(int x) { return x * 2; }
variávelextern int total;int total = 0;
tipostruct Motor;struct Motor { int cv; };
g++

O compilador cobra a declaração

Para checar a chamada, basta saber que dobro existe e o tipo dos parâmetros e do retorno.

ld

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

Não é “valor aleatório”É ausência total de contrato: o padrão não diz nada. Pode funcionar, travar — ou piorar depois de otimizado.
O raciocínio do -O2int não estoura ⇒ dobrar um positivo dá positivo ⇒ i > 0 é sempre verdade ⇒ laço infinito. O printf sumiu.
Como enxergar-fsanitize=un⁠defined acusa na hora: signed integer overflow. Com -Wall -Wextra: nenhum aviso.

src/undefined_behavior/

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

0

avisos com -Wall -Wextra -Wpedantic -Wshadow -Wconversion

0

achados com -fsanitize=address,un⁠defined — nem vazamento

0

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

fato 1

main sem return?

O programa termina sem return em main. Compila? O que o shell recebe?

?
resposta

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.

fato 2

#include importa?

#include <fmt/core.h> traz uma biblioteca já compilada para dentro do programa?

?
resposta

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.

18linhas
→
58.226na TU
fato 3

Quando o objeto morre?

Saudacao{"mundo"}.falar(); — sem nome, sem new, sem delete.

?
resposta

É 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?

  1. importa um módulo já compilado
  2. cola o texto do arquivo no lugar da linha
  3. diz ao linker onde está a definição
  4. cria um namespace com o nome do arquivo
Trabalho do pré-processador, e é só texto: o resultado é a TU. Por isso 18 linhas viraram 58.226.

Ninguém define dobro. E agora?

  1. erro de compilação em main
  2. compila; o linker falha
  3. roda e devolve lixo
  4. o linker cria uma dobro vazia
A declaração satisfaz o compilador; quem cobra a definição é o linker: un⁠defined reference to `dobro(int)'.

quiz · capítulo 0

UB e avisos

O que melhor descreve UB?

  1. o programa produz um valor aleatório
  2. o padrão não define nada: pode funcionar, travar ou mudar com -O2
  3. um erro de compilação adiado para a execução
  4. um comportamento que o compilador escolhe e documenta
“Valor aleatório” ainda seria um contrato. UB é ausência de contrato: o mesmo laço deu 31 voltas em -O0 e virou jmp infinito em -O2. (A opção D é o implementation-defined.)

Que flag acusa este case sem break?

  1. nenhuma: já avisa
  2. -Wall
  3. -Wextra
  4. -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

  • #include cola 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. inline repete 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 -O2 pode reescrever o programa.
  • Os avisos que importam não vêm ligados — o mínimo civilizado:
    -Wall -Wextra -Wpedantic -Wshadow -Wconversion
01

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

static constespecificadoresstorage · cv
int* pdeclaradortipo + nome
= &xinicializadorcomo nasce
;
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

pergunta à turma

Quantos ponteiros int* a, b; declara?

⚠ rigor · um só

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);
  1. f f é — comece no nome
  2. [3] → array de 3
  3. * ← ponteiros para — o ) bloqueou
  4. (int) → função(int) que devolve
  5. int ← int
Regra de ouro Declaração ilegível? Dê nome às partes com 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>

Três tiposchar, 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: =, sem explicit
  • direct: ( ), até explicit
  • list: proíbe narrowing
  • copy-list: = {}, sem explicit
  • value: {} vazio → zero garantido
  • default: depende de onde ⚠
Por que {} 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

GCC 13 Com variável, o narrowing em {} sai como warning (o padrão diz "mal-formado"). Compile com -Werror=narrowing ou -pedantic-errors.
com chavesresultadopor quê
int x{3.0};erroflutuante → inteiro: sempre estreita
char c{65};okconstante que cabe
char c{300};erro300 não cabe em char
unsigned u{-1};erronegativo não cabe
double d{3};ok3 é exato em double
char c{i};warningi não é constante

1.2 a exceção que dói

( ) × { } num container

std::vector<int> a(3, 0); →
0
0
0
3 elementos iguais a 0
std::vector<int> b{3, 0}; →
3
0
2 elementos: 3 e 0 ⚠
std::vector<int> c(3);→
0
0
0
std::vector<int> d{3};→
3
Por quê Com { }, 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

a regra

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

Onde mordeCom retorno 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

const

"não posso modificar"

  • ✓ valor pode vir de runtime
  • ✗ nunca muda
  • · vindo de runtime, não serve em static_assert
constexpr

"o compilador já sabe"

  • ✓ usável em static_assert e NTTP
  • ✗ nunca muda (implica const)
  • ⚠ o inicializador tem de ser constante
constinit C++20

"nasce pronto, mas muda"

  • ✓ init garantida em compile-time
  • ✓ muda depois, à vontade
  • ⚠ só static / thread_local
Detalhe herdado do C++98const 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

① antes de tudo

inicialização estática: zero e constantes — constinit garante estar aqui

→
② depois

inicialização dinâmica: entre .cpp diferentes, a ordem não é especificada

→
③ por fim

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

✓ para que serve

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.

✗ para que NÃO serve

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

Magic static (C++11) Um inicializador não-constante roda na 1ª passagem, protegido contra threads — o GCC gera __cxa_guard_acquire.

1.5 storage class

Quanto tempo vive, onde é visível

formaexemplovive quandovisível onde
automáticoint x; no blocoescopo do blocobloco
static (local)static int n;programa inteirobloco
static (global)static int g;programa inteirosó esta .cpp
externextern int g;programa inteirotodo o programa
thread_localthread_local int t;vida da threadconforme declarado
Três sentidosstatic em função = duração; fora = linkage interna; em classe = um por classe (cap. 5). Para "só desta .cpp", prefira namespace { }.
extern declara sem definir: a definição mora em uma .cpp (ODR). src/linkage/

1.6 demo_variaveis.hpp:289

Ponteiro × referência: o mesmo objeto

1.6 nullptr

Nulo tem tipo: nullptr

aspectoponteiroreferência
pode ser nulosim (nullptr)não
reapontávelsimnão (liga uma vez)
precisa de *simnão
aritméticasimnão
UB Desreferenciar 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

typedef não vira templateerror: template declaration of ‘typedef’

1.8 demo_variaveis.hpp:371

052 não é 52

1.8 sufixos e strings

O sufixo decide o tipo

literaltipobytes
42uunsigned4
42Llong8
42LLlong long8
3.14ffloat4
3.14double8
3.14Llong double16

bytes: saída real (42u → unsigned (4B)…)

Sem sufixo Decimal: o primeiro de 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

Regras Nomes = membros, exatamente: only 2 names provided for structured binding. Membros acessíveis: cannot decompose inaccessible member.

quiz · 1 de 3

Teste: o que foi declarado?

O que Widget w(); declara?

  1. um Widget inicializado com valor
  2. um Widget com lixo
  3. uma função que devolve Widget
  4. nada: não compila
Most vexing parse: se pode ser declaração de função, é. Variável: Widget w{};

Quanto vale int x = 052;?

  1. 52
  2. 42
  3. 82
  4. não compila
Zero à esquerda = octal: 5×8 + 2 = 42. E 08 é erro: invalid digit "8".

quiz · 2 de 3

Teste: tipos e chaves

Com int i = 0;, decltype((i)) é…

  1. int
  2. int&
  3. int&&
  4. const int&
(i) é uma expressão lvalue → int&. Sem os parênteses, decltype(i) = int.

std::vector<int> v{3, 0}; — v.size()?

  1. 3
  2. 2
  3. 0
  4. não compila
Com {}, 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:

  1. 20
  2. 5
  3. 8
  4. 4
O parâmetro 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) e Widget w(); é função.
  • auto descarta & e const de topo; decltype((x)) é T&.
  • const não muda · constexpr é compile-time · constinit nasce pronto e muda.
  • Escopo é do nome; tempo de vida, do objeto; static local nasce uma vez.
  • Array decai para ponteiro; referência não religa; 052 é octal.
02

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ó.

seleção · escolhe um caminho
if / elseswitch

dois caminhos por condição · N caminhos por valor

iteração · repete enquanto…
whiledo-whileforrange-for

testa antes · testa depois · conta · percorre

salto · abandona o caminho
breakcontinuereturngoto

sai 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:

  1. C++98for (int i = 0; …)i morre no fim do for
  2. C++98if (T* p = f())declaração na condição
  3. C++17if (init; cond)idem switch — init separado
  4. C++20for (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 else final é “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

e o else? a quem pertence?
ao if mais próximo — o de dentro

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.

Chaves sempreCusto zero. O -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

Só dentro de templateFora de template nada é descartado: if constexpr (false) { x.size(); } com int x ainda é erro.
Um constexpr por else ifSem ele, aquele 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

#RegraSe violar — GCC 13
1A condição é integral ou enum — nada de string ou double.error: switch quantity not an integer
2Cada case: constante de compile-time e única.error: duplicate case valueerror: ‘limite’ is not a constant expression
3Sem break, o controle cai no próximo case. Queda intencional: [[fallthrough]].warning: this statement may fall through(-Wextra)
4Variável com inicialização num case exige { chaves }.error: jump to case labelnote: crosses initialization of ‘const char* motivo’
5Com 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

Rótulos coladosSem código entre eles, a queda é o agrupamento: não precisa de [[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

Quasecontinue no for ainda executa o inc. No while escrito à mão, ele pula o incremento → pode virar laço infinito.
  • Todas opcionais: for (;;) = condição true.
  • 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

break sai de UM nívelPara sair dos dois: uma flag, um return (extraindo a função) ou goto — próximo bloco, 2.6.

2.5 range-for

Por valor, const& ou &

cópia for (int x : v)
12345
copia →x = 3

Mexer em x não muda v. Bom para tipos baratos.

só leitura for (const auto& x : v)
12345
x é o próprio elementoconst · só lê

Sem cópia, sem escrita. O padrão para ler.

modifica for (auto& x : v) x *= 10;
110220330440550
x é o próprio elemento✎ escreve em v

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

⚠ UB · mexer no container

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.

⚠ UB · o temporário que morre

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.

src/stl/ — invalidação de iteradores

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

1 · não salta sobre uma inicialização
erro de compilação — não é UB

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.

2 · não sai da função
rótulos têm escopo de função

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.

3 · destrutores dos escopos abandonados rodam?
sim — o RAII continua valendo
4 · e o “goto cleanup;” do C?
em C++, o lugar dele é o RAII

2.7 ternário

?: é uma expressão — tem valor

Regra prática?: escolhe um valor; if/else escolhe uma ação. Ternário dentro de ternário vira enigma — aí prefira uma função.
GalhosTipo comum
c ? 1 : 2.5double — 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:

  1. um
  2. um dois
  3. um dois outro
  4. não compila
Sem break, o controle cai pelos rótulos até o fim do switch. Compila — o -Wextra avisaria.

E este laço?

  1. 3 2 1
  2. 2 1 0
  3. 2 1
  4. 3 2 1 0
O teste usa o valor antigo e decrementa antes do corpo: imprime 2 1 0 — e, ao sair, n vale −1.

quiz · 2 de 3

Quem roda, quem vale?

f() devolve 7. Quanto vale a?

  1. 7
  2. 42
  3. 49
  4. não compila
O operador vírgula avalia f() (o efeito acontece), descarta o 7 e devolve o último: 42.

Esta linha chama f()?

  1. Sim, sempre
  2. Não — garantido
  3. Depende da otimização
  4. Só em modo debug
Curto-circuito é regra, não otimização: com o primeiro operando falso, o segundo nunca é avaliado. (Com & seria.)

quiz · 3 de 3

Isto compila?

  1. Compila; total = lixo
  2. Compila; total = 0
  3. Não compila
  4. Compila, mas é UB
error: jump to label ‘fim’ … crosses initialization of ‘int total’ — o C++ proíbe o salto; não é UB, é erro.
Mesma regra, dois lugaresÉ a regra 4 do 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 if governa uma instrução (goto fail).
  • if (auto x = f(); cond) — o nome morre no fim do if/else.
  • if constexpr descarta o galho falso — só dentro de template.
  • switch = salto para rótulo: integral, case constante, sem break cai.
  • enum class sem default: o -Wswitch acha o caso esquecido.
  • range-for = begin/end + iterador — não insira nem remova elementos dentro dele.
  • break sai de um nível; prefira função + return ao goto.
  • ?: tem valor; &&/|| param cedo; a vírgula devolve o último.
03

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

Quem precisa de quêO compilador precisa da declaração; o linker, da definição.
declaração · .hpp

A promessa. Pode aparecer N vezes: quem inclui o header sabe chamar.

definição · .cpp

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?

FormaCopia?Modifica?Aceita nulo?Quando usar
Tsimnão (a cópia)nãotipos baratos, sink
T&nãosimnãosaída, in-out
const T&nãonãonãoleitura — o padrão
T*nãosimsimopcional, API C
T&&nãoconsomenãomove; se T for deduzido, forwarding
Regra práticaconst T& para ler · T para tipos pequenos (int, double, ponteiro) · T& só quando a saída é o objetivo.
sinkA função vai guardar o valor (um construtor, por exemplo): receba T por valor e faça std::move para dentro.

3.2 README · a origem de muita confusão

T&& tem dois significados

tipo concreto → referência a rvalue
error: cannot bind rvalue reference of type ‘std::string&&’ to lvalue of type ‘std::string’
T deduzido → forwarding reference

Aceita tudo e guarda em T se veio lvalue ou rvalue; std::forward<T>(x) repassa preservando isso.

o cast que não movestd::move(e) é só um cast para rvalue. Quem move é o construtor de movimento — no demo, std::string roubado = std::move(s);.
Depois do moveO objeto fica válido, mas não especificado: destrua ou atribua de novo. Não conte com string vazia.

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

1 · direita → esquerda

Depois do primeiro padrão, todos à direita precisam de um.

error: default argument missing for parameter 2 of ‘void h(int, int)’
2 · só na declaração

O padrão pertence à declaração; repeti-lo na definição é erro.

error: default argument given for parameter 2 of ‘int f(int, int)’
3 · resolvido no chamador

O valor é colado em cada chamada. Não há named args: não dá para pular o 2º.

ConsequênciaMudou o padrão no .hpp? Recompile quem chama.
Sem argumentos nomeadosQuer só a largura? 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

Regra do demoNão use padrão em função virtual. Precisa de um? Ponha-o numa função não-virtual que chama a virtual.

3.4 demo_funcoes.hpp:135

Mesmo nome, seis funções

Quem escolheO compilador, olhando só os argumentos: quantos são e de que tipo.
E estes?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

error: ambiguating new declaration of ‘bool f(int)’
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
nomesimf × g
tipos dos parâmetrossimf(int) × f(double)
const / & do métodosimget() × get() const
tipo de retornonãoint f(int) = bool f(int)
nomes dos parâmetrosnãof(int a) = f(int x)
const de toponãof(int) = f(const int)
argumento padrãonãof(int = 1) = f(int)
noexcept, atributosnãonão criam sobrecarga

3.5 demo_funcoes.hpp:171

Retorno no fim — ou deduzido

Por que no fim?Escrito na frente, decltype(a + b) ainda não conhece a e b:
error: ‘a’ was not declared in this scope
Deduzidoreturn 1; e return 2.0; juntos:
error: inconsistent deduction for auto return type: ‘int’ and then ‘double’

3.5 demo_funcoes.hpp:179 · structured bindings

Vários valores, com nome

o jeito antigo

parâmetros de saída: int& q, int& r

hoje

auto [q, r] = divmod(17, 5);

✗ tuple

std::get<2>(t) — o que era o 2?

✓ struct

e.media — o nome diz

3.5 ⚠ dangling · programa real

Nunca devolva referência para local

ao compilar (sem flags):warning: reference to local variable ‘x’ returned [-Wreturn-local-addr]
O que o g++ 13.3 fazf() 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

✓ prvalue · garantida (C++17)

return T{}; constrói o objeto direto no destino: nem desligando a elisão aparece cópia ou move.

⚠ NRVO · permitida, não garantida

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

mitoinline

“expanda o corpo no lugar da chamada”

verdadeinline

pode ter definição repetida (idêntica) em várias TUs. Expandir é decisão do otimizador — a palavra é só uma sugestão.

mitoconstexpr

“sempre roda em compile-time”

verdadeconstexpr

pode rodar em compile-time, se os argumentos forem constantes; senão, é chamada normal. consteval obriga.

mitonoexcept

“o compilador garante que não lança”

verdadenoexcept

é uma promessa. Uma exceção tentou sair dela? std::terminate — nenhum catch de fora pega.

mito[[nodiscard]]

“proíbe ignorar o retorno”

verdade[[nodiscard]]

só avisa (warning). Vira erro com -Werror.

mitostatic (escopo de arquivo)

“função que guarda estado”

verdadestatic

linkage interna: o nome some fora desta .cpp. O README prefere namespace anônimo.

mito[[deprecated]]

“remove a função”

verdade[[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

Moralinline 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

warning: ‘throw’ will always call ‘terminate’ [-Wterminate]
O catch nunca rodaA exceção não pode sair de uma função 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

✗ C · <cstdarg>
✓ C++ · parameter pack + fold
tiposC: nenhum — va_arg acredita no que você diz. C++: cada argumento tem o seu.
contagemC: manual. C++: sizeof...(args), em compile-time.
o erro apareceC: UB em runtime — 0 avisos com -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→ (*op)→ (int, int)→ int

“op é um ponteiro para função que recebe (int, int) e devolve int.”

Regra de ouroDeclaração ilegível? Dê nome: 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

Saída realfib_recursivo(20) = 6765 — e fib_iterativo(20) também.

3.9 demo_funcoes.hpp:357

Caso base e recursão mútua

Sem caso baseA recursão não para. Com -Wall, o GCC até avisa — warning: infinite recursion detected [-Winfinite-recursion] — e o programa estoura a pilha.
sem a 1ª linha:error: ‘eh_impar’ was not declared in this scope; did you mean ‘eh_par’?

3.9 pilha · tail call · programa real

A pilha é finita — e TCO não é garantida

O que mudou?Com -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);

  1. duas sobrecargas válidas
  2. erro de compilação
  3. compila; a chamada escolhe pelo retorno
  4. só um warning
O retorno não entra na assinatura. GCC: ambiguating new declaration of ‘bool f(int)’.

Com as 6 sobrecargas do demo, tipo_de('a') chama…

  1. tipo_de(int)
  2. tipo_de(double)
  3. tipo_de(bool)
  4. 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?

  1. sim
  2. não: o padrão vai só na declaração
  3. sim, e o padrão da definição vence
GCC: default argument given for parameter 2 of ‘int f(int, int)’. Na definição: 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?

  1. o catch captura normalmente
  2. std::terminate: o programa aborta
  3. a exceção é ignorada
  4. comportamento indefinido
É bem definido: a exceção não pode sair de uma função 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)?

  1. 5
  2. 9
  3. 15
  4. 32
f(5) 1× · f(4) 1× · f(3) 2× · f(2) 3× · f(1) 5× · f(0) 3× = 15 (contado com um contador no programa). Em geral, 2·fib(n+1) − 1.
DicaDesenhe a árvore: cada nó é uma chamada; as folhas são 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, se T for 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.
  • constexpr pode, noexcept promete, [[nodiscard]] avisa.
  • Variádicas: parameter pack + fold, não va_list.
  • Ponteiro cru não guarda estado; std::function guarda qualquer chamável.
  • Recursão: caso base, pilha finita, TCO não garantida.
04

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

struct

dados agrupados — membros públicos por padrão

struct Ponto { int x, y; };
class

o mesmo — mas membros privados por padrão

class Conta { double saldo; };
enum

um conjunto fechado de valores com nome

enum class Cor { Vermelho, Verde, Azul };
union

vários membros no mesmo espaço — um de cada vez

union Valor { int32_t i; float f; };
Spoiler da 4.1struct 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

struct · agregado de dados

Tudo público, sem invariante a proteger.

class · estado 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}
10
20
r2{}
0
0
r3{5}
5
0
Retangulo r;
??
??
UB ao ler
warning: missing initializer for member ‘Retangulo::altura’ [-Wmissing-field-initializers]

↑ 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

formaC (C99/C11)C++20o que o GCC 13 diz no C++
{.tls = true, .porta = 443}qualquer ordemsó na ordemdesignator order for field ‘Config::porta’ does not match declaration order in ‘Config’
{"api", .porta = 443}misturartudo ou nadaeither all initializer clauses should be designated or none of them should be
{.a.x = 1}aninhadouse .a = {.x = 1}expected primary-expression before ‘.’ token
{[2] = 7}índice de arraynão existeaceita 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

enumenum class C++11
escopovaza para foraexige Cor::Verde
converte p/ intsozinhosó com static_cast
tipo subjacenteimplementaçãovocê escolhe: : uint8_t
colisão de nomesaconteceimpossível
C++20 · using enumusing 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.
error: cannot convert ‘Cor’ to ‘int’ in initialization
error: could not convert ‘moderna’ from ‘Cor’ to ‘bool’

4.3 demo_tipos.hpp

Tipo subjacente: quanto o enum ocupa

CorAntiga c = Verde;
01
00
00
00

4 bytes · tipo escolhido pelo compilador

Cor m = Cor::Verde; // Cor : std::uint8_t
01

1 byte · tipo escolhido por você

E sem o :?enum class → int, garantido. Enum clássico → um inteiro em que os valores caibam, à escolha do compilador — no GCC 13, unsigned int.
error: use of enum ‘CorAntiga’ without previous declaration

4.3 demo_tipos.hpp

enum como flags: um bit por permissão

sem o operator|: error: no match for ‘operator|’ (operand types are ‘Permissao’ and ‘Permissao’)

4.4 demo_tipos.hpp

union: todos no mesmo endereço

4.4 demo_tipos.hpp C++17

Tagged union à mão × std::variant

4.5 demo_tipos.hpp

Bitfields: 32 bits com nome

4.5 saída real

Três avisos sobre bitfields

⚠ 1 · truncam

reg.codigo_erro = 20; guarda 4 — e só a constante gera aviso.

✗ 2 · não têm endereço

&reg.pronto e unsigned& r = reg.pronto; não compilam — daí o +reg.pronto (um int temporário).

error: attempt to take address of bit-field
error: cannot bind bit-field ‘reg.RegistradorStatus::pronto’ to ‘unsigned int&’
⚠ 3 · layout da implementação

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

Carro
RodasCambioPlaca

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

standard-layout ✓standard-layout ✗
trivial ✓trivial ✗

os dois → era o POD

trivial, mas mistura acessos nos dados

o construtor faz trabalho

nenhum dos dois

trivial autoriza

criar sem inicializar; copiar com memcpy (todo trivial é trivially copyable)

standard-layout autoriza

offsetof; interoperar com struct de C

POD · aposentado no C++20

= 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… →

O meio da tabelaComConstrutor não é trivial — o construtor põe 42 em a — e mesmo assim pode ir para memcpy.
A pergunta certaPara copiar bytes, o que importa é 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?

  1. 12
  2. 4
  3. 9
  4. 1
Todos começam no mesmo endereço: vale o maior membro — 4, não a soma.

O que fica guardado em codigo_erro?

  1. 20
  2. 15
  3. 4
  4. não compila
4 bits guardam 0..15: 20 = 1 0100₂ perde o bit de cima → 4. Valor de runtime: nem aviso.

quiz · 2 de 3

Compila?

Com o Config do demo (host, porta, tls, timeout):

  1. sim — a ordem não importa
  2. não — a ordem tem de seguir a declaração
  3. sim, mas host fica "localhost"
C++ ≠ C: a ordem tem de seguir a declaração — host vem antes de porta. O GCC 13:
error: designator order for field ‘Config::host’ does not match declaration order in ‘Config’

E esta?

  1. sim, x = 1
  2. sim, x = 0
  3. não — precisa de static_cast
enum class não vira int sozinho; com static_cast<int>, dá 1.
error: cannot convert ‘Cor’ to ‘int’ in initialization

quiz · 3 de 3

De onde vem o padrão?

Que herança é esta — e d.x = 1; compila?

  1. public — compila
  2. private — não compila
  3. depende de Base ser class: private
O padrão vem da palavra-chave da derivada: struct → public. Base ser class não importa.
pergunta aberta

Por que ComConstrutor pode ir para memcpy e ComVirtual não?

clique para virar

resposta

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

  • struct e class: 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_cast e std::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, pergunte is_trivially_copyable_v; POD aposentou.
05

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.

InvarianteA regra que vale para todo objeto — aqui, saldo ≥ 0. O construtor a estabelece; os métodos a preservam.

class: dado privado + métodos

g++‘double ContaBancaria::saldo_’ is private within this context

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

ContaBancaria

Dois construtores. Um deles só repassa o trabalho ao outro.

Avance: delegante → argumento padrão → lista → corpo.

Delegante · C++11ContaBancaria 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.

Argumento padrãob{"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).
Lista de inicializaçãoOs membros nascem com esses valores, na ordem em que foram declarados: titular_, saldo_, numero_. operacoes_ não está aqui: pega o = 0 escrito na classe.
CorpoQuando a { 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

g++conversion from ‘std::string’ to non-scalar type ‘ContaBancaria’ requested
g++could not convert ‘nome’ from ‘std::string’ to ‘ContaBancaria’
g++converting to ‘ContaBancaria’ from initializer list would use explicit constructor
Sem explicitas três linhas ✗ compilariam: uma std::string viraria uma conta bancária sem ninguém pedir.
e esta linha?

ContaBancaria e = "ana";

compila sem o explicit?

não — nem sem explicit

Seriam duas conversões do usuário em fila: const char* → std::string → ContaBancaria. O C++ faz no máximo uma, implícita.

Regra de ouroConstrutor de um argumento: explicit, salvo se a conversão for desejada.

5.1 métodos · const · mutable

Métodos: a invariante mora dentro

invariante

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.

const

Só métodos const podem ser chamados por um const ContaBancaria&. Lá dentro, this é const ContaBancaria*.

⚠ mutable

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

antes do C++17
ldun​defined reference to `ContaBancaria::abertas_' — se esquecer a definição

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

construçãoa e b: construtor explícito; padrao: delegante.
staticTrês objetos, um contador: #1, #2, #3.
friendauditar() leu três membros privados.
por que 2 → 3?depositar(50) já tinha contado 1 operação.
destrutoresNa }: 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

g++uninitialized const member in ‘const int’
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

g++use of deleted function ‘NaoCopiavel::NaoCopiavel(const NaoCopiavel&)’
= delete

Torna aquele uso um erro de compilação — com nome e linha. Vale para qualquer função, não só as especiais.

= default é o mesmo que { }?

T() = default;

T() {}

não

= 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.

chamadap/ intp/ doubleresultado
so_aceita_int(42)exataconversãoint → imprime so_aceita_int(42)
so_aceita_int(3.14)conversãoexatause of deleted function
so_aceita_int(3.14f)conversãopromoçãodeletada: float → double é promoção, vence
so_aceita_int('a')promoçãoconversãoint → imprime 97
so_aceita_int(42L)conversãoconversãoempate: call … is ambiguous
Para aceitar SÓ inttemplate <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

g++assignment of read-only location ‘(& cb)->Buffer::operator[](0)’
b[0]Buffer&int&lê e escreve
cb[0]const Buffer&const int&só lê
Sem o const no métodoele nem pode ser chamado por 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

Com a versão &&std::vector<int> vetor() && devolve por valor: o laço recebe o vetor inteiro → soma = 56
e para proibir

5.5 demo_classes.hpp

Herança e despacho dinâmico

quem responde?descrever() não é virtual, mas chama nome() e area(), que são: decide o tipo real do objeto, não o do ponteiro.
~Forma() virtualO 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

palavrasignificadose você errar (g++)
virtualpode ser substituída; despacho pelo tipo realesquecer: compila — e o tipo do ponteiro decide
= 0pura: a classe vira abstrata, não instanciávelForma f; cannot declare variable ‘f’ to be of abstract type ‘Forma’
override“estou substituindo” — o compilador conferedouble area() override ‘double Elipse::area()’ marked ‘override’, but does not override
finalninguém mais substitui (método) / herda (classe)class Cubo : public Quadrado cannot derive from ‘final’ base ‘Quadrado’ in derived type ‘Cubo’
Sem override, o erro somestd::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çapublic de B viraprotected de B viraB* p = &d fora
: public Bpublicprotectedcompila
: protected Bprotectedprotectednão
: private Bprivateprivatenã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.

g++‘B’ is an inaccessible base of ‘D1’
Omitir a palavraem class dá private; em struct, public. Escreva sempre.

5.5 ⚠ destrutor virtual

Base polimórfica sem destrutor virtual: UB

Regradestrutor virtual público — ou não-virtual protegido (aí delete p nem compila: ‘Base::~Base()’ is protected within this context).
-Walldeleting object of polymorphic class type ‘Base’ which has non-virtual destructor might cause un​defined behavior [-Wdelete-non-virtual-dtor]

Com virtual ~Base(): ~Derivada, depois ~Base — e a string é liberada.

5.6 as cinco operações especiais

As cinco operações especiais

#operaçãoassinatura
1destrutor~T()
2construtor de cópiaT(const T&)
3atribuição de cópiaT& operator=(const T&)
4construtor de moveT(T&&)
5atribuição de moveT& operator=(T&&)
  1. Regra dos 3 (C++98): precisou de uma, precisa das três
  2. Regra dos 5 (C++11): somou-se o move — declarar uma suprime outras
  3. 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

std::string32vector24shared_ptr16= 72
std::string32vector24u_ptr8= 64

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?

  1. Nada: o otimizador junta os dois passos
  2. Uma operação inteira: 1 em vez de 2
  3. Só faz diferença para membros int
  4. A chamada do destrutor do membro
No corpo o membro já nasceu (ctor(vazio)) e depois é atribuído (ATRIBUIÇÃO de fonte). Com : membro(r), só CÓPIA de fonte.

Quanto vale a_?

  1. 1
  2. 0
  3. Indeterminado — lê b_ antes de ele ser inicializado
  4. 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?

  1. compila: herança é public
  2. não compila
Em class, a herança padrão é private: ‘B’ is an inaccessible base of ‘D’. Com struct, compilaria.

Forma tem area() = 0. Qual linha compila?

  1. Forma f;
  2. Forma f{};
  3. auto p = std::make_unique<Forma>();
  4. Circulo c{2.0}; Forma& r = c;
Abstrata não vira objeto de jeito nenhum (C: invalid new‑expression of abstract class type) — mas referência e ponteiro para ela, sim: é assim que se usa.

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?

  1. Move: b rouba o buffer, a.nome fica vazio
  2. Copia: aloca outro buffer, a.nome fica intacto
  3. Não compila: o move não foi declarado
  4. Comportamento indefinido
Destrutor declarado → o move não é declarado; o rvalue cai na cópia, que ainda é gerada (deprecated). O move vira cópia em silêncio. Apague o ~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).
  • const e referência: inicialize, nunca atribua.
  • = delete vale 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.
Os ⚠ que compilam sem errolista fora da ordem (só o -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.
06

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

1 · o texto

Pré-processador

Cola #include, expande #define, apaga os galhos de #if falsos.

Não conhece escopo, tipo nem namespace.

6.2

2 · os nomes

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

3 · os símbolos

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 static global
  • 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 atual
  • biblioteca::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

✓ using-declaration — um nome
⚠ using-directive — todos

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

✓ compila no GCC 13

O iterador é uma classe — __normal_iterator<…, std::vector<int>> — e o argumento de template traz std para a busca.

✗ error: ‘sort’ was not declared in this scope

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ó -I e o sistema — com config.hpp nos dois lugares, "config.hpp" pegou o vizinho e <config.hpp>, o de include/
⚠ a guarda copiada e colada

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

macrosubstituto melhoro que se ganha
#define PI 3.14constexpr 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_ONconstexpr bool + if constexpro galho desligado continua compilando
ainda é macroo 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ê escreveo 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 = 0criou 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

desconhecido → aviso, não erro

[[inventado]] int a; compila (status 0); o g++ só avisa: ‘inventado’ attribute directive ignored [-Wattributes]

extensões de fornecedor

__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.

no demoinline int variavel_global_do_header = 100; — e o programa lembra: antes do C++17 isto exigia extern no .hpp + a definição num .cpp.
a.cpp main.cpp
contador_static2…a014
contador_static0…a01c
contador_inline · um só, para as duas TUs2…a018

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

⚠ o preço: sem sobrecarga

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
Para desligar um bloco use #if 0 … #endif: os #if se aninham, e um /* … */ lá dentro não atrapalha.
comentário — o quê ou o porquê?++i; // incrementa i
✗ o quê++i; // incrementa i

Repete o código. Quando o código mudar, vai mentir.

comentário — o quê ou o porquê?// a API devolve centavos: converter só na borda
✓ o porquê// a API devolve centavos: converter só na borda

Explica 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)?

  1. 9
  2. 5
  3. 3
  4. não compila
O texto colado é 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?

  1. externa: um objeto no programa
  2. interna: um objeto por TU
  3. nenhum: vira um literal
  4. 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__?

  1. troca os três
  2. troca __FILE__ e __LINE__; deixa __func__
  3. troca só __LINE__
  4. 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 1
  2. 2 1
  3. 2 2
  4. ambíguo
Os membros do 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::c e alias encurtam.
  • using de um nome; nunca using namespace global em header.
  • inline namespace: a versão nova, sem quebrar a antiga.
  • ADL procura nos namespaces dos argumentos.
  • #include cola texto; #pragma once cola 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, const global: internos.
  • ODR violada não avisa; extern "C" tira o mangling.
07

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

escrito assima + b
expressãoa + b

produz um valor: 7, um int (se a = 3 e b = 4)

escrito assima + b;
instruçãoa + b;

calcula e joga fora — GCC: statement has no effect

escrito assimx = 5
também expressão!x = 5

vale o próprio x: (x = 5) + 1 dá 6

escrito assimthrow erro
também expressãothrow erro

tipo void: cabe num ?:

Compila — e SEMPRE entrax = 5 é expressão: vale x, que vira bool; 5 é true.

7 · abertura tipo e categoria

Toda expressão responde a duas perguntas

1 · tipo

O que é o valor? int, double, std::string…

decide as operações e as conversões (7.4)

2 · categoria de valor

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ãotipocategoria
xintlvalue
x + 1intprvalue
'A' + 1int (não char!)prvalue
x = 5intlvalue é o próprio x
"abc"const char[4]lvalue (!)
std::move(x)intxvalue
São independentesx e x + 1: o mesmo tipo, categorias diferentes.

7.1 demo_expressoes.hpp aritméticos

Divisão inteira trunca — não arredonda

UBa % 0 e a / 0 com inteiros: comportamento indefinido.
Sempre vale(a/b)*b + a%b == a — também com negativos.

7.1 relacionais e lógicos

Curto-circuito: && e || param no meio

<=> · C++20

a <=> b devolve uma ordem (std::strong_ordering para int), que se compara com 0: (17 <=> 5) > 0 → true

O idiomaif (p && p->x > 0) só é seguro por causa do curto-circuito.
src/operators/

7.1 bit a bit

Bit a bit: coluna por coluna

Sem curto-circuito& e | avaliam os DOIS lados, sempre.
~ promoveCom 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.

src/bits/

7.1 atribuição composta

x op= y é x = x op y, com x avaliado uma vez

uma avaliação

v[idx()] += 1; → idx() roda 1 vez

duas avaliações

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 comparison
3 > 2 > 1comparisons like ‘X<=Y<=Z’ do not have their mathematical meaning
A regra práticaMisturou aritmética, bits, deslocamento ou comparação? Parênteses. Não custam nada.

7.2 ordem de avaliação

Precedência ≠ ordem de avaliação

expressãoquem roda primeiro
a && b a || b a , b a ? b : ca, sempre
a[b] a << b a >> b a->*ba (C++17)
a = b a += bb (C++17)
f(a, b)f; depois a e b em ordem livre
a + b a * b a == b …não especificado
E o clássicoi = 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

teste 1 · tem endereço?

&x ✓   &42 ✗   &(x+1) ✗

error: lvalue required as unary ‘&’ operand

teste 2 · vai à esquerda do =?

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

categoriaidentidade?saqueável?exemplos
lvaluesimnãox *p arr[0] f()→T&
xvaluesimsimstd::move(x) f()→T&&
prvaluenãosim42 x + 1 T{} f()→T
Os guarda-chuvasglvalue = lvalue ∪ xvalue (tem identidade) · rvalue = xvalue ∪ prvalue (pode ser saqueado).

"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/

glvalue · identidade rvalue · saqueável lvalue xvalue prvalue

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

escrito assimint t = 3.99;
int t = 3.99;3trunca para zero, não arredonda
escrito assimint t = -3.99;
int t = -3.99;−3para ZERO — não −4
escrito assimfloat f = 16'777'217;
float f = 16'777'217;16777216acima de 2²⁴ o float pula
escrito assimbool b = -5;
bool b = -5;truesó 0 é false
escrito assimunsigned u = -1;
unsigned u = -1;4294967295módulo 2³²
escrito assimshort s = 2'000'000'000;
short s = 2'000'000'000;−27648módulo 2¹⁶ (C++20) — o único que avisa: -Woverflow

error: 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

castfazverifica
static_castconversões razoáveis: número ↔ número, descer na hierarquia sem checar…compile-time
dynamic_castdesce na hierarquiaruntime (exige virtual)
const_castremove constnada — escrever é UB
reinterpret_castreinterpreta os bitsnada

7.5 de perto

dynamic_cast confere; const_cast confia

sem virtual: error: cannot ‘dynamic_cast’ … (source type is not polymorphic)

Para que serveChamar uma API antiga que pede char* mas só lê. Ler é ok; escrever num objeto que nasceu const é UB

7.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

o nome MANGLED, decifrado

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]

Usestd::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

new[] com deleteUB. Com -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?

  1. true
  2. false
  3. não compila
  4. UB
a é convertido para unsigned: vira 4294967295. O -Wall avisa (-Wsign-compare).

Quanto vale 1 << 2 + 3?

  1. 7
  2. 32
  3. 20
  4. 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?

  1. std::move(x)
  2. x + 1
  3. "abc"
  4. 42
O literal de string é um array estático, com endereço: lvalue. std::move(x) é xvalue; os outros, prvalues.

std::size_t n = sizeof(f());
quantas vezes f roda?

  1. 1
  2. 0
  3. só em debug
  4. 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;

  1. libera os 5 ints normalmente
  2. libera só o primeiro int
  3. comportamento indefinido
  4. 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.
Sem new, sem dúvidastd::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::move gera um xvalue.
  • int com unsigned vira unsigned: -1 < 1u é false. Use std::cmp_less.
  • {} barra o narrowing; os casts nomeados dizem a intenção — o cast C esconde.
  • sizeof não avalia; membros do maior para o menor; nada de new cru.
08

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

template <typename T> maior<T> molde T = int T = double T = string maior<int> maior<double> maior<string>

O compilador escreve uma versão por tipo, a partir de um molde.

try · throw · catch catch (…) { } chamada f() return valor caminho normal throw caminho excepcional

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

T é um parâmetro de tipoCada chamada propõe um T a partir dos argumentos: maior(3, 7) → T = int.
typename = classNa lista de parâmetros são sinônimos. typename diz melhor o que é: qualquer tipo, não só classes.
Dois parâmetrosA e B são deduzidos separadamente; 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

✓ diga o T

maior<double>(3, 7.5)

Nada a deduzir; o 3 vira 3.0.

✓ iguale os tipos

maior(3.0, 7.5)

Os dois argumentos propõem double.

✓ dois parâmetros

misturar(3, 7.5)

A = int, B = double → 10.5.

8.1 por dentro do arquivo objeto

Nada existe até alguém chamar

Uma função por tipoQuatro chamadas, três tipos → três funções no objeto. maior<double>(3, 7.5) reaproveitou a de double.
W = símbolo fracoCada .o que usa maior<int> leva uma cópia; o linker fica com uma só (ODR).
Corpo no .cpp?maior.o sai vazio: lá ninguém pediu 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.5 com <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 guiacom o guia
-std=c++17deduction failedDupla<int, string>
-std=c++20dedução de agregadoDupla<int, string>
A formaNomeDoTemplate(params) -> Tipo<…>; — "quando construírem assim, o tipo é este".
No C++20Dupla é um agregado e ganhou CTAD própria: o guia ficou opcional. O demo o escreve para mostrar a sintaxe.
Aposentoustd::make_pair(1, 2.0) → std::pair p{1, 2.0}; (idem make_tuple).
Só classesFunções sempre deduziram os seus T. CTAD é a mesma ideia levada às classes.

8.3 demo_generico.hpp

Um valor como parâmetro de template

8.3 argumentos padrão de template

Vetor<> é Vetor<int, 4>

Vetor<>
intintintint
16 bytes
Vetor<double, 3>
doubledoubledouble
24 bytes
ondeVetor 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

PrimárioA regra geral: vale para todo T que nenhuma especialização pegar.
Totaltemplate <> + argumentos concretos. Não sobra nada livre.
ParcialAinda sobra um parâmetro (T), mas com FORMA: "qualquer ponteiro".
Recursivanome() 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

Só classe e variávelA própria mensagem do GCC diz quem pode ter especialização parcial. Para funções, três saídas ↓

8.5 demo_generico.hpp

Pacotes, variáveis e apelidos

C++11 variádico

C++14 de variável

C++11 de alias

É assim questd::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?

sem typename, o compilador lê

T::value_type × p: um VALOR vezes uma variável que não existe.

GCC 13.3

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?

sem template, o compilador lê

p.convertida < double: comparação com um tipo.

GCC 13.3

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++17C++20
tipo de retorno (o demo)errook
using X = T::value_type;errook
membro de classeerrook
variável no corpoerroerro
parâmetro de função livreerroerro

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).

Regra práticaEscrever 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 true ou false por tipo.
  • Parâmetros de mentira: nada roda, só se pergunta se compila.
  • A expressão a + b tem de ser válida…
  • …e o resultado tem de converter para T.
TSomavel<T>
int, doubletrue
std::stringtrue
chartrue · 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

sem concept
106linhas

o erro aponta para DENTRO de soma + 14 candidatos de operator+

com concept
17linhas

o erro aponta para a CHAMADA e diz qual exigência falhou

8.7 demo_generico.hpp

throw sai, catch recebe

  • throw abandona a função na hora: o return não roda.
  • Os catch sã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.

Para que serveRegistrar, limpar e repassar: o catch intermediário não precisa saber o tipo.

8.7 regra prática

Lance por valor, capture por const&

o objeto lançado: std::invalid_argument

parte std::exception
parte logic_error · guarda a mensagem
parte invalid_argument

a cópia em catch (std::exception e)

parte std::exception

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

Destrutor é noexceptO GCC avisa no ruim.cpp: ‘throw’ will always call ‘terminate’ [-Wterminate] · in C++11 destructors default to ‘noexcept’.
Sem RAII, cada throw vazap = 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)?

  1. Compila: T = double
  2. Compila: T = int, trunca 7.5
  3. Não compila
  4. Compila com aviso
O 3 propõe T = int, o 7.5 propõe T = double, e a dedução não faz a conversão int → double: deduced conflicting types.

BufferFixo<int, 8> e BufferFixo<int, 16> são o mesmo tipo? (std::is_same_v)

  1. true
  2. false
O valor do NTTP faz parte do tipo: são dois tipos diferentes (32 e 64 bytes), e nem a atribuição entre eles compila.

quiz · 2 de 3

Especialização e catch

Os primários de X, f e e existem. Qual linha não compila?

  1. template <> struct X<int> {};
  2. template <class T> struct X<T*> {};
  3. template <class T> void f<T*>(T*) {}
  4. template <class T> bool e<T*> = 1;
Especialização parcial só para classe e variável. Para função: sobrecarga, if constexpr ou concepts.

catch (const std::exception&) vem antes de catch (const std::invalid_argument&). dividir(1, 0) cai em…

  1. invalid_argument: o mais específico
  2. std::exception: o primeiro que casa
  3. nos dois, em sequência
  4. erro de compilação
Os catch são testados em ordem; o geral engole o específico, que fica inalcançável. O GCC avisa: -Wexceptions.

quiz · 3 de 3

Quando roda ~Sentinela()?

O destrutor de s…

  1. nunca roda: o throw pula o fim da função
  2. roda depois do catch
  3. roda antes do catch, no stack unwinding
  4. só no fim do programa
Entre o throw e o catch a pilha é desmontada e cada local construído é destruído. A saída real mostra "liberado" antes de "capturado": é a base do RAII.

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 constexpr ou concepts.
  • typename e template dizem 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&.
}

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#include cola texto; função ou variável não-inline tem uma definição no programa (ODR).
  • 1Inicialize sempre, com {}: barra o narrowing e zera o que não tem valor.
  • 2if e switch com init prendem o nome no escopo; if constexpr descarta o galho.
  • 3const T& para ler, T para o barato; a sobrecarga se resolve ao compilar.
  • 4enum class nã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.
  • 7int com unsigned vira unsigned; use os 4 casts nomeados, nunca (T)x.
  • 8Templates geram código por tipo; concepts dão nome às exigências; throw desempilha.

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

  1. 8 blocos, cada um com o cabeçalho em turquesa
  2. os trechos reais que o README cita
  3. a última linha, em verde-lima
Saída realCada linha ao lado é cópia literal do programa; cada … marca linhas puladas.

como validar 2 · todos os avisos · 3 · sanitizers

Três portões, zero achados

1
Rodar o instaladoo que o README promete
8 blocos1.090 linhas · saiu com 0
2
Compilar avulsocom todos os avisos
0 avisosstderr vazio
3
SanitizersASan + UBSan
0 achadosstderr vazio · saiu com 0
Por que trêsAvisos pegam o que o compilador enxerga; sanitizers pegam o que só aparece executando — acesso fora dos limites, overflow com sinal, uso depois de liberar. Tudo rodado de novo para esta aula, com o GCC 13.3.

como validar o detalhe · demo_tipos.hpp

Zero avisos — e um #pragma com motivo

O único #pragma GCC diagnostic do subprojetoCala o aviso só onde a inicialização parcial é a lição — o campo omitido vira zero (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

casts/os 4 casts, bit_cast, a ordem do cast C
value_semantics/categorias de valor, move, forwarding
layout/sizeof, padding, trivial medidos
linkage/TU, linkage, ODR, o linker
undefined_behavior/o que "UB" custa
templates/concepts/genéricos além da sintaxe
errors/exceções, garantias, expected, error_code
stl/containers e algoritmos: para que serve a sintaxe

fontes canônicas

C++ Core Guidelines

ES.20 sempre inicialize · ES.23 prefira {} · ES.45 nada de constantes mágicas · NR as "não-regras"

padrão ISO

[expr.cast]/4 a ordem do cast C · [basic.def.odr] a ODR · [basic.lval] categorias de valor · [class.bit] bitfields

livro

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

Tier 3concorrência e paralelismo
depoispor interesse
baixo nível asm_course · inline_asm · outline_asmferramentas meson · doxygen · parserrede e dados network · http-client · database · rabbitmq · awsgráficos e física calculus · collision · sfml_bullet · qt_sfml · flight-simulator…interop e visão python · embed-python · yolo

$ ./dist/bin/syntax … 1.088 linhas depois …

✓ Todos os demos de sintaxe concluídos!

Perguntas?

cpp_academy · src/syntax · make open PROJ=syntax