awesome-agv: Skill for Claude Code

C++ Idioms and Patterns

Modern C++ (17/20/23) rewards RAII, value semantics, and zero-cost abstractions. Lean into the type system and smart pointers. Idiomatic C++ = safe, deterministic, performant.

Scope: C++ coding idioms. Test naming: .agents/rules/testing-strategy.md.

Ownership and Memory

1. RAII — resources tied to object lifetime. No manual new/delete.

2. std::unique_ptr for exclusive ownership, std::shared_ptr only when sharing is necessary.

3. Move semantics — prefer moving over copying for expensive types.

4. Rule of Five/Zero:

   // ✅ Rule of Zero — let compiler-generated defaults work
   class TaskService {
       std::unique_ptr<TaskStorage> storage_;
       std::shared_ptr<Logger> logger_;
   public:
       // No destructor, copy/move constructors needed — smart pointers handle it
       explicit TaskService(std::unique_ptr<TaskStorage> storage, std::shared_ptr<Logger> logger)
           : storage_(std::move(storage)), logger_(std::move(logger)) {}
   };
   
   // ✅ Rule of Five — when managing raw resources (rare)
   class Buffer {
       char* data_;
       size_t size_;
   public:
       ~Buffer();                                   // Destructor
       Buffer(const Buffer&);                       // Copy constructor
       Buffer& operator=(const Buffer&);            // Copy assignment
       Buffer(Buffer&&) noexcept;                   // Move constructor
       Buffer& operator=(Buffer&&) noexcept;        // Move assignment
   };
   

5. Pass by value and move for sink parameters:

   // ✅ Sink parameter — takes ownership
   void addTask(Task task) {
       tasks_.push_back(std::move(task));
   }
   
   // ✅ Read-only — const reference
   void printTask(const Task& task);
   
   // ❌ Never pass smart pointers unless transferring ownership
   void processTask(std::shared_ptr<Task> task);  // Unnecessary ref-count bump
   
   // ✅ If function doesn't need ownership
   void processTask(const Task& task);