Claude-skill-registry C++ Ecosystem

<purpose> Provide comprehensive patterns for Modern C++ (C++11-23) language, CMake build system, and toolchain configuration. </purpose>

<cplusplus_language> <modern_features> <decision_tree name="when_to_use"> <question>Are you working with modern C++ features like smart pointers, move semantics, or ranges?</question> <if_yes>Apply modern C++ patterns for safer, more efficient code</if_yes> <if_no>Consider refactoring legacy code to modern C++ standards</if_no> </decision_tree>

<concept name="move_semantics">
  <description>Transfer ownership of resources without copying. Introduced in C++11.</description>
  <example>
    std::vector&lt;int&gt; v1 = {1, 2, 3};
    std::vector&lt;int&gt; v2 = std::move(v1); // v1 is now empty
  </example>
  <use>Use std::move for expensive-to-copy objects when ownership transfer is intended</use>
</concept>

<concept name="smart_pointers">
  <description>RAII-based automatic memory management</description>
  <types>
    <type name="unique_ptr">Exclusive ownership, zero overhead</type>
    <type name="shared_ptr">Shared ownership with reference counting</type>
    <type name="weak_ptr">Non-owning observer of shared_ptr</type>
  </types>
  <example>
    auto ptr = std::make_unique&lt;MyClass&gt;(args);
    auto shared = std::make_shared&lt;MyClass&gt;(args);
  </example>
</concept>

<concept name="constexpr">
  <description>Compile-time computation</description>
  <evolution>
    <version name="C++11">Simple expressions only</version>
    <version name="C++14">Loops and local variables allowed</version>
    <version name="C++17">if constexpr for compile-time branching</version>
    <version name="C++20">constexpr std::vector, std::string</version>
  </evolution>
</concept>

<concept name="auto_type_deduction">
  <description>Compiler deduces type from initializer</description>
  <example>
    auto x = 42;                    // int
    auto vec = std::vector&lt;int&gt;{};  // std::vector&lt;int&gt;
    auto [key, value] = pair;       // structured bindings (C++17)
  </example>
</concept>

<concept name="lambdas">
  <description>Anonymous function objects</description>
  <example>
    auto add = [](int a, int b) { return a + b; };
    auto capture_by_ref = [&amp;x]() { x++; };
    auto capture_by_val = [=]() { return x; };
    auto generic = [](auto a, auto b) { return a + b; };  // C++14
  </example>
</concept>

<concept name="concepts">
  <description>Constraints on template parameters (C++20)</description>
  <example>
    template&lt;typename T&gt;
    concept Addable = requires(T a, T b) { a + b; };

    template&lt;Addable T&gt;
    T add(T a, T b) { return a + b; }
  </example>
</concept>

<concept name="ranges">
  <description>Composable range operations (C++20)</description>
  <example>
    auto result = numbers
    | std::views::filter([](int n) { return n % 2 == 0; })
    | std::views::transform([](int n) { return n * 2; });
  </example>
</concept>

<concept name="modules">
  <description>C++20 modules for faster compilation and better encapsulation</description>
  <example>
    // math.cppm (module interface)
    export module math;
    export int add(int a, int b) { return a + b; }

    // main.cpp
    import math;
    int main() { return add(1, 2); }
  </example>
  <note>Requires CMake 3.28+ with CMAKE_CXX_SCAN_FOR_MODULES</note>
</concept>

<concept name="coroutines">
  <description>C++20 coroutines for async and generator patterns</description>
  <example>
    #include &lt;coroutine&gt;

    generator&lt;int&gt; range(int start, int end) {
      for (int i = start; i &lt; end; ++i) {
        co_yield i;
      }
    }

    task&lt;int&gt; async_compute() {
      co_return co_await some_async_operation();
    }
  </example>
  <note>Requires coroutine library (cppcoro, libcoro, or custom promise types)</note>
</concept>

<concept name="three_way_comparison">
  <description>C++20 spaceship operator for simplified comparisons</description>
  <example>
    struct Point {
      int x, y;
      auto operator&lt;=&gt;(const Point&amp;) const = default;
    };

    // Automatically generates ==, !=, &lt;, &gt;, &lt;=, &gt;=
  </example>
</concept>

