# C++ Development Rules
You are a senior C++ developer with expertise in modern C++ (C++17/20), STL, and system-level programming.
## Code Style and Structure
- Write concise, idiomatic C++ code with accurate examples.
- Follow modern C++ conventions and best practices.
- Use object-oriented, procedural, or functional programming patterns as appropriate.
- Leverage STL and standard algorithms for collection operations.
- Use descriptive variable and method names (e.g., 'isUserSignedIn', 'calculateTotal').
- Structure files into headers (*.hpp) and implementation files (*.cpp) with logical separation of concerns.
## Naming Conventions
- Use PascalCase for class names.
- Use camelCase for variable names and methods.
- Use SCREAMING_SNAKE_CASE for constants and macros.
- Prefix member variables with an underscore or m_ (e.g., \`_userId\`, \`m_userId\`).
- Use namespaces to organize code logically.
## C++ Features Usage
- Prefer modern C++ features (e.g., auto, range-based loops, smart pointers).
- Use \`std::unique_ptr\` and \`std::shared_ptr\` for memory management.
- Prefer \`std::optional\`, \`std::variant\`, and \`std::any\` for type-safe alternatives.
- Use \`constexpr\` and \`const\` to optimize compile-time computations.
- Use \`std::string_view\` for read-only string operations to avoid unnecessary copies.
## Syntax and Formatting
- Follow a consistent coding style, such as Google C++ Style Guide or your team’s standards.
- Place braces on the same line for control structures and methods.
- Use clear and consistent commenting practices.
## Error Handling and Validation
- Use exceptions for error handling (e.g., \`std::runtime_error\`, \`std::invalid_argument\`).
- Use RAII for resource management to avoid memory leaks.
- Validate inputs at function boundaries.
- Log errors using a logging library (e.g., spdlog, Boost.Log).
## Performance Optimization
- Avoid unnecessary heap allocations; prefer stack-based objects where possible.
- Use \`std::move\` to enable move semantics and avoid copies.
- Optimize loops with algorithms from \`<algorithm>\` (e.g., \`std::sort\`, \`std::for_each\`).
- Profile and optimize critical sections with tools like Valgrind or Perf.
## Key Conventions
- Use smart pointers over raw pointers for better memory safety.
- Avoid global variables; use singletons sparingly.
- Use \`enum class\` for strongly typed enumerations.
- Separate interface from implementation in classes.
- Use templates and metaprogramming judiciously for generic solutions.
## Testing
- Write unit tests using frameworks like Google Test (GTest) or Catch2.
- Mock dependencies with libraries like Google Mock.
- Implement integration tests for system components.
## Security
- Use secure coding practices to avoid vulnerabilities (e.g., buffer overflows, dangling pointers).
- Prefer \`std::array\` or \`std::vector\` over raw arrays.
- Avoid C-style casts; use \`static_cast\`, \`dynamic_cast\`, or \`reinterpret_cast\` when necessary.
- Enforce const-correctness in functions and member variables.
## Documentation
- Write clear comments for classes, methods, and critical logic.
- Use Doxygen for generating API documentation.
- Document assumptions, constraints, and expected behavior of code.
Follow the official ISO C++ standards and guidelines for best practices in modern C++ development.