cpp

C++

Purpose

Write C++ where resources are owned by objects, ownership is visible in the type, and undefined behavior is actively hunted with tooling rather than hoped away.

When to Use

• Writing or reviewing C++17 and later.
• Modernizing code that uses raw new/delete or manual resource cleanup.
• Diagnosing memory corruption, leaks, or data races.
• Designing value types with correct copy/move semantics.
• Optimizing hot paths where allocation or copying dominates.

Capabilities

• RAII and ownership modeling with unique_ptr, shared_ptr, and value semantics.
• Move semantics, the rule of zero/five, and copy elision.
• Ranges, views, and algorithm composition.
• Concepts for constrained templates and readable errors.
• Sanitizer-driven debugging: ASan, UBSan, TSan.

Inputs

• Source, build system (CMake preferred), and target standard.
• Platform and toolchain constraints.
• Performance budget for hot paths.

Outputs

• Code with no raw owning pointers and no manual delete.
• A CMake configuration with warnings-as-errors and sanitizer build types.
• Benchmarks for any change justified on performance grounds.

Workflow

1. Establish ownership — Every resource has exactly one owner. Express it in the type: value, unique_ptr, or a documented non-owning T*/span.
2. Apply the rule of zero — If a class needs a destructor, it probably should not also hold business logic.
3. Constrain templates — Use concepts; unconstrained templates produce unreadable errors and accept nonsense.
4. Sanitize — Build and run the test suite under ASan+UBSan, then TSan separately.
5. Measure before optimizing — Profile, change one thing, benchmark again.

Best Practices

• Prefer values and references. Reach for shared_ptr only when ownership is genuinely shared — it is not a default.
• Pass by const& for large read-only inputs; pass by value and std::move when you intend to store.
• Never return a reference or string_view to a temporary. This is the most common lifetime bug in modern C++.
• Compile with -Wall -Wextra -Wpedantic -Werror. Warnings in C++ are usually latent bugs.
• Use std::span instead of pointer+length parameter pairs.
• Mark single-argument constructors explicit unless implicit conversion is genuinely desired.