<concept name="vocabulary_types">
  <description>C++17 vocabulary types for safer value handling</description>
  <types>
    <type name="std::optional">Maybe-value container, replaces nullable pointers</type>
    <type name="std::variant">Type-safe union, replaces raw unions</type>
    <type name="std::any">Type-erased container for any single value</type>
  </types>
  <example>
    std::optional&lt;int&gt; find_value(const std::vector&lt;int&gt;&amp; v, int target) {
      auto it = std::find(v.begin(), v.end(), target);
      if (it != v.end()) return *it;
      return std::nullopt;
    }

    std::variant&lt;int, std::string, double&gt; data = 42;
    std::visit([](auto&amp;&amp; val) { std::cout &lt;&lt; val; }, data);
  </example>
</concept>

</modern_features>

<concurrency> <decision_tree name="when_to_use"> <question>Do you need concurrent or parallel execution?</question> <if_yes>Use std::thread for explicit control, std::async for task-based parallelism, or atomics for lock-free synchronization</if_yes> <if_no>Use single-threaded sequential execution for simplicity</if_no> </decision_tree>

<concept name="threads">
  <description>Thread creation and management</description>
  <example>
    std::thread t([]{ /* work */ });
    t.join();  // or t.detach()

    auto future = std::async(std::launch::async, []{ return 42; });
    int result = future.get();
  </example>
</concept>

<concept name="mutexes">
  <description>Mutual exclusion for shared data</description>
  <example>
    std::mutex mtx;
    std::lock_guard&lt;std::mutex&gt; lock(mtx);  // RAII lock

    std::shared_mutex rw_mtx;
    std::shared_lock&lt;std::shared_mutex&gt; read_lock(rw_mtx); // multiple readers
    std::unique_lock&lt;std::shared_mutex&gt; write_lock(rw_mtx); // exclusive writer
  </example>
</concept>

<concept name="atomics">
  <description>Lock-free atomic operations</description>
  <example>
    std::atomic&lt;int&gt; counter{0};
    counter.fetch_add(1, std::memory_order_relaxed);
    counter.store(10, std::memory_order_release);
    int val = counter.load(std::memory_order_acquire);
  </example>
</concept>

<concept name="condition_variables">
  <description>Thread synchronization primitives</description>
  <example>
    std::condition_variable cv;
    std::mutex mtx;
    bool ready = false;

    // Waiting thread
    std::unique_lock&lt;std::mutex&gt; lock(mtx);
    cv.wait(lock, []{ return ready; });

    // Notifying thread
    {
      std::lock_guard&lt;std::mutex&gt; lock(mtx);
      ready = true;
    }
    cv.notify_one();
  </example>
</concept>

<anti_patterns>
  <avoid name="data_races">
    <description>Accessing shared data without synchronization</description>
    <instead>Use mutex, atomic, or immutable data</instead>
  </avoid>
  <avoid name="deadlocks">
    <description>Circular lock dependencies</description>
    <instead>Use std::scoped_lock for multiple mutexes, consistent lock ordering</instead>
  </avoid>
</anti_patterns>

</concurrency> <patterns> <pattern name="raii"> <description>Resource Acquisition Is Initialization - bind resource lifetime to object lifetime</description> <example> class FileHandle { FILE* file_; public: explicit FileHandle(const char* path) : file_(fopen(path, "r")) {} ~FileHandle() { if (file_) fclose(file_); } FileHandle(const FileHandle&amp;) = delete; FileHandle&amp; operator=(const FileHandle&amp;) = delete; }; </example> <use_case>Managing resources: files, sockets, locks, memory</use_case> </pattern>

<pattern name="rule_of_zero">
  <description>Prefer classes that do not define special member functions</description>
  <example>
    class Person {
      std::string name_;
      std::vector&lt;std::string&gt; addresses_;
      // No destructor, copy/move constructors, or assignment operators needed
    };
  </example>
  <use_case>Use smart pointers and standard containers; let compiler generate defaults</use_case>
</pattern>

