Modern C++ Project Rules

cppsystemsperformance

Enforces modern C++17/20 conventions including RAII, smart pointers, move semantics, const-correctness, and safe resource management for high-performance systems code.

Целевые файлы

Файл	Формат
.cursorrules	plaintext
CLAUDE.md	markdown

Содержимое

## Modern C++ Project Rules ### Resource Management (RAII) - Every resource (memory, file handle, mutex, socket) must be managed by an RAII wrapper - Never use raw `new` or `delete` — use `std::make_unique<T>()` and `std::make_shared<T>()` - Prefer `std::unique_ptr<T>` for sole ownership; `std::shared_ptr<T>` only when shared ownership is semantically correct - Stack-allocate objects when lifetime is bounded to a scope — heap allocation has overhead - Use `std::lock_guard<std::mutex>` and `std::scoped_lock` — never call `.lock()`/`.unlock()` directly ### Move Semantics - Define the rule of five when a class manages a resource: destructor, copy constructor, copy assignment, move constructor, move assignment - Use `= default` and `= delete` explicitly to control which operations are available - Prefer `= delete` on copy operations for resource-owning types that should only be moved - Pass by value and `std::move` into members in constructors for sink parameters - Use `std::move` when passing an lvalue to a function that accepts `&&` — do not over-use it ### Const Correctness - Mark every member function that does not modify state as `const` - Pass objects by `const&` when the function only reads them; by value when it needs a copy; by `&&` for moves - Use `constexpr` for compile-time constants and functions that can be evaluated at compile time - Use `const` local variables by default; only use non-const when mutation is needed ### Type Safety - Avoid C-style casts — use `static_cast`, `dynamic_cast`, `reinterpret_cast`, `const_cast` explicitly - Use `std::variant<Types...>` instead of union for type-safe tagged unions - Use `std::optional<T>` instead of sentinel values (e.g., `-1`, `nullptr`) for nullable types - Use `std::string_view` for non-owning string parameters instead of `const std::string&` - Use `[[nodiscard]]` on functions whose return values must not be ignored ### Error Handling - Use exceptions for exceptional (unrecoverable) errors; use `std::optional` or `std::expected` (C++23) for expected failures - Throw by value; catch by `const&`: `throw std::runtime_error("msg")` / `catch (const std::exception& e)` - Guarantee exception safety: basic guarantee (no leaks) at minimum, strong guarantee (no state change on failure) when feasible - Never throw from destructors — use `noexcept` on destructors (it is the default) ### Modern STL Usage - Prefer `std::array<T, N>` over C-style arrays - Use range-based `for` loops: `for (const auto& item : container)` - Use STL algorithms (`std::sort`, `std::find_if`, `std::transform`) over hand-written loops - Use `std::string` and `std::string_view` over `char*` - Use `std::span<T>` (C++20) for non-owning views of contiguous sequences ### Templates & Concepts - Use `auto` for template argument deduction in lambdas and generic algorithms - In C++20, use `requires` and Concepts to constrain template parameters: `template<std::integral T>` - Prefer `if constexpr` over SFINAE for compile-time branching in templates - Keep template implementations in header files or explicit instantiation files ### Naming & Style - Classes and types: `PascalCase`; functions and variables: `snake_case`; constants and enum values: `k_PascalCase` or `UPPER_SNAKE_CASE` - Private member variables: `m_name` or `name_` suffix — pick one and be consistent - Header files: `.hpp`; source files: `.cpp`; include guards via `#pragma once` ### Performance - Profile before optimizing — measure, do not guess - Avoid unnecessary copies: pass by `const&` or `std::move`; return by value (NRVO applies) - Use `reserve()` on `std::vector` when the size is known ahead of time - Mark hot-path functions `[[likely]]`/`[[unlikely]]` for branch prediction hints (C++20) ### Anti-patterns - Do not use raw owning pointers — they leak - Do not call `std::shared_ptr` where `std::unique_ptr` suffices — shared ownership is expensive - Do not use `#define` for constants — use `constexpr` - Do not use `goto` — use RAII and structured control flow - Do not silently swallow exceptions with empty `catch (...)` blocks

CLI

npx mindaxis apply cpp-rules --target cursor --scope project

Используется в паках

Не используется ни в одном паке

← Правила