C++ Development Guidelines

Code Style and Structure

• Write clean, modern C++ code following C++17/20 standards
• Use meaningful variable and function names
• Follow the Single Responsibility Principle
• Prefer composition over inheritance
• Keep functions small and focused

Naming Conventions

• Use PascalCase for classes and structs
• Use camelCase for functions, variables, and methods
• Use SCREAMING_SNAKE_CASE for constants and macros
• Use snake_case for namespaces
• Prefix member variables with

  m_

  or use trailing underscore

Memory Management

Smart Pointers

• Use

  std::unique_ptr

  for exclusive ownership
• Use

  std::shared_ptr

  only when shared ownership is required
• Use

  std::weak_ptr

  to break circular references
• Avoid raw owning pointers

RAII (Resource Acquisition Is Initialization)

• Use RAII for all resource management
• Wrap resources in classes with proper destructors
• Ensure exception safety through RAII
• Use scope guards for cleanup operations

Best Practices

• Prefer stack allocation over heap allocation
• Use

  std::make_unique

  and

  std::make_shared

• Avoid

  new

  and

  delete

  in application code
• Use containers instead of raw arrays

Modern C++ Features

C++17 Features

• Use structured bindings for tuple unpacking
• Use

  std::optional

  for values that may not exist
• Use

  std::variant

  for type-safe unions
• Use

  if constexpr

  for compile-time conditionals
• Use

  std::string_view

  for non-owning string references

C++20 Features

• Use concepts for template constraints
• Use ranges for cleaner algorithms
• Use

  std::span

  for non-owning array views
• Use coroutines for asynchronous operations
• Use modules for faster compilation (when supported)

Error Handling

• Use exceptions for error handling
• Define custom exception types for domain-specific errors
• Use

  noexcept

  for functions that don't throw
• Catch exceptions by const reference
• Provide strong exception guarantees where possible

Performance

• Use

  const

  and

  constexpr

  liberally
• Prefer move semantics with

  std::move

• Use perfect forwarding with

  std::forward

• Avoid unnecessary copies
• Profile before optimizing
• Use

  inline

  for small frequently-called functions

Security

Buffer Safety

• Use

  std::array

  instead of C-style arrays
• Use

  std::vector

  with bounds checking
• Prefer

  std::string

  over C-style strings
• Use

  std::span

  for array views

Type Safety

• Avoid C-style casts; use

  static_cast

  ,

  dynamic_cast

  , etc.
• Use

  enum class

  instead of plain enums
• Use

  nullptr

  instead of

  NULL

• Enable compiler warnings and treat them as errors

Concurrency

• Use

  std::thread

  and

  std::jthread

  for threading
• Use

  std::mutex

  and

  std::lock_guard

  for synchronization
• Use

  std::atomic

  for lock-free operations
• Prefer

  std::async

  for simple async operations
• Use condition variables for thread coordination

Testing

• Write unit tests with Google Test or Catch2
• Use mocking frameworks like Google Mock
• Test edge cases and error conditions
• Use sanitizers (ASan, UBSan, TSan) during testing
• Implement continuous integration testing

Documentation

• Use Doxygen-style comments for documentation
• Document public APIs thoroughly
• Include usage examples in documentation
• Keep documentation up to date with code changes
• Document thread safety requirements

Build System

• Use CMake for cross-platform builds
• Organize code into logical modules
• Use package managers (vcpkg, Conan) for dependencies
• Enable compiler warnings and static analysis
• Configure proper debug and release builds