<pattern name="rule_of_five">
  <description>If you define one of destructor, copy/move constructor, or copy/move assignment, define all five</description>
  <example>
    class Resource {
      int* data_;
    public:
      Resource();
      ~Resource();
      Resource(const Resource&amp;);
      Resource(Resource&amp;&amp;) noexcept;
      Resource&amp; operator=(const Resource&amp;);
      Resource&amp; operator=(Resource&amp;&amp;) noexcept;
    };
  </example>
  <use_case>Classes managing raw resources directly</use_case>
</pattern>

<pattern name="pimpl">
  <description>Pointer to Implementation - hide implementation details and reduce compilation dependencies</description>
  <example>
    // header
    class Widget {
      class Impl;
      std::unique_ptr&lt;Impl&gt; pimpl_;
    public:
      Widget();
      ~Widget();
      void doSomething();
    };

    // source
    class Widget::Impl {
      // implementation details
    };
  </example>
  <use_case>Reducing compile times, ABI stability, hiding implementation</use_case>
</pattern>

<pattern name="crtp">
  <description>Curiously Recurring Template Pattern - static polymorphism</description>
  <example>
    template&lt;typename Derived&gt;
    class Base {
    public:
      void interface() {
        static_cast&lt;Derived*&gt;(this)-&gt;implementation();
      }
    };

    class Derived : public Base&lt;Derived&gt; {
    public:
      void implementation() { /_ ... _/ }
    };
  </example>
  <use_case>Static polymorphism, mixin classes, compile-time polymorphism</use_case>
</pattern>

<pattern name="type_erasure">
  <description>Hide concrete types behind a uniform interface</description>
  <example>
    class AnyCallable {
      struct Concept {
        virtual ~Concept() = default;
        virtual void call() = 0;
      };
      template&lt;typename T&gt;
      struct Model : Concept {
        T obj_;
        void call() override { obj_(); }
      };
      std::unique_ptr&lt;Concept&gt; ptr_;
    public:
      template&lt;typename T&gt;
      AnyCallable(T obj) : ptr_(std::make_unique&lt;Model&lt;T&gt;&gt;(std::move(obj))) {}
    };
  </example>
  <use_case>std::function, std::any, runtime polymorphism without inheritance</use_case>
</pattern>

</patterns>

<anti_patterns> <avoid name="raw_pointer_ownership"> <description>Using raw pointers for ownership</description> <instead>Use std::unique_ptr or std::shared_ptr</instead> </avoid>

<avoid name="manual_memory_management">
  <description>Using new/delete directly</description>
  <instead>Use std::make_unique/std::make_shared</instead>
</avoid>

<avoid name="c_style_casts">
  <description>Using (Type)value casts</description>
  <instead>Use static_cast, dynamic_cast, const_cast, or reinterpret_cast</instead>
</avoid>

<avoid name="using_namespace_in_headers">
  <description>Using using namespace std; in headers</description>
  <instead>Use fully qualified names or limited using declarations in source files</instead>
</avoid>

<avoid name="throwing_in_destructors">
  <description>Throwing exceptions in destructors</description>
  <instead>Mark destructors noexcept, handle errors internally</instead>
</avoid>

<avoid name="const_cast_abuse">
  <description>Using const_cast to remove const from data you do not own</description>
  <instead>Fix the design to avoid needing const_cast</instead>
</avoid>

</anti_patterns> </cplusplus_language>

<cmake> <decision_tree name="when_to_use"> <question>Are you building a C++ project with dependencies and multiple targets?</question> <if_yes>Use CMake for cross-platform, modern build configuration</if_yes> <if_no>Use simple Makefile for single-file projects or prototypes</if_no> </decision_tree>

<project_structure> <standard_layout> . ├── CMakeLists.txt ├── cmake/ │ └── modules/ ├── src/ │ ├── CMakeLists.txt │ ├── main.cpp │ └── lib/ ├── include/ │ └── project/ ├── tests/ │ ├── CMakeLists.txt │ └── test_*.cpp └── build/ </standard_layout> </project_structure>

<cmake_patterns> <pattern name="modern_cmake"> <description>Target-based CMake (3.0+)</description> <example> cmake_minimum_required(VERSION 3.20) project(MyProject VERSION 1.0.0 LANGUAGES CXX)

    set(CMAKE_CXX_STANDARD 20)
    set(CMAKE_CXX_STANDARD_REQUIRED ON)
    set(CMAKE_CXX_EXTENSIONS OFF)

    add_library(mylib STATIC src/mylib.cpp)
    target_include_directories(mylib PUBLIC include)
    target_compile_features(mylib PUBLIC cxx_std_20)

    add_executable(myapp src/main.cpp)
    target_link_libraries(myapp PRIVATE mylib)
  </example>
