Padrões de Codificação C++ (C++ Core Guidelines)

Padrões de codificação abrangentes para C++ moderno (C++17/20/23) derivados das C++ Core Guidelines. Impõe segurança de tipo, segurança de recursos, imutabilidade e clareza.

Quando Usar

• Escrever novo código C++ (classes, funções, templates)
• Revisar ou refatorar código C++ existente
• Tomar decisões arquiteturais em projetos C++
• Impor estilo consistente em uma base de código C++
• Escolher entre recursos da linguagem (por exemplo, enum vs enum class, ponteiro bruto vs ponteiro inteligente)

Quando NÃO Usar

• Projetos que não são C++
• Bases de código C legadas que não podem adotar recursos modernos de C++
• Contextos embarcados/bare-metal onde diretrizes específicas entram em conflito com restrições de hardware (adaptar seletivamente)

Princípios Transversais

Esses temas recorrem em todas as diretrizes e formam a base:

1. RAII em todos os lugares (P.8, R.1, E.6, CP.20): Vincule o tempo de vida do recurso ao tempo de vida do objeto
2. Imutabilidade por padrão (P.10, Con.1-5, ES.25): Comece com const/constexpr; mutabilidade é a exceção
3. Segurança de tipo (P.4, I.4, ES.46-49, Enum.3): Use o sistema de tipos para prevenir erros em tempo de compilação
4. Expresse a intenção (P.3, F.1, NL.1-2, T.10): Nomes, tipos e conceitos devem comunicar o propósito
5. Minimize a complexidade (F.2-3, ES.5, Per.4-5): Código simples é código correto
6. Semântica de valor em vez de semântica de ponteiro (C.10, R.3-5, F.20, CP.31): Prefira retornar por valor e objetos com escopo

Filosofia e Interfaces (P., I.)

Regras Chave

FAZER

// P.10 + I.4: Immutable, strongly typed interface
struct Temperature {
    double kelvin;
};

Temperature boil(const Temperature& water);

NÃO FAZER

// Weak interface: unclear ownership, unclear units
double boil(double* temp);

// Non-const global variable
int g_counter = 0;  // I.2 violation

Funções (F.*)

Regras Chave

Passagem de Parâmetros

// F.16: Cheap types by value, others by const&
void print(int x);                           // cheap: by value
void analyze(const std::string& data);       // expensive: by const&
void transform(std::string s);               // sink: by value (will move)

// F.20 + F.21: Return values, not output parameters
struct ParseResult {
    std::string token;
    int position;
};

ParseResult parse(std::string_view input);   // GOOD: return struct

// BAD: output parameters
void parse(std::string_view input,
           std::string& token, int& pos);    // avoid this

Funções Puras e constexpr

// F.4 + F.8: Pure, constexpr where possible
constexpr int factorial(int n) noexcept {
    return (n <= 1) ? 1 : n * factorial(n - 1);
}

static_assert(factorial(5) == 120);

Anti-Padrões

• Retornar T&& de funções (F.45)
• Usar va_arg / variádicas estilo C (F.55)
• Capturar por referência em lambdas passadas para outras threads (F.53)
• Retornar const T que inibe semânticas de movimento (F.49)

Classes e Hierarquias de Classes (C.*)

Regras Chave

…