theus-cli-linux-x64 0.2.84

package/vendor/theus-arsenal/skills/estandares-cpp/SKILL.md

@@ -0,0 +1,727 @@
+---
+name: estandares-cpp
+description: Estándares de codificación C++ basados en las C++ Core Guidelines (isocpp.github.io).
+  Úsala al escribir, revisar o refactorizar código C++ para aplicar prácticas modernas, seguras e idiomáticas.
+---
+
+# Estándares de codificación C++ (C++ Core Guidelines)
+
+Estándares de codificación integrales para C++ moderno (C++17/20/23) derivados de las [C++ Core Guidelines](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines). Refuerzan la seguridad de tipos, la seguridad de recursos, la inmutabilidad y la claridad.
+
+## Cuándo usarla
+
+- Al escribir código C++ nuevo (clases, funciones, plantillas).
+- Al revisar o refactorizar código C++ existente.
+- Al tomar decisiones de arquitectura en proyectos C++.
+- Al imponer un estilo consistente en una base de código C++.
+- Al elegir entre funcionalidades del lenguaje (p. ej., `enum` vs `enum class`, puntero crudo vs puntero inteligente).
+
+### Cuándo NO usarla
+
+- Proyectos que no son C++.
+- Bases de código C heredadas que no pueden adoptar C++ moderno.
+- Contextos embebidos/bare-metal donde alguna directriz choca con restricciones de hardware (adapta selectivamente).
+
+## Principios transversales
+
+Estos temas se repiten a lo largo de todas las directrices y forman la base:
+
+1. **RAII en todas partes** (P.8, R.1, E.6, CP.20): liga la vida del recurso a la vida del objeto.
+2. **Inmutabilidad por defecto** (P.10, Con.1-5, ES.25): parte de `const`/`constexpr`; la mutabilidad es la excepción.
+3. **Seguridad de tipos** (P.4, I.4, ES.46-49, Enum.3): usa el sistema de tipos para prevenir errores en compilación.
+4. **Expresar la intención** (P.3, F.1, NL.1-2, T.10): nombres, tipos y concepts deben comunicar propósito.
+5. **Minimizar la complejidad** (F.2-3, ES.5, Per.4-5): el código simple es código correcto.
+6. **Semántica de valor sobre semántica de puntero** (C.10, R.3-5, F.20, CP.31): prefiere devolver por valor y objetos con ámbito.
+
+## Filosofía e interfaces (P.*, I.*)
+
+### Reglas clave
+
+| Regla | Resumen |
+|-------|---------|
+| **P.1** | Expresa las ideas directamente en el código |
+| **P.3** | Expresa la intención |
+| **P.4** | Idealmente, un programa debe ser estáticamente seguro en tipos |
+| **P.5** | Prefiere verificación en compilación a verificación en ejecución |
+| **P.8** | No filtres ningún recurso |
+| **P.10** | Prefiere datos inmutables a datos mutables |
+| **I.1** | Haz las interfaces explícitas |
+| **I.2** | Evita variables globales no const |
+| **I.4** | Haz las interfaces precisa y fuertemente tipadas |
+| **I.11** | Nunca transfieras propiedad mediante puntero crudo o referencia |
+| **I.23** | Mantén bajo el número de argumentos de función |
+
+### SÍ
+
+```cpp
+// P.10 + I.4: interfaz inmutable y fuertemente tipada
+struct Temperature {
+    double kelvin;
+};
+
+Temperature boil(const Temperature& water);
+```
+
+### NO
+
+```cpp
+// Interfaz débil: propiedad poco clara, unidades poco claras
+double boil(double* temp);
+
+// Variable global no const
+int g_counter = 0;  // violación de I.2
+```
+
+## Funciones (F.*)
+
+### Reglas clave
+
+| Regla | Resumen |
+|-------|---------|
+| **F.1** | Empaqueta las operaciones significativas en funciones bien nombradas |
+| **F.2** | Una función debe realizar una única operación lógica |
+| **F.3** | Mantén las funciones cortas y simples |
+| **F.4** | Si una función puede evaluarse en compilación, decláralo `constexpr` |
+| **F.6** | Si tu función no debe lanzar, decláralo `noexcept` |
+| **F.8** | Prefiere funciones puras |
+| **F.16** | Parámetros "in": tipos baratos de copiar por valor, el resto por `const&` |
+| **F.20** | Para valores "out", prefiere valores de retorno a parámetros de salida |
+| **F.21** | Para devolver varios valores "out", prefiere devolver un struct |
+| **F.43** | Nunca devuelvas un puntero o referencia a un objeto local |
+
+### Paso de parámetros
+
+```cpp
+// F.16: tipos baratos por valor, el resto por const&
+void print(int x);                           // barato: por valor
+void analyze(const std::string& data);       // costoso: por const&
+void transform(std::string s);               // sink: por valor (se moverá)
+
+// F.20 + F.21: valores de retorno, no parámetros de salida
+struct ParseResult {
+    std::string token;
+    int position;
+};
+
+ParseResult parse(std::string_view input);   // BIEN: devolver struct
+
+// MAL: parámetros de salida
+void parse(std::string_view input,
+           std::string& token, int& pos);    // evitar
+```
+
+### Funciones puras y constexpr
+
+```cpp
+// F.4 + F.8: puras y constexpr donde sea posible
+constexpr int factorial(int n) noexcept {
+    return (n <= 1) ? 1 : n * factorial(n - 1);
+}
+
+static_assert(factorial(5) == 120);
+```
+
+### Antipatrones
+
+- Devolver `T&&` desde funciones (F.45).
+- Usar `va_arg` / variádicos estilo C (F.55).
+- Capturar por referencia en lambdas que se pasan a otros hilos (F.53).
+- Devolver `const T`, que inhibe la semántica de movimiento (F.49).
+
+## Clases y jerarquías de clases (C.*)
+
+### Reglas clave
+
+| Regla | Resumen |
+|-------|---------|
+| **C.2** | Usa `class` si existe un invariante; `struct` si los miembros varían de forma independiente |
+| **C.9** | Minimiza la exposición de miembros |
+| **C.20** | Si puedes evitar definir las operaciones por defecto, hazlo (Regla del Cero) |
+| **C.21** | Si defines o haces `=delete` de cualquier copia/movimiento/destructor, gestiona los cinco (Regla del Cinco) |
+| **C.35** | Destructor de clase base: público virtual o protegido no virtual |
+| **C.41** | Un constructor debe crear un objeto totalmente inicializado |
+| **C.46** | Declara `explicit` los constructores de un solo argumento |
+| **C.67** | Una clase polimórfica debe suprimir la copia/movimiento públicos |
+| **C.128** | Funciones virtuales: especifica exactamente uno de `virtual`, `override` o `final` |
+
+### Regla del Cero
+
+```cpp
+// C.20: deja que el compilador genere los miembros especiales
+struct Employee {
+    std::string name;
+    std::string department;
+    int id;
+    // No necesita destructor, constructores de copia/movimiento ni operadores de asignación
+};
+```
+
+### Regla del Cinco
+
+```cpp
+// C.21: si debes gestionar un recurso, define los cinco
+class Buffer {
+public:
+    explicit Buffer(std::size_t size)
+        : data_(std::make_unique<char[]>(size)), size_(size) {}
+
+    ~Buffer() = default;
+
+    Buffer(const Buffer& other)
+        : data_(std::make_unique<char[]>(other.size_)), size_(other.size_) {
+        std::copy_n(other.data_.get(), size_, data_.get());
+    }
+
+    Buffer& operator=(const Buffer& other) {
+        if (this != &other) {
+            auto new_data = std::make_unique<char[]>(other.size_);
+            std::copy_n(other.data_.get(), other.size_, new_data.get());
+            data_ = std::move(new_data);
+            size_ = other.size_;
+        }
+        return *this;
+    }
+
+    Buffer(Buffer&&) noexcept = default;
+    Buffer& operator=(Buffer&&) noexcept = default;
+
+private:
+    std::unique_ptr<char[]> data_;
+    std::size_t size_;
+};
+```
+
+### Jerarquía de clases
+
+```cpp
+// C.35 + C.128: destructor virtual, usar override
+class Shape {
+public:
+    virtual ~Shape() = default;
+    virtual double area() const = 0;  // C.121: interfaz pura
+};
+
+class Circle : public Shape {
+public:
+    explicit Circle(double r) : radius_(r) {}
+    double area() const override { return 3.14159 * radius_ * radius_; }
+
+private:
+    double radius_;
+};
+```
+
+### Antipatrones
+
+- Llamar funciones virtuales en constructores/destructores (C.82).
+- Usar `memset`/`memcpy` sobre tipos no triviales (C.90).
+- Dar argumentos por defecto distintos a una función virtual y a su override (C.140).
+- Hacer miembros de datos `const` o referencias, lo que suprime movimiento/copia (C.12).
+
+## Gestión de recursos (R.*)
+
+### Reglas clave
+
+| Regla | Resumen |
+|-------|---------|
+| **R.1** | Gestiona los recursos automáticamente mediante RAII |
+| **R.3** | Un puntero crudo (`T*`) no es propietario |
+| **R.5** | Prefiere objetos con ámbito; no reserves en heap sin necesidad |
+| **R.10** | Evita `malloc()`/`free()` |
+| **R.11** | Evita llamar `new` y `delete` explícitamente |
+| **R.20** | Usa `unique_ptr` o `shared_ptr` para representar propiedad |
+| **R.21** | Prefiere `unique_ptr` sobre `shared_ptr` salvo propiedad compartida |
+| **R.22** | Usa `make_shared()` para crear `shared_ptr`s |
+
+### Uso de punteros inteligentes
+
+```cpp
+// R.11 + R.20 + R.21: RAII con punteros inteligentes
+auto widget = std::make_unique<Widget>("config");  // propiedad única
+auto cache  = std::make_shared<Cache>(1024);        // propiedad compartida
+
+// R.3: puntero crudo = observador no propietario
+void render(const Widget* w) {  // NO es dueño de w
+    if (w) w->draw();
+}
+
+render(widget.get());
+```
+
+### Patrón RAII
+
+```cpp
+// R.1: la adquisición del recurso es la inicialización
+class FileHandle {
+public:
+    explicit FileHandle(const std::string& path)
+        : handle_(std::fopen(path.c_str(), "r")) {
+        if (!handle_) throw std::runtime_error("No se pudo abrir: " + path);
+    }
+
+    ~FileHandle() {
+        if (handle_) std::fclose(handle_);
+    }
+
+    FileHandle(const FileHandle&) = delete;
+    FileHandle& operator=(const FileHandle&) = delete;
+    FileHandle(FileHandle&& other) noexcept
+        : handle_(std::exchange(other.handle_, nullptr)) {}
+    FileHandle& operator=(FileHandle&& other) noexcept {
+        if (this != &other) {
+            if (handle_) std::fclose(handle_);
+            handle_ = std::exchange(other.handle_, nullptr);
+        }
+        return *this;
+    }
+
+private:
+    std::FILE* handle_;
+};
+```
+
+### Antipatrones
+
+- `new`/`delete` desnudos (R.11).
+- `malloc()`/`free()` en código C++ (R.10).
+- Múltiples reservas de recursos en una misma expresión (R.13 — riesgo para la seguridad ante excepciones).
+- `shared_ptr` donde basta `unique_ptr` (R.21).
+
+## Expresiones y sentencias (ES.*)
+
+### Reglas clave
+
+| Regla | Resumen |
+|-------|---------|
+| **ES.5** | Mantén los ámbitos pequeños |
+| **ES.20** | Siempre inicializa los objetos |
+| **ES.23** | Prefiere la sintaxis de inicialización `{}` |
+| **ES.25** | Declara los objetos `const` o `constexpr` salvo que se pretenda modificarlos |
+| **ES.28** | Usa lambdas para inicializaciones complejas de variables `const` |
+| **ES.45** | Evita constantes mágicas; usa constantes simbólicas |
+| **ES.46** | Evita conversiones aritméticas con estrechamiento/pérdida |
+| **ES.47** | Usa `nullptr` en lugar de `0` o `NULL` |
+| **ES.48** | Evita los casts |
+| **ES.50** | No elimines `const` con casts |
+
+### Inicialización
+
+```cpp
+// ES.20 + ES.23 + ES.25: siempre inicializar, preferir {}, const por defecto
+const int max_retries{3};
+const std::string name{"widget"};
+const std::vector<int> primes{2, 3, 5, 7, 11};
+
+// ES.28: lambda para inicialización const compleja
+const auto config = [&] {
+    Config c;
+    c.timeout = std::chrono::seconds{30};
+    c.retries = max_retries;
+    c.verbose = debug_mode;
+    return c;
+}();
+```
+
+### Antipatrones
+
+- Variables sin inicializar (ES.20).
+- Usar `0` o `NULL` como puntero (ES.47 — usa `nullptr`).
+- Casts estilo C (ES.48 — usa `static_cast`, `const_cast`, etc.).
+- Eliminar `const` con casts (ES.50).
+- Números mágicos sin constantes con nombre (ES.45).
+- Mezclar aritmética con y sin signo (ES.100).
+- Reutilizar nombres en ámbitos anidados (ES.12).
+
+## Manejo de errores (E.*)
+
+### Reglas clave
+
+| Regla | Resumen |
+|-------|---------|
+| **E.1** | Diseña la estrategia de manejo de errores temprano |
+| **E.2** | Lanza una excepción para señalar que una función no puede cumplir su tarea |
+| **E.6** | Usa RAII para prevenir fugas |
+| **E.12** | Usa `noexcept` cuando lanzar sea imposible o inaceptable |
+| **E.14** | Usa tipos definidos por el usuario, diseñados a propósito, como excepciones |
+| **E.15** | Lanza por valor, captura por referencia |
+| **E.16** | Destructores, liberación de memoria y swap nunca deben fallar |
+| **E.17** | No intentes capturar todas las excepciones en todas las funciones |
+
+### Jerarquía de excepciones
+
+```cpp
+// E.14 + E.15: tipos de excepción propios, lanzar por valor, capturar por referencia
+class AppError : public std::runtime_error {
+public:
+    using std::runtime_error::runtime_error;
+};
+
+class NetworkError : public AppError {
+public:
+    NetworkError(const std::string& msg, int code)
+        : AppError(msg), status_code(code) {}
+    int status_code;
+};
+
+void fetch_data(const std::string& url) {
+    // E.2: lanzar para señalar el fallo
+    throw NetworkError("conexión rechazada", 503);
+}
+
+void run() {
+    try {
+        fetch_data("https://api.example.com");
+    } catch (const NetworkError& e) {
+        log_error(e.what(), e.status_code);
+    } catch (const AppError& e) {
+        log_error(e.what());
+    }
+    // E.17: no capturar todo aquí — dejar que los errores inesperados se propaguen
+}
+```
+
+### Antipatrones
+
+- Lanzar tipos primitivos como `int` o literales de cadena (E.14).
+- Capturar por valor (riesgo de slicing) (E.15).
+- Bloques catch vacíos que se tragan los errores en silencio.
+- Usar excepciones para control de flujo (E.3).
+- Manejo de errores basado en estado global como `errno` (E.28).
+
+## Constantes e inmutabilidad (Con.*)
+
+### Todas las reglas
+
+| Regla | Resumen |
+|-------|---------|
+| **Con.1** | Por defecto, haz los objetos inmutables |
+| **Con.2** | Por defecto, haz las funciones miembro `const` |
+| **Con.3** | Por defecto, pasa punteros y referencias a `const` |
+| **Con.4** | Usa `const` para valores que no cambian tras la construcción |
+| **Con.5** | Usa `constexpr` para valores computables en compilación |
+
+```cpp
+// Con.1 a Con.5: inmutabilidad por defecto
+class Sensor {
+public:
+    explicit Sensor(std::string id) : id_(std::move(id)) {}
+
+    // Con.2: funciones miembro const por defecto
+    const std::string& id() const { return id_; }
+    double last_reading() const { return reading_; }
+
+    // No const solo cuando la mutación es necesaria
+    void record(double value) { reading_ = value; }
+
+private:
+    const std::string id_;  // Con.4: nunca cambia tras la construcción
+    double reading_{0.0};
+};
+
+// Con.3: pasar por referencia const
+void display(const Sensor& s) {
+    std::cout << s.id() << ": " << s.last_reading() << '\n';
+}
+
+// Con.5: constantes en tiempo de compilación
+constexpr double PI = 3.14159265358979;
+constexpr int MAX_SENSORS = 256;
+```
+
+## Concurrencia y paralelismo (CP.*)
+
+### Reglas clave
+
+| Regla | Resumen |
+|-------|---------|
+| **CP.2** | Evita las condiciones de carrera de datos |
+| **CP.3** | Minimiza la compartición explícita de datos escribibles |
+| **CP.4** | Piensa en términos de tareas, no de hilos |
+| **CP.8** | No uses `volatile` para sincronización |
+| **CP.20** | Usa RAII, nunca `lock()`/`unlock()` a pelo |
+| **CP.21** | Usa `std::scoped_lock` para adquirir múltiples mutex |
+| **CP.22** | Nunca llames código desconocido manteniendo un lock |
+| **CP.42** | No esperes sin una condición |
+| **CP.44** | Recuerda nombrar tus `lock_guard`s y `unique_lock`s |
+| **CP.100** | No hagas programación lock-free salvo que sea absolutamente necesario |
+
+### Bloqueo seguro
+
+```cpp
+// CP.20 + CP.44: locks RAII, siempre con nombre
+class ThreadSafeQueue {
+public:
+    void push(int value) {
+        std::lock_guard<std::mutex> lock(mutex_);  // CP.44: ¡con nombre!
+        queue_.push(value);
+        cv_.notify_one();
+    }
+
+    int pop() {
+        std::unique_lock<std::mutex> lock(mutex_);
+        // CP.42: siempre esperar con una condición
+        cv_.wait(lock, [this] { return !queue_.empty(); });
+        const int value = queue_.front();
+        queue_.pop();
+        return value;
+    }
+
+private:
+    std::mutex mutex_;             // CP.50: el mutex junto a sus datos
+    std::condition_variable cv_;
+    std::queue<int> queue_;
+};
+```
+
+### Múltiples mutex
+
+```cpp
+// CP.21: std::scoped_lock para múltiples mutex (sin deadlocks)
+void transfer(Account& from, Account& to, double amount) {
+    std::scoped_lock lock(from.mutex_, to.mutex_);
+    from.balance_ -= amount;
+    to.balance_ += amount;
+}
+```
+
+### Antipatrones
+
+- `volatile` para sincronización (CP.8 — es solo para E/S de hardware).
+- Hilos con `detach` (CP.26 — la gestión de la vida útil se vuelve casi imposible).
+- Lock guards sin nombre: `std::lock_guard<std::mutex>(m);` se destruye de inmediato (CP.44).
+- Mantener locks mientras se llaman callbacks (CP.22 — riesgo de deadlock).
+- Programación lock-free sin experiencia profunda (CP.100).
+
+## Plantillas y programación genérica (T.*)
+
+### Reglas clave
+
+| Regla | Resumen |
+|-------|---------|
+| **T.1** | Usa plantillas para elevar el nivel de abstracción |
+| **T.2** | Usa plantillas para expresar algoritmos aplicables a muchos tipos |
+| **T.10** | Especifica concepts para todos los argumentos de plantilla |
+| **T.11** | Usa concepts estándar siempre que sea posible |
+| **T.13** | Prefiere la notación abreviada para concepts simples |
+| **T.43** | Prefiere `using` sobre `typedef` |
+| **T.120** | Usa metaprogramación de plantillas solo cuando realmente la necesites |
+| **T.144** | No especialices plantillas de función (sobrecarga en su lugar) |
+
+### Concepts (C++20)
+
+```cpp
+#include <concepts>
+
+// T.10 + T.11: restringir plantillas con concepts estándar
+template<std::integral T>
+T gcd(T a, T b) {
+    while (b != 0) {
+        a = std::exchange(b, a % b);
+    }
+    return a;
+}
+
+// T.13: sintaxis abreviada de concepts
+void sort(std::ranges::random_access_range auto& range) {
+    std::ranges::sort(range);
+}
+
+// Concept propio para restricciones del dominio
+template<typename T>
+concept Serializable = requires(const T& t) {
+    { t.serialize() } -> std::convertible_to<std::string>;
+};
+
+template<Serializable T>
+void save(const T& obj, const std::string& path);
+```
+
+### Antipatrones
+
+- Plantillas sin restricciones en espacios de nombres visibles (T.47).
+- Especializar plantillas de función en lugar de sobrecargar (T.144).
+- Metaprogramación de plantillas donde basta `constexpr` (T.120).
+- `typedef` en lugar de `using` (T.43).
+
+## Biblioteca estándar (SL.*)
+
+### Reglas clave
+
+| Regla | Resumen |
+|-------|---------|
+| **SL.1** | Usa bibliotecas siempre que sea posible |
+| **SL.2** | Prefiere la biblioteca estándar a otras bibliotecas |
+| **SL.con.1** | Prefiere `std::array` o `std::vector` sobre arrays de C |
+| **SL.con.2** | Prefiere `std::vector` por defecto |
+| **SL.str.1** | Usa `std::string` para poseer secuencias de caracteres |
+| **SL.str.2** | Usa `std::string_view` para referirte a secuencias de caracteres |
+| **SL.io.50** | Evita `endl` (usa `'\n'` — `endl` fuerza un flush) |
+
+```cpp
+// SL.con.1 + SL.con.2: preferir vector/array sobre arrays de C
+const std::array<int, 4> fixed_data{1, 2, 3, 4};
+std::vector<std::string> dynamic_data;
+
+// SL.str.1 + SL.str.2: string posee, string_view observa
+std::string build_greeting(std::string_view name) {
+    return "Hola, " + std::string(name) + "!";
+}
+
+// SL.io.50: usar '\n', no endl
+std::cout << "resultado: " << value << '\n';
+```
+
+## Enumeraciones (Enum.*)
+
+### Reglas clave
+
+| Regla | Resumen |
+|-------|---------|
+| **Enum.1** | Prefiere enumeraciones sobre macros |
+| **Enum.3** | Prefiere `enum class` sobre `enum` plano |
+| **Enum.5** | No uses MAYÚSCULAS para los enumeradores |
+| **Enum.6** | Evita enumeraciones sin nombre |
+
+```cpp
+// Enum.3 + Enum.5: enum con ámbito, sin MAYÚSCULAS
+enum class Color { red, green, blue };
+enum class LogLevel { debug, info, warning, error };
+
+// MAL: el enum plano filtra nombres, las MAYÚSCULAS chocan con macros
+enum { RED, GREEN, BLUE };           // violación de Enum.3 + Enum.5 + Enum.6
+#define MAX_SIZE 100                  // violación de Enum.1 — usa constexpr
+```
+
+## Archivos fuente y nombrado (SF.*, NL.*)
+
+### Reglas clave
+
+| Regla | Resumen |
+|-------|---------|
+| **SF.1** | Usa `.cpp` para archivos de código y `.h` para archivos de interfaz |
+| **SF.7** | No escribas `using namespace` a nivel global en un header |
+| **SF.8** | Usa guardas de `#include` en todos los `.h` |
+| **SF.11** | Los headers deben ser autocontenidos |
+| **NL.5** | Evita codificar información de tipo en los nombres (nada de notación húngara) |
+| **NL.8** | Usa un estilo de nombrado consistente |
+| **NL.9** | Usa MAYÚSCULAS solo para nombres de macros |
+| **NL.10** | Prefiere nombres en `underscore_style` |
+
+### Guarda de header
+
+```cpp
+// SF.8: guarda de include (o #pragma once)
+#ifndef PROJECT_MODULE_WIDGET_H
+#define PROJECT_MODULE_WIDGET_H
+
+// SF.11: autocontenido — incluye todo lo que este header necesita
+#include <string>
+#include <vector>
+
+namespace project::module {
+
+class Widget {
+public:
+    explicit Widget(std::string name);
+    const std::string& name() const;
+
+private:
+    std::string name_;
+};
+
+}  // namespace project::module
+
+#endif  // PROJECT_MODULE_WIDGET_H
+```
+
+### Convenciones de nombrado
+
+```cpp
+// NL.8 + NL.10: underscore_style consistente
+namespace my_project {
+
+constexpr int max_buffer_size = 4096;  // NL.9: sin MAYÚSCULAS (no es una macro)
+
+class tcp_connection {                 // clase en underscore_style
+public:
+    void send_message(std::string_view msg);
+    bool is_connected() const;
+
+private:
+    std::string host_;                 // guion bajo final para miembros
+    int port_;
+};
+
+}  // namespace my_project
+```
+
+### Antipatrones
+
+- `using namespace std;` a nivel global en un header (SF.7).
+- Headers que dependen del orden de inclusión (SF.10, SF.11).
+- Notación húngara como `strName`, `iCount` (NL.5).
+- MAYÚSCULAS para cualquier cosa que no sea una macro (NL.9).
+
+## Rendimiento (Per.*)
+
+### Reglas clave
+
+| Regla | Resumen |
+|-------|---------|
+| **Per.1** | No optimices sin razón |
+| **Per.2** | No optimices prematuramente |
+| **Per.6** | No hagas afirmaciones de rendimiento sin mediciones |
+| **Per.7** | Diseña para habilitar la optimización |
+| **Per.10** | Apóyate en el sistema de tipos estático |
+| **Per.11** | Mueve el cómputo del tiempo de ejecución al de compilación |
+| **Per.19** | Accede a la memoria de forma predecible |
+
+### Directrices
+
+```cpp
+// Per.11: cómputo en compilación donde sea posible
+constexpr auto lookup_table = [] {
+    std::array<int, 256> table{};
+    for (int i = 0; i < 256; ++i) {
+        table[i] = i * i;
+    }
+    return table;
+}();
+
+// Per.19: preferir datos contiguos por amigabilidad con la caché
+std::vector<Point> points;           // BIEN: contiguo
+std::vector<std::unique_ptr<Point>> indirect_points; // MAL: persecución de punteros
+```
+
+### Antipatrones
+
+- Optimizar sin datos de profiling (Per.1, Per.6).
+- Elegir código de bajo nivel "ingenioso" en vez de abstracciones claras (Per.4, Per.5).
+- Ignorar la disposición de datos y el comportamiento de la caché (Per.19).
+
+## Lista de verificación rápida
+
+Antes de dar por terminado trabajo en C++:
+
+- [ ] Sin `new`/`delete` crudos — usa punteros inteligentes o RAII (R.11).
+- [ ] Objetos inicializados en la declaración (ES.20).
+- [ ] Variables `const`/`constexpr` por defecto (Con.1, ES.25).
+- [ ] Funciones miembro `const` donde sea posible (Con.2).
+- [ ] `enum class` en lugar de `enum` plano (Enum.3).
+- [ ] `nullptr` en lugar de `0`/`NULL` (ES.47).
+- [ ] Sin conversiones con estrechamiento (ES.46).
+- [ ] Sin casts estilo C (ES.48).
+- [ ] Constructores de un solo argumento `explicit` (C.46).
+- [ ] Regla del Cero o Regla del Cinco aplicada (C.20, C.21).
+- [ ] Destructores de clase base públicos virtuales o protegidos no virtuales (C.35).
+- [ ] Plantillas restringidas con concepts (T.10).
+- [ ] Sin `using namespace` a nivel global en headers (SF.7).
+- [ ] Headers con guardas de include y autocontenidos (SF.8, SF.11).
+- [ ] Locks con RAII (`scoped_lock`/`lock_guard`) (CP.20).
+- [ ] Excepciones de tipos propios, lanzadas por valor, capturadas por referencia (E.14, E.15).
+- [ ] `'\n'` en lugar de `std::endl` (SL.io.50).
+- [ ] Sin números mágicos (ES.45).
+
+## Skills relacionadas
+
+- `testing-cpp` para el flujo de pruebas con GoogleTest/CTest.