</pattern>

<pattern name="find_package">
  <description>Finding and using external dependencies</description>
  <example>
    find_package(Threads REQUIRED)
    find_package(GTest REQUIRED)

    target_link_libraries(myapp PRIVATE Threads::Threads)
    target_link_libraries(mytests PRIVATE GTest::gtest GTest::gtest_main)
  </example>
</pattern>

<pattern name="compiler_options">
  <description>Setting compiler warnings and options</description>
  <example>
    add_library(project_warnings INTERFACE)
    target_compile_options(project_warnings INTERFACE
      $&lt;$&lt;CXX_COMPILER_ID:GNU,Clang&gt;:
        -Wall -Wextra -Wpedantic -Werror
        -Wshadow -Wnon-virtual-dtor -Wold-style-cast
        -Wcast-align -Wunused -Woverloaded-virtual
        -Wconversion -Wsign-conversion -Wnull-dereference
      &gt;
    )
  </example>
</pattern>

</cmake_patterns>

<commands> <command name="cmake -B build -G Ninja">Configure with Ninja generator</command> <command name="cmake --build build">Build the project</command> <command name="cmake --build build --target test">Run tests</command> <command name="cmake --build build --config Release">Build in Release mode</command> <command name="cmake --install build --prefix /usr/local">Install the project</command> </commands> </cmake> <toolchain> <compilers> <compiler name="clang"> <description>LLVM C++ compiler</description> <flags> <flag name="-std=c++20">Enable C++20 standard</flag> <flag name="-stdlib=libc++">Use LLVM libc++ standard library</flag> <flag name="-Wall -Wextra -Wpedantic">Enable comprehensive warnings</flag> <flag name="-Werror">Treat warnings as errors</flag> <flag name="-fsanitize=address,undefined">Enable sanitizers</flag> </flags> </compiler>

<compiler name="gcc">
  <description>GNU C++ compiler</description>
  <flags>
    <flag name="-std=c++20">Enable C++20 standard</flag>
    <flag name="-Wall -Wextra -Wpedantic">Enable comprehensive warnings</flag>
    <flag name="-Werror">Treat warnings as errors</flag>
    <flag name="-fsanitize=address,undefined">Enable sanitizers</flag>
    <flag name="-fanalyzer">Enable static analysis (GCC 10+)</flag>
  </flags>
</compiler>

</compilers>

