theus-cli 0.2.83 → 0.2.85

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

@@ -1,727 +0,0 @@
----
-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.