<clang_tidy> <description>Static analysis and linting tool</description> <usage>clang-tidy src/*.cpp -- -std=c++20</usage>

<configuration>
  <file_reference>.clang-tidy</file_reference>
  Checks: >
    -*,
    bugprone-*,
    clang-analyzer-*,
    cppcoreguidelines-*,
    modernize-*,
    performance-*,
    readability-*,
    -modernize-use-trailing-return-type

  WarningsAsErrors: '_'
  HeaderFilterRegex: '._'

  CheckOptions:
    - key: readability-identifier-naming.ClassCase
      value: CamelCase
    - key: readability-identifier-naming.FunctionCase
      value: camelBack
    - key: readability-identifier-naming.VariableCase
      value: lower_case
</configuration>

<common_checks>
  <check name="modernize-use-nullptr">Replace NULL with nullptr</check>
  <check name="modernize-use-auto">Use auto where appropriate</check>
  <check name="modernize-use-override">Use override keyword</check>
  <check name="modernize-loop-convert">Convert C-style loops to range-based</check>
  <check name="cppcoreguidelines-owning-memory">Check ownership semantics</check>
  <check name="bugprone-use-after-move">Detect use-after-move bugs</check>
  <check name="performance-unnecessary-copy-initialization">Detect unnecessary copies</check>
</common_checks>

</clang_tidy>

<clang_format> <description>Code formatting tool</description> <usage>clang-format -i src/.cpp include/.hpp</usage>

<configuration>
  <file_reference>.clang-format</file_reference>
  BasedOnStyle: LLVM
  IndentWidth: 4
  ColumnLimit: 100
  Language: Cpp
  Standard: c++20
  AccessModifierOffset: -4
  AlignAfterOpenBracket: Align
  AllowShortFunctionsOnASingleLine: Inline
  BreakBeforeBraces: Attach
  IncludeBlocks: Regroup
  IncludeCategories:
    - Regex: '^<.*>'
      Priority: 1
    - Regex: '^".*"'
      Priority: 2
  PointerAlignment: Left
  SortIncludes: CaseSensitive
</configuration>

</clang_format>

<sanitizers> <description>Runtime error detection tools</description>

<sanitizer name="AddressSanitizer">
  <description>Detects memory errors (buffer overflow, use-after-free)</description>
  <flags>-fsanitize=address -fno-omit-frame-pointer</flags>
  <cmake>
    target_compile_options(myapp PRIVATE -fsanitize=address -fno-omit-frame-pointer)
    target_link_options(myapp PRIVATE -fsanitize=address)
  </cmake>
</sanitizer>

<sanitizer name="UndefinedBehaviorSanitizer">
  <description>Detects undefined behavior (signed overflow, null dereference)</description>
  <flags>-fsanitize=undefined</flags>
  <cmake>
    target_compile_options(myapp PRIVATE -fsanitize=undefined)
    target_link_options(myapp PRIVATE -fsanitize=undefined)
  </cmake>
</sanitizer>

<sanitizer name="ThreadSanitizer">
  <description>Detects data races and deadlocks</description>
  <flags>-fsanitize=thread</flags>
  <note>Cannot be combined with AddressSanitizer</note>
</sanitizer>

<sanitizer name="MemorySanitizer">
  <description>Detects uninitialized memory reads (Clang only)</description>
  <flags>-fsanitize=memory</flags>
  <note>Requires all code and libraries to be instrumented</note>
</sanitizer>

<cmake_preset>
  # CMakePresets.json sanitizer configuration
  {
    "configurePresets": [{
      "name": "sanitize",
      "cacheVariables": {
        "CMAKE_CXX_FLAGS": "-fsanitize=address,undefined -fno-omit-frame-pointer"
      }
    }]
  }
</cmake_preset>

</sanitizers> </toolchain> <testing> <decision_tree name="when_to_use"> <question>Do you need unit testing for C++ code?</question> <if_yes>Use GoogleTest for comprehensive testing features or Catch2 for header-only simplicity</if_yes> <if_no>Consider adding tests to improve code quality and maintainability</if_no> </decision_tree> <googletest> <description>Google Test framework</description> <cmake_integration> enable_testing() find_package(GTest REQUIRED)

  add_executable(tests tests/test_main.cpp)
  target_link_libraries(tests PRIVATE GTest::gtest GTest::gtest_main)

  include(GoogleTest)
  gtest_discover_tests(tests)
</cmake_integration>

<example>
  #include &lt;gtest/gtest.h&gt;

  TEST(MyTest, BasicAssertion) {
    EXPECT_EQ(1 + 1, 2);
  }

  TEST(MyTest, StringComparison) {
    std::string s = "hello";
    EXPECT_STREQ(s.c_str(), "hello");
  }

  class MyFixture : public ::testing::Test {
  protected:
    void SetUp() override { /_ setup _/ }
    void TearDown() override { /_ cleanup _/ }
  };

  TEST_F(MyFixture, FixtureTest) {
    EXPECT_TRUE(true);
  }
</example>

</googletest> <catch2> <description>Catch2 test framework</description> <cmake_integration> find_package(Catch2 3 REQUIRED)

  add_executable(tests tests/test_main.cpp)
  target_link_libraries(tests PRIVATE Catch2::Catch2WithMain)

  include(CTest)
  include(Catch)
  catch_discover_tests(tests)
</cmake_integration>

<example>
  #include &lt;catch2/catch_test_macros.hpp&gt;

  TEST_CASE("Basic arithmetic", "[math]") {
    REQUIRE(1 + 1 == 2);
    CHECK(2 * 2 == 4);
  }

  TEST_CASE("String operations", "[string]") {
    std::string s = "hello";

    SECTION("length") {
      REQUIRE(s.length() == 5);
    }

    SECTION("comparison") {
      REQUIRE(s == "hello");
    }
  }
</example>

</catch2> </testing>

<context7_integration> <description>Use Context7 MCP for up-to-date C++ documentation</description>

<cplusplus_libraries> <library name="cppreference" id="/websites/cppreference_com" /> <library name="CMake" id="/Kitware/CMake" /> <library name="GoogleTest" id="/google/googletest" /> <library name="Catch2" id="/catchorg/Catch2" /> </cplusplus_libraries>

<usage_patterns> <pattern name="language_reference"> <step>resolve-library-id libraryName="cppreference"</step> <step>get-library-docs context7CompatibleLibraryID="/websites/cppreference_com" topic="std::unique_ptr"</step> </pattern>

<pattern name="cmake_reference">
  <step>get-library-docs context7CompatibleLibraryID="/Kitware/CMake" topic="target_link_libraries"</step>
</pattern>

<pattern name="testing_reference">
  <step>get-library-docs context7CompatibleLibraryID="/google/googletest" topic="assertions"</step>
</pattern>

</usage_patterns> </context7_integration>

<best_practices> <practice priority="critical">Use smart pointers instead of raw pointers for ownership</practice> <practice priority="critical">Enable -Wall -Wextra -Werror for all builds</practice> <practice priority="critical">Run clang-tidy before committing</practice> <practice priority="critical">Format with clang-format for consistent style</practice> <practice priority="standard">Prefer const correctness throughout</practice> <practice priority="standard">Use noexcept for move constructors and destructors</practice> <practice priority="standard">Prefer constexpr for compile-time computation</practice> <practice priority="standard">Use std::string_view for non-owning string references</practice> <practice priority="standard">Prefer range-based for loops over index-based</practice> <practice priority="standard">Use structured bindings for tuple/pair access</practice> <practice priority="standard">Document public API with Doxygen comments</practice> <practice priority="standard">Write unit tests alongside implementation</practice> </best_practices>

<workflow> <phase name="analyze"> <objective>Understand C++ code requirements</objective> <step>1. Check CMakeLists.txt for build configuration</step> <step>2. Review existing code patterns and standards</step> <step>3. Identify memory management requirements</step> </phase> <phase name="implement"> <objective>Write modern, safe C++ code</objective> <step>1. Use RAII and smart pointers</step> <step>2. Follow C++ Core Guidelines</step> <step>3. Prefer standard library over raw implementations</step> </phase> <phase name="validate"> <objective>Verify C++ code correctness</objective> <step>1. Build with warnings enabled</step> <step>2. Run static analysis tools</step> <step>3. Execute tests with sanitizers</step> </phase> </workflow>

<error_escalation> <level severity="low"> <example>Compiler warning about unused variable</example> <action>Fix warning, maintain clean build</action> </level> <level severity="medium"> <example>Compilation error</example> <action>Fix error, verify with full build</action> </level> <level severity="high"> <example>Memory leak or undefined behavior detected</example> <action>Stop, require safe memory management</action> </level> <level severity="critical"> <example>Buffer overflow or security vulnerability</example> <action>Block operation, require immediate fix</action> </level> </error_escalation>

<constraints> <must>Use smart pointers for memory management</must> <must>Enable compiler warnings (-Wall -Wextra)</must> <must>Follow C++ Core Guidelines</must> <avoid>Raw pointers for ownership</avoid> <avoid>Manual memory management when smart pointers suffice</avoid> <avoid>Undefined behavior</avoid> </constraints>

<related_agents> <agent name="design">Architecture design for C++ class hierarchies and template metaprogramming</agent> <agent name="docs">Doxygen documentation and API reference generation</agent> <agent name="execute">CMake configuration and C++ implementation tasks</agent> <agent name="bug">Debugging memory leaks, segfaults, and undefined behavior</agent> </related_agents>

<related_skills> <skill name="serena-usage">Symbol operations for C++ code navigation and refactoring</skill> <skill name="context7-usage">C++ documentation via /websites/cppreference_com and CMake docs via /Kitware/CMake</skill> <skill name="investigation-patterns">Debugging with sanitizers, valgrind, and gdb</skill> <skill name="technical-documentation">Creating library documentation with Doxygen</skill> </related_skills>