[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6HS93VMVGHAKAM8SB5N7RYN":3,"skill-same:01M6HS93VMVGHAKAM8SB5N7RYN":70},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":22,"publishedAt":44,"linkOnly":45,"markdownContent":46,"markdownBody":47,"frontMatter":48,"refName":49,"commitSha":50,"skillDirectory":51,"forksCount":52,"repositoryHtmlUrl":53,"repositoryHomepageUrl":6,"ownerHtmlUrl":54,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":55,"install":56,"resources":69},"01M6HS93VMVGHAKAM8SB5N7RYN","memory-safety-patterns",null,"Implement memory-safe programming with RAII, ownership, smart pointers, and resource management across Rust, C++, and C. Use when writing safe systems code, managing resources, or preventing memory bugs.","welflau\u002Fai-dev-system","welflau","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F7010385?v=4","01M6HPTDGF18RFY07M229P8CTM","01M6HPTDMRMZCJPYBFEA9XVVYT",3,"MIT","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fexternal_plugins\u002Fsystems-programming\u002Fskills\u002Fmemory-safety-patterns\u002FSKILL.md",[17],{"categoryNo":18,"categoryName":19,"taxonomyType":20,"taxonomyTypeDesc":21},"01JBSEEDCAT000000000000030","开发工程师","PROFESSION","适用职业",[23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43],"memory","memory safety","Safety","memory safety patterns","patterns","when","writing","bugs","resource management","with","raii","resources","systems","across","c++","use","programming","code","implement","rust","safe","2026-11-10 10:12:30",false,"---\nname: memory-safety-patterns\ndescription: Implement memory-safe programming with RAII, ownership, smart pointers, and resource management across Rust, C++, and C. Use when writing safe systems code, managing resources, or preventing memory bugs.\n---\n\n# Memory Safety Patterns\n\nCross-language patterns for memory-safe programming including RAII, ownership, smart pointers, and resource management.\n\n## When to Use This Skill\n\n- Writing memory-safe systems code\n- Managing resources (files, sockets, memory)\n- Preventing use-after-free and leaks\n- Implementing RAII patterns\n- Choosing between languages for safety\n- Debugging memory issues\n\n## Core Concepts\n\n### 1. Memory Bug Categories\n\n| Bug Type | Description | Prevention |\n|----------|-------------|------------|\n| **Use-after-free** | Access freed memory | Ownership, RAII |\n| **Double-free** | Free same memory twice | Smart pointers |\n| **Memory leak** | Never free memory | RAII, GC |\n| **Buffer overflow** | Write past buffer end | Bounds checking |\n| **Dangling pointer** | Pointer to freed memory | Lifetime tracking |\n| **Data race** | Concurrent unsynchronized access | Ownership, Sync |\n\n### 2. Safety Spectrum\n\n```\nManual (C) → Smart Pointers (C++) → Ownership (Rust) → GC (Go, Java)\nLess safe                                              More safe\nMore control                                           Less control\n```\n\n## Patterns by Language\n\n### Pattern 1: RAII in C++\n\n```cpp\n\u002F\u002F RAII: Resource Acquisition Is Initialization\n\u002F\u002F Resource lifetime tied to object lifetime\n\n#include \u003Cmemory>\n#include \u003Cfstream>\n#include \u003Cmutex>\n\n\u002F\u002F File handle with RAII\nclass FileHandle {\npublic:\n    explicit FileHandle(const std::string& path)\n        : file_(path) {\n        if (!file_.is_open()) {\n            throw std::runtime_error(\"Failed to open file\");\n        }\n    }\n\n    \u002F\u002F Destructor automatically closes file\n    ~FileHandle() = default; \u002F\u002F fstream closes in its destructor\n\n    \u002F\u002F Delete copy (prevent double-close)\n    FileHandle(const FileHandle&) = delete;\n    FileHandle& operator=(const FileHandle&) = delete;\n\n    \u002F\u002F Allow move\n    FileHandle(FileHandle&&) = default;\n    FileHandle& operator=(FileHandle&&) = default;\n\n    void write(const std::string& data) {\n        file_ \u003C\u003C data;\n    }\n\nprivate:\n    std::fstream file_;\n};\n\n\u002F\u002F Lock guard (RAII for mutexes)\nclass Database {\npublic:\n    void update(const std::string& key, const std::string& value) {\n        std::lock_guard\u003Cstd::mutex> lock(mutex_); \u002F\u002F Released on scope exit\n        data_[key] = value;\n    }\n\n    std::string get(const std::string& key) {\n        std::shared_lock\u003Cstd::shared_mutex> lock(shared_mutex_);\n        return data_[key];\n    }\n\nprivate:\n    std::mutex mutex_;\n    std::shared_mutex shared_mutex_;\n    std::map\u003Cstd::string, std::string> data_;\n};\n\n\u002F\u002F Transaction with rollback (RAII)\ntemplate\u003Ctypename T>\nclass Transaction {\npublic:\n    explicit Transaction(T& target)\n        : target_(target), backup_(target), committed_(false) {}\n\n    ~Transaction() {\n        if (!committed_) {\n            target_ = backup_; \u002F\u002F Rollback\n        }\n    }\n\n    void commit() { committed_ = true; }\n\n    T& get() { return target_; }\n\nprivate:\n    T& target_;\n    T backup_;\n    bool committed_;\n};\n```\n\n### Pattern 2: Smart Pointers in C++\n\n```cpp\n#include \u003Cmemory>\n\n\u002F\u002F unique_ptr: Single ownership\nclass Engine {\npublic:\n    void start() { \u002F* ... *\u002F }\n};\n\nclass Car {\npublic:\n    Car() : engine_(std::make_unique\u003CEngine>()) {}\n\n    void start() {\n        engine_->start();\n    }\n\n    \u002F\u002F Transfer ownership\n    std::unique_ptr\u003CEngine> extractEngine() {\n        return std::move(engine_);\n    }\n\nprivate:\n    std::unique_ptr\u003CEngine> engine_;\n};\n\n\u002F\u002F shared_ptr: Shared ownership\nclass Node {\npublic:\n    std::string data;\n    std::shared_ptr\u003CNode> next;\n\n    \u002F\u002F Use weak_ptr to break cycles\n    std::weak_ptr\u003CNode> parent;\n};\n\nvoid sharedPtrExample() {\n    auto node1 = std::make_shared\u003CNode>();\n    auto node2 = std::make_shared\u003CNode>();\n\n    node1->next = node2;\n    node2->parent = node1; \u002F\u002F Weak reference prevents cycle\n\n    \u002F\u002F Access weak_ptr\n    if (auto parent = node2->parent.lock()) {\n        \u002F\u002F parent is valid shared_ptr\n    }\n}\n\n\u002F\u002F Custom deleter for resources\nclass Socket {\npublic:\n    static void close(int* fd) {\n        if (fd && *fd >= 0) {\n            ::close(*fd);\n            delete fd;\n        }\n    }\n};\n\nauto createSocket() {\n    int fd = socket(AF_INET, SOCK_STREAM, 0);\n    return std::unique_ptr\u003Cint, decltype(&Socket::close)>(\n        new int(fd),\n        &Socket::close\n    );\n}\n\n\u002F\u002F make_unique\u002Fmake_shared best practices\nvoid bestPractices() {\n    \u002F\u002F Good: Exception safe, single allocation\n    auto ptr = std::make_shared\u003CWidget>();\n\n    \u002F\u002F Bad: Two allocations, not exception safe\n    std::shared_ptr\u003CWidget> ptr2(new Widget());\n\n    \u002F\u002F For arrays\n    auto arr = std::make_unique\u003Cint[]>(10);\n}\n```\n\n### Pattern 3: Ownership in Rust\n\n```rust\n\u002F\u002F Move semantics (default)\nfn move_example() {\n    let s1 = String::from(\"hello\");\n    let s2 = s1; \u002F\u002F s1 is MOVED, no longer valid\n\n    \u002F\u002F println!(\"{}\", s1); \u002F\u002F Compile error!\n    println!(\"{}\", s2);\n}\n\n\u002F\u002F Borrowing (references)\nfn borrow_example() {\n    let s = String::from(\"hello\");\n\n    \u002F\u002F Immutable borrow (multiple allowed)\n    let len = calculate_length(&s);\n    println!(\"{} has length {}\", s, len);\n\n    \u002F\u002F Mutable borrow (only one allowed)\n    let mut s = String::from(\"hello\");\n    change(&mut s);\n}\n\nfn calculate_length(s: &String) -> usize {\n    s.len()\n} \u002F\u002F s goes out of scope, but doesn't drop since borrowed\n\nfn change(s: &mut String) {\n    s.push_str(\", world\");\n}\n\n\u002F\u002F Lifetimes: Compiler tracks reference validity\nfn longest\u003C'a>(x: &'a str, y: &'a str) -> &'a str {\n    if x.len() > y.len() { x } else { y }\n}\n\n\u002F\u002F Struct with references needs lifetime annotation\nstruct ImportantExcerpt\u003C'a> {\n    part: &'a str,\n}\n\nimpl\u003C'a> ImportantExcerpt\u003C'a> {\n    fn level(&self) -> i32 {\n        3\n    }\n\n    \u002F\u002F Lifetime elision: compiler infers 'a for &self\n    fn announce_and_return_part(&self, announcement: &str) -> &str {\n        println!(\"Attention: {}\", announcement);\n        self.part\n    }\n}\n\n\u002F\u002F Interior mutability\nuse std::cell::{Cell, RefCell};\nuse std::rc::Rc;\n\nstruct Stats {\n    count: Cell\u003Ci32>,           \u002F\u002F Copy types\n    data: RefCell\u003CVec\u003CString>>, \u002F\u002F Non-Copy types\n}\n\nimpl Stats {\n    fn increment(&self) {\n        self.count.set(self.count.get() + 1);\n    }\n\n    fn add_data(&self, item: String) {\n        self.data.borrow_mut().push(item);\n    }\n}\n\n\u002F\u002F Rc for shared ownership (single-threaded)\nfn rc_example() {\n    let data = Rc::new(vec![1, 2, 3]);\n    let data2 = Rc::clone(&data); \u002F\u002F Increment reference count\n\n    println!(\"Count: {}\", Rc::strong_count(&data)); \u002F\u002F 2\n}\n\n\u002F\u002F Arc for shared ownership (thread-safe)\nuse std::sync::Arc;\nuse std::thread;\n\nfn arc_example() {\n    let data = Arc::new(vec![1, 2, 3]);\n\n    let handles: Vec\u003C_> = (0..3)\n        .map(|_| {\n            let data = Arc::clone(&data);\n            thread::spawn(move || {\n                println!(\"{:?}\", data);\n            })\n        })\n        .collect();\n\n    for handle in handles {\n        handle.join().unwrap();\n    }\n}\n```\n\n### Pattern 4: Safe Resource Management in C\n\n```c\n\u002F\u002F C doesn't have RAII, but we can use patterns\n\n#include \u003Cstdlib.h>\n#include \u003Cstdio.h>\n\n\u002F\u002F Pattern: goto cleanup\nint process_file(const char* path) {\n    FILE* file = NULL;\n    char* buffer = NULL;\n    int result = -1;\n\n    file = fopen(path, \"r\");\n    if (!file) {\n        goto cleanup;\n    }\n\n    buffer = malloc(1024);\n    if (!buffer) {\n        goto cleanup;\n    }\n\n    \u002F\u002F Process file...\n    result = 0;\n\ncleanup:\n    if (buffer) free(buffer);\n    if (file) fclose(file);\n    return result;\n}\n\n\u002F\u002F Pattern: Opaque pointer with create\u002Fdestroy\ntypedef struct Context Context;\n\nContext* context_create(void);\nvoid context_destroy(Context* ctx);\nint context_process(Context* ctx, const char* data);\n\n\u002F\u002F Implementation\nstruct Context {\n    int* data;\n    size_t size;\n    FILE* log;\n};\n\nContext* context_create(void) {\n    Context* ctx = calloc(1, sizeof(Context));\n    if (!ctx) return NULL;\n\n    ctx->data = malloc(100 * sizeof(int));\n    if (!ctx->data) {\n        free(ctx);\n        return NULL;\n    }\n\n    ctx->log = fopen(\"log.txt\", \"w\");\n    if (!ctx->log) {\n        free(ctx->data);\n        free(ctx);\n        return NULL;\n    }\n\n    return ctx;\n}\n\nvoid context_destroy(Context* ctx) {\n    if (ctx) {\n        if (ctx->log) fclose(ctx->log);\n        if (ctx->data) free(ctx->data);\n        free(ctx);\n    }\n}\n\n\u002F\u002F Pattern: Cleanup attribute (GCC\u002FClang extension)\n#define AUTO_FREE __attribute__((cleanup(auto_free_func)))\n\nvoid auto_free_func(void** ptr) {\n    free(*ptr);\n}\n\nvoid auto_free_example(void) {\n    AUTO_FREE char* buffer = malloc(1024);\n    \u002F\u002F buffer automatically freed at end of scope\n}\n```\n\n### Pattern 5: Bounds Checking\n\n```cpp\n\u002F\u002F C++: Use containers instead of raw arrays\n#include \u003Cvector>\n#include \u003Carray>\n#include \u003Cspan>\n\nvoid safe_array_access() {\n    std::vector\u003Cint> vec = {1, 2, 3, 4, 5};\n\n    \u002F\u002F Safe: throws std::out_of_range\n    try {\n        int val = vec.at(10);\n    } catch (const std::out_of_range& e) {\n        \u002F\u002F Handle error\n    }\n\n    \u002F\u002F Unsafe but faster (no bounds check)\n    int val = vec[2];\n\n    \u002F\u002F Modern C++20: std::span for array views\n    std::span\u003Cint> view(vec);\n    \u002F\u002F Iterators are bounds-safe\n    for (int& x : view) {\n        x *= 2;\n    }\n}\n\n\u002F\u002F Fixed-size arrays\nvoid fixed_array() {\n    std::array\u003Cint, 5> arr = {1, 2, 3, 4, 5};\n\n    \u002F\u002F Compile-time size known\n    static_assert(arr.size() == 5);\n\n    \u002F\u002F Safe access\n    int val = arr.at(2);\n}\n```\n\n```rust\n\u002F\u002F Rust: Bounds checking by default\n\nfn rust_bounds_checking() {\n    let vec = vec![1, 2, 3, 4, 5];\n\n    \u002F\u002F Runtime bounds check (panics if out of bounds)\n    let val = vec[2];\n\n    \u002F\u002F Explicit option (no panic)\n    match vec.get(10) {\n        Some(val) => println!(\"Got {}\", val),\n        None => println!(\"Index out of bounds\"),\n    }\n\n    \u002F\u002F Iterators (no bounds checking needed)\n    for val in &vec {\n        println!(\"{}\", val);\n    }\n\n    \u002F\u002F Slices are bounds-checked\n    let slice = &vec[1..3]; \u002F\u002F [2, 3]\n}\n```\n\n### Pattern 6: Preventing Data Races\n\n```cpp\n\u002F\u002F C++: Thread-safe shared state\n#include \u003Cmutex>\n#include \u003Cshared_mutex>\n#include \u003Catomic>\n\nclass ThreadSafeCounter {\npublic:\n    void increment() {\n        \u002F\u002F Atomic operations\n        count_.fetch_add(1, std::memory_order_relaxed);\n    }\n\n    int get() const {\n        return count_.load(std::memory_order_relaxed);\n    }\n\nprivate:\n    std::atomic\u003Cint> count_{0};\n};\n\nclass ThreadSafeMap {\npublic:\n    void write(const std::string& key, int value) {\n        std::unique_lock lock(mutex_);\n        data_[key] = value;\n    }\n\n    std::optional\u003Cint> read(const std::string& key) {\n        std::shared_lock lock(mutex_);\n        auto it = data_.find(key);\n        if (it != data_.end()) {\n            return it->second;\n        }\n        return std::nullopt;\n    }\n\nprivate:\n    mutable std::shared_mutex mutex_;\n    std::map\u003Cstd::string, int> data_;\n};\n```\n\n```rust\n\u002F\u002F Rust: Data race prevention at compile time\n\nuse std::sync::{Arc, Mutex, RwLock};\nuse std::sync::atomic::{AtomicI32, Ordering};\nuse std::thread;\n\n\u002F\u002F Atomic for simple types\nfn atomic_example() {\n    let counter = Arc::new(AtomicI32::new(0));\n\n    let handles: Vec\u003C_> = (0..10)\n        .map(|_| {\n            let counter = Arc::clone(&counter);\n            thread::spawn(move || {\n                counter.fetch_add(1, Ordering::SeqCst);\n            })\n        })\n        .collect();\n\n    for handle in handles {\n        handle.join().unwrap();\n    }\n\n    println!(\"Counter: {}\", counter.load(Ordering::SeqCst));\n}\n\n\u002F\u002F Mutex for complex types\nfn mutex_example() {\n    let data = Arc::new(Mutex::new(vec![]));\n\n    let handles: Vec\u003C_> = (0..10)\n        .map(|i| {\n            let data = Arc::clone(&data);\n            thread::spawn(move || {\n                let mut vec = data.lock().unwrap();\n                vec.push(i);\n            })\n        })\n        .collect();\n\n    for handle in handles {\n        handle.join().unwrap();\n    }\n}\n\n\u002F\u002F RwLock for read-heavy workloads\nfn rwlock_example() {\n    let data = Arc::new(RwLock::new(HashMap::new()));\n\n    \u002F\u002F Multiple readers OK\n    let read_guard = data.read().unwrap();\n\n    \u002F\u002F Writer blocks readers\n    let write_guard = data.write().unwrap();\n}\n```\n\n## Best Practices\n\n### Do's\n- **Prefer RAII** - Tie resource lifetime to scope\n- **Use smart pointers** - Avoid raw pointers in C++\n- **Understand ownership** - Know who owns what\n- **Check bounds** - Use safe access methods\n- **Use tools** - AddressSanitizer, Valgrind, Miri\n\n### Don'ts\n- **Don't use raw pointers** - Unless interfacing with C\n- **Don't return local references** - Dangling pointer\n- **Don't ignore compiler warnings** - They catch bugs\n- **Don't use `unsafe` carelessly** - In Rust, minimize it\n- **Don't assume thread safety** - Be explicit\n\n## Debugging Tools\n\n```bash\n# AddressSanitizer (Clang\u002FGCC)\nclang++ -fsanitize=address -g source.cpp\n\n# Valgrind\nvalgrind --leak-check=full .\u002Fprogram\n\n# Rust Miri (undefined behavior detector)\ncargo +nightly miri run\n\n# ThreadSanitizer\nclang++ -fsanitize=thread -g source.cpp\n```\n\n## Resources\n\n- [C++ Core Guidelines](https:\u002F\u002Fisocpp.github.io\u002FCppCoreGuidelines\u002F)\n- [Rust Ownership](https:\u002F\u002Fdoc.rust-lang.org\u002Fbook\u002Fch04-00-understanding-ownership.html)\n- [AddressSanitizer](https:\u002F\u002Fclang.llvm.org\u002Fdocs\u002FAddressSanitizer.html)\n","# Memory Safety Patterns\n\nCross-language patterns for memory-safe programming including RAII, ownership, smart pointers, and resource management.\n\n## When to Use This Skill\n\n- Writing memory-safe systems code\n- Managing resources (files, sockets, memory)\n- Preventing use-after-free and leaks\n- Implementing RAII patterns\n- Choosing between languages for safety\n- Debugging memory issues\n\n## Core Concepts\n\n### 1. Memory Bug Categories\n\n| Bug Type | Description | Prevention |\n|----------|-------------|------------|\n| **Use-after-free** | Access freed memory | Ownership, RAII |\n| **Double-free** | Free same memory twice | Smart pointers |\n| **Memory leak** | Never free memory | RAII, GC |\n| **Buffer overflow** | Write past buffer end | Bounds checking |\n| **Dangling pointer** | Pointer to freed memory | Lifetime tracking |\n| **Data race** | Concurrent unsynchronized access | Ownership, Sync |\n\n### 2. Safety Spectrum\n\n```\nManual (C) → Smart Pointers (C++) → Ownership (Rust) → GC (Go, Java)\nLess safe                                              More safe\nMore control                                           Less control\n```\n\n## Patterns by Language\n\n### Pattern 1: RAII in C++\n\n```cpp\n\u002F\u002F RAII: Resource Acquisition Is Initialization\n\u002F\u002F Resource lifetime tied to object lifetime\n\n#include \u003Cmemory>\n#include \u003Cfstream>\n#include \u003Cmutex>\n\n\u002F\u002F File handle with RAII\nclass FileHandle {\npublic:\n    explicit FileHandle(const std::string& path)\n        : file_(path) {\n        if (!file_.is_open()) {\n            throw std::runtime_error(\"Failed to open file\");\n        }\n    }\n\n    \u002F\u002F Destructor automatically closes file\n    ~FileHandle() = default; \u002F\u002F fstream closes in its destructor\n\n    \u002F\u002F Delete copy (prevent double-close)\n    FileHandle(const FileHandle&) = delete;\n    FileHandle& operator=(const FileHandle&) = delete;\n\n    \u002F\u002F Allow move\n    FileHandle(FileHandle&&) = default;\n    FileHandle& operator=(FileHandle&&) = default;\n\n    void write(const std::string& data) {\n        file_ \u003C\u003C data;\n    }\n\nprivate:\n    std::fstream file_;\n};\n\n\u002F\u002F Lock guard (RAII for mutexes)\nclass Database {\npublic:\n    void update(const std::string& key, const std::string& value) {\n        std::lock_guard\u003Cstd::mutex> lock(mutex_); \u002F\u002F Released on scope exit\n        data_[key] = value;\n    }\n\n    std::string get(const std::string& key) {\n        std::shared_lock\u003Cstd::shared_mutex> lock(shared_mutex_);\n        return data_[key];\n    }\n\nprivate:\n    std::mutex mutex_;\n    std::shared_mutex shared_mutex_;\n    std::map\u003Cstd::string, std::string> data_;\n};\n\n\u002F\u002F Transaction with rollback (RAII)\ntemplate\u003Ctypename T>\nclass Transaction {\npublic:\n    explicit Transaction(T& target)\n        : target_(target), backup_(target), committed_(false) {}\n\n    ~Transaction() {\n        if (!committed_) {\n            target_ = backup_; \u002F\u002F Rollback\n        }\n    }\n\n    void commit() { committed_ = true; }\n\n    T& get() { return target_; }\n\nprivate:\n    T& target_;\n    T backup_;\n    bool committed_;\n};\n```\n\n### Pattern 2: Smart Pointers in C++\n\n```cpp\n#include \u003Cmemory>\n\n\u002F\u002F unique_ptr: Single ownership\nclass Engine {\npublic:\n    void start() { \u002F* ... *\u002F }\n};\n\nclass Car {\npublic:\n    Car() : engine_(std::make_unique\u003CEngine>()) {}\n\n    void start() {\n        engine_->start();\n    }\n\n    \u002F\u002F Transfer ownership\n    std::unique_ptr\u003CEngine> extractEngine() {\n        return std::move(engine_);\n    }\n\nprivate:\n    std::unique_ptr\u003CEngine> engine_;\n};\n\n\u002F\u002F shared_ptr: Shared ownership\nclass Node {\npublic:\n    std::string data;\n    std::shared_ptr\u003CNode> next;\n\n    \u002F\u002F Use weak_ptr to break cycles\n    std::weak_ptr\u003CNode> parent;\n};\n\nvoid sharedPtrExample() {\n    auto node1 = std::make_shared\u003CNode>();\n    auto node2 = std::make_shared\u003CNode>();\n\n    node1->next = node2;\n    node2->parent = node1; \u002F\u002F Weak reference prevents cycle\n\n    \u002F\u002F Access weak_ptr\n    if (auto parent = node2->parent.lock()) {\n        \u002F\u002F parent is valid shared_ptr\n    }\n}\n\n\u002F\u002F Custom deleter for resources\nclass Socket {\npublic:\n    static void close(int* fd) {\n        if (fd && *fd >= 0) {\n            ::close(*fd);\n            delete fd;\n        }\n    }\n};\n\nauto createSocket() {\n    int fd = socket(AF_INET, SOCK_STREAM, 0);\n    return std::unique_ptr\u003Cint, decltype(&Socket::close)>(\n        new int(fd),\n        &Socket::close\n    );\n}\n\n\u002F\u002F make_unique\u002Fmake_shared best practices\nvoid bestPractices() {\n    \u002F\u002F Good: Exception safe, single allocation\n    auto ptr = std::make_shared\u003CWidget>();\n\n    \u002F\u002F Bad: Two allocations, not exception safe\n    std::shared_ptr\u003CWidget> ptr2(new Widget());\n\n    \u002F\u002F For arrays\n    auto arr = std::make_unique\u003Cint[]>(10);\n}\n```\n\n### Pattern 3: Ownership in Rust\n\n```rust\n\u002F\u002F Move semantics (default)\nfn move_example() {\n    let s1 = String::from(\"hello\");\n    let s2 = s1; \u002F\u002F s1 is MOVED, no longer valid\n\n    \u002F\u002F println!(\"{}\", s1); \u002F\u002F Compile error!\n    println!(\"{}\", s2);\n}\n\n\u002F\u002F Borrowing (references)\nfn borrow_example() {\n    let s = String::from(\"hello\");\n\n    \u002F\u002F Immutable borrow (multiple allowed)\n    let len = calculate_length(&s);\n    println!(\"{} has length {}\", s, len);\n\n    \u002F\u002F Mutable borrow (only one allowed)\n    let mut s = String::from(\"hello\");\n    change(&mut s);\n}\n\nfn calculate_length(s: &String) -> usize {\n    s.len()\n} \u002F\u002F s goes out of scope, but doesn't drop since borrowed\n\nfn change(s: &mut String) {\n    s.push_str(\", world\");\n}\n\n\u002F\u002F Lifetimes: Compiler tracks reference validity\nfn longest\u003C'a>(x: &'a str, y: &'a str) -> &'a str {\n    if x.len() > y.len() { x } else { y }\n}\n\n\u002F\u002F Struct with references needs lifetime annotation\nstruct ImportantExcerpt\u003C'a> {\n    part: &'a str,\n}\n\nimpl\u003C'a> ImportantExcerpt\u003C'a> {\n    fn level(&self) -> i32 {\n        3\n    }\n\n    \u002F\u002F Lifetime elision: compiler infers 'a for &self\n    fn announce_and_return_part(&self, announcement: &str) -> &str {\n        println!(\"Attention: {}\", announcement);\n        self.part\n    }\n}\n\n\u002F\u002F Interior mutability\nuse std::cell::{Cell, RefCell};\nuse std::rc::Rc;\n\nstruct Stats {\n    count: Cell\u003Ci32>,           \u002F\u002F Copy types\n    data: RefCell\u003CVec\u003CString>>, \u002F\u002F Non-Copy types\n}\n\nimpl Stats {\n    fn increment(&self) {\n        self.count.set(self.count.get() + 1);\n    }\n\n    fn add_data(&self, item: String) {\n        self.data.borrow_mut().push(item);\n    }\n}\n\n\u002F\u002F Rc for shared ownership (single-threaded)\nfn rc_example() {\n    let data = Rc::new(vec![1, 2, 3]);\n    let data2 = Rc::clone(&data); \u002F\u002F Increment reference count\n\n    println!(\"Count: {}\", Rc::strong_count(&data)); \u002F\u002F 2\n}\n\n\u002F\u002F Arc for shared ownership (thread-safe)\nuse std::sync::Arc;\nuse std::thread;\n\nfn arc_example() {\n    let data = Arc::new(vec![1, 2, 3]);\n\n    let handles: Vec\u003C_> = (0..3)\n        .map(|_| {\n            let data = Arc::clone(&data);\n            thread::spawn(move || {\n                println!(\"{:?}\", data);\n            })\n        })\n        .collect();\n\n    for handle in handles {\n        handle.join().unwrap();\n    }\n}\n```\n\n### Pattern 4: Safe Resource Management in C\n\n```c\n\u002F\u002F C doesn't have RAII, but we can use patterns\n\n#include \u003Cstdlib.h>\n#include \u003Cstdio.h>\n\n\u002F\u002F Pattern: goto cleanup\nint process_file(const char* path) {\n    FILE* file = NULL;\n    char* buffer = NULL;\n    int result = -1;\n\n    file = fopen(path, \"r\");\n    if (!file) {\n        goto cleanup;\n    }\n\n    buffer = malloc(1024);\n    if (!buffer) {\n        goto cleanup;\n    }\n\n    \u002F\u002F Process file...\n    result = 0;\n\ncleanup:\n    if (buffer) free(buffer);\n    if (file) fclose(file);\n    return result;\n}\n\n\u002F\u002F Pattern: Opaque pointer with create\u002Fdestroy\ntypedef struct Context Context;\n\nContext* context_create(void);\nvoid context_destroy(Context* ctx);\nint context_process(Context* ctx, const char* data);\n\n\u002F\u002F Implementation\nstruct Context {\n    int* data;\n    size_t size;\n    FILE* log;\n};\n\nContext* context_create(void) {\n    Context* ctx = calloc(1, sizeof(Context));\n    if (!ctx) return NULL;\n\n    ctx->data = malloc(100 * sizeof(int));\n    if (!ctx->data) {\n        free(ctx);\n        return NULL;\n    }\n\n    ctx->log = fopen(\"log.txt\", \"w\");\n    if (!ctx->log) {\n        free(ctx->data);\n        free(ctx);\n        return NULL;\n    }\n\n    return ctx;\n}\n\nvoid context_destroy(Context* ctx) {\n    if (ctx) {\n        if (ctx->log) fclose(ctx->log);\n        if (ctx->data) free(ctx->data);\n        free(ctx);\n    }\n}\n\n\u002F\u002F Pattern: Cleanup attribute (GCC\u002FClang extension)\n#define AUTO_FREE __attribute__((cleanup(auto_free_func)))\n\nvoid auto_free_func(void** ptr) {\n    free(*ptr);\n}\n\nvoid auto_free_example(void) {\n    AUTO_FREE char* buffer = malloc(1024);\n    \u002F\u002F buffer automatically freed at end of scope\n}\n```\n\n### Pattern 5: Bounds Checking\n\n```cpp\n\u002F\u002F C++: Use containers instead of raw arrays\n#include \u003Cvector>\n#include \u003Carray>\n#include \u003Cspan>\n\nvoid safe_array_access() {\n    std::vector\u003Cint> vec = {1, 2, 3, 4, 5};\n\n    \u002F\u002F Safe: throws std::out_of_range\n    try {\n        int val = vec.at(10);\n    } catch (const std::out_of_range& e) {\n        \u002F\u002F Handle error\n    }\n\n    \u002F\u002F Unsafe but faster (no bounds check)\n    int val = vec[2];\n\n    \u002F\u002F Modern C++20: std::span for array views\n    std::span\u003Cint> view(vec);\n    \u002F\u002F Iterators are bounds-safe\n    for (int& x : view) {\n        x *= 2;\n    }\n}\n\n\u002F\u002F Fixed-size arrays\nvoid fixed_array() {\n    std::array\u003Cint, 5> arr = {1, 2, 3, 4, 5};\n\n    \u002F\u002F Compile-time size known\n    static_assert(arr.size() == 5);\n\n    \u002F\u002F Safe access\n    int val = arr.at(2);\n}\n```\n\n```rust\n\u002F\u002F Rust: Bounds checking by default\n\nfn rust_bounds_checking() {\n    let vec = vec![1, 2, 3, 4, 5];\n\n    \u002F\u002F Runtime bounds check (panics if out of bounds)\n    let val = vec[2];\n\n    \u002F\u002F Explicit option (no panic)\n    match vec.get(10) {\n        Some(val) => println!(\"Got {}\", val),\n        None => println!(\"Index out of bounds\"),\n    }\n\n    \u002F\u002F Iterators (no bounds checking needed)\n    for val in &vec {\n        println!(\"{}\", val);\n    }\n\n    \u002F\u002F Slices are bounds-checked\n    let slice = &vec[1..3]; \u002F\u002F [2, 3]\n}\n```\n\n### Pattern 6: Preventing Data Races\n\n```cpp\n\u002F\u002F C++: Thread-safe shared state\n#include \u003Cmutex>\n#include \u003Cshared_mutex>\n#include \u003Catomic>\n\nclass ThreadSafeCounter {\npublic:\n    void increment() {\n        \u002F\u002F Atomic operations\n        count_.fetch_add(1, std::memory_order_relaxed);\n    }\n\n    int get() const {\n        return count_.load(std::memory_order_relaxed);\n    }\n\nprivate:\n    std::atomic\u003Cint> count_{0};\n};\n\nclass ThreadSafeMap {\npublic:\n    void write(const std::string& key, int value) {\n        std::unique_lock lock(mutex_);\n        data_[key] = value;\n    }\n\n    std::optional\u003Cint> read(const std::string& key) {\n        std::shared_lock lock(mutex_);\n        auto it = data_.find(key);\n        if (it != data_.end()) {\n            return it->second;\n        }\n        return std::nullopt;\n    }\n\nprivate:\n    mutable std::shared_mutex mutex_;\n    std::map\u003Cstd::string, int> data_;\n};\n```\n\n```rust\n\u002F\u002F Rust: Data race prevention at compile time\n\nuse std::sync::{Arc, Mutex, RwLock};\nuse std::sync::atomic::{AtomicI32, Ordering};\nuse std::thread;\n\n\u002F\u002F Atomic for simple types\nfn atomic_example() {\n    let counter = Arc::new(AtomicI32::new(0));\n\n    let handles: Vec\u003C_> = (0..10)\n        .map(|_| {\n            let counter = Arc::clone(&counter);\n            thread::spawn(move || {\n                counter.fetch_add(1, Ordering::SeqCst);\n            })\n        })\n        .collect();\n\n    for handle in handles {\n        handle.join().unwrap();\n    }\n\n    println!(\"Counter: {}\", counter.load(Ordering::SeqCst));\n}\n\n\u002F\u002F Mutex for complex types\nfn mutex_example() {\n    let data = Arc::new(Mutex::new(vec![]));\n\n    let handles: Vec\u003C_> = (0..10)\n        .map(|i| {\n            let data = Arc::clone(&data);\n            thread::spawn(move || {\n                let mut vec = data.lock().unwrap();\n                vec.push(i);\n            })\n        })\n        .collect();\n\n    for handle in handles {\n        handle.join().unwrap();\n    }\n}\n\n\u002F\u002F RwLock for read-heavy workloads\nfn rwlock_example() {\n    let data = Arc::new(RwLock::new(HashMap::new()));\n\n    \u002F\u002F Multiple readers OK\n    let read_guard = data.read().unwrap();\n\n    \u002F\u002F Writer blocks readers\n    let write_guard = data.write().unwrap();\n}\n```\n\n## Best Practices\n\n### Do's\n- **Prefer RAII** - Tie resource lifetime to scope\n- **Use smart pointers** - Avoid raw pointers in C++\n- **Understand ownership** - Know who owns what\n- **Check bounds** - Use safe access methods\n- **Use tools** - AddressSanitizer, Valgrind, Miri\n\n### Don'ts\n- **Don't use raw pointers** - Unless interfacing with C\n- **Don't return local references** - Dangling pointer\n- **Don't ignore compiler warnings** - They catch bugs\n- **Don't use `unsafe` carelessly** - In Rust, minimize it\n- **Don't assume thread safety** - Be explicit\n\n## Debugging Tools\n\n```bash\n# AddressSanitizer (Clang\u002FGCC)\nclang++ -fsanitize=address -g source.cpp\n\n# Valgrind\nvalgrind --leak-check=full .\u002Fprogram\n\n# Rust Miri (undefined behavior detector)\ncargo +nightly miri run\n\n# ThreadSanitizer\nclang++ -fsanitize=thread -g source.cpp\n```\n\n## Resources\n\n- [C++ Core Guidelines](https:\u002F\u002Fisocpp.github.io\u002FCppCoreGuidelines\u002F)\n- [Rust Ownership](https:\u002F\u002Fdoc.rust-lang.org\u002Fbook\u002Fch04-00-understanding-ownership.html)\n- [AddressSanitizer](https:\u002F\u002Fclang.llvm.org\u002Fdocs\u002FAddressSanitizer.html)\n",{"name":5,"description":7},"main","18d0e63d1313ca87098f614aa7c1e2dcf6de79c7","backend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fexternal_plugins\u002Fsystems-programming\u002Fskills\u002Fmemory-safety-patterns",1,"https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system","https:\u002F\u002Fgithub.com\u002Fwelflau","2026-11-10 11:14:25",{"source":8,"skillName":5,"commands":57,"prompt":67,"zipAvailable":68},[58,61,64],{"tool":59,"command":60},"npx","npx skills add welflau\u002Fai-dev-system --skill memory-safety-patterns",{"tool":62,"command":63},"bunx","bunx skills add welflau\u002Fai-dev-system --skill memory-safety-patterns",{"tool":65,"command":66},"pnpm","pnpm dlx skills add welflau\u002Fai-dev-system --skill memory-safety-patterns","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fexternal_plugins\u002Fsystems-programming\u002Fskills\u002Fmemory-safety-patterns\u002FSKILL.md",true,[],[71,105,132,156,182,206],{"skillNo":72,"name":73,"nameZh":6,"description":74,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":75,"licenseFileUrl":76,"sourceHtmlUrl":77,"categories":78,"keywords":84,"publishedAt":44},"01M6HSTDP4M3JFXEBK91VFB4PA","web-artifacts-builder","Suite of tools for creating elaborate, multi-component claude.ai HTML artifacts using modern frontend web technologies (React, Tailwind CSS, shadcn\u002Fui). Use for complex artifacts requiring state management, routing, or shadcn\u002Fui components - not for simple single-file HTML\u002FJSX artifacts.","Apache-2.0","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fplugins\u002Fweb-artifacts-builder\u002FLICENSE.txt","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fplugins\u002Fweb-artifacts-builder\u002FSKILL.md",[79],{"categoryNo":80,"categoryName":81,"taxonomyType":82,"taxonomyTypeDesc":83},"01JBSEEDCAT000000000000009","前端开发","SCENARIO","使用场景",[85,86,87,88,89,90,91,92,93,94,95,96,97,98,38,99,100,101,102,103,104],"web artifacts builder","web","artifacts","artifacts builder","builder","frontend","css","components","react","routing","state management","state","file","Tailwind","single-file","simple","ui components","multi","for","single",{"skillNo":106,"name":107,"nameZh":6,"description":108,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":75,"licenseFileUrl":109,"sourceHtmlUrl":110,"categories":111,"keywords":119,"publishedAt":44},"01M6HSDXH0JSP8R3QTNY9XZ8HN","frontend-design","Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, artifacts, posters, or applications (examples include websites, landing pages, dashboards, React components, HTML\u002FCSS layouts, or when styling\u002Fbeautifying any web UI). Generates creative, polished code and UI design that avoids generic AI aesthetics.","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fplugins\u002Ffrontend-design\u002FLICENSE.txt","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fplugins\u002Ffrontend-design\u002FSKILL.md",[112,113,116],{"categoryNo":80,"categoryName":81,"taxonomyType":82,"taxonomyTypeDesc":83},{"categoryNo":114,"categoryName":115,"taxonomyType":82,"taxonomyTypeDesc":83},"01JBSEEDCAT000000000000015","视觉设计",{"categoryNo":117,"categoryName":118,"taxonomyType":20,"taxonomyTypeDesc":21},"01JBSEEDCAT000000000000032","设计师",[90,120,121,91,86,92,93,122,123,40,87,124,125,126,38,127,128,129,130,32,131,28],"design","frontend design","react components","create","examples","applications","landing","ui design","pages","aesthetics","web ui","generic",{"skillNo":133,"name":134,"nameZh":6,"description":135,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":75,"licenseFileUrl":136,"sourceHtmlUrl":137,"categories":138,"keywords":140,"publishedAt":44},"01M6HSA77QYVP7A72HREGTDN2C","algorithmic-art","Creating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems. Create original algorithmic art rather than copying existing artists' work to avoid copyright violations.","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fplugins\u002Falgorithmic-art\u002FLICENSE.txt","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fplugins\u002Falgorithmic-art\u002FSKILL.md",[139],{"categoryNo":114,"categoryName":115,"taxonomyType":82,"taxonomyTypeDesc":83},[141,142,143,123,40,144,145,146,147,38,148,149,35,150,32,151,152,153,154,155,28],"algorithmic art","Art","algorithmic","flow","js","work","interactive","generative art","exploration","users","Existing","request","generative","copyright","fields",{"skillNo":157,"name":158,"nameZh":6,"description":159,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":75,"licenseFileUrl":160,"sourceHtmlUrl":161,"categories":162,"keywords":164,"publishedAt":44},"01M6HS9HE0X390Y6RQKTY1YNGJ","theme-factory","Toolkit for styling artifacts with a theme. These artifacts can be slides, docs, reportings, HTML landing pages, etc. There are 10 pre-set themes with colors\u002Ffonts that you can apply to any artifact that has been creating, or can generate a new theme on-the-fly.","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fexternal_plugins\u002Ftheme-factory\u002FLICENSE.txt","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fexternal_plugins\u002Ftheme-factory\u002FSKILL.md",[163],{"categoryNo":114,"categoryName":115,"taxonomyType":82,"taxonomyTypeDesc":83},[165,166,167,168,169,170,87,171,172,173,126,174,175,128,176,32,177,178,179,103,180,181],"theme factory","factory","theme","docs","toolkit","generate","SET","fly","slides","styling","artifact","themes","you","fonts","can","apply","new",{"skillNo":183,"name":184,"nameZh":6,"description":185,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":186,"categories":187,"keywords":191,"publishedAt":44},"01M6HS74GASM6FJ77F83EY679E","browsing","Use when you need direct browser control - teaches Chrome DevTools Protocol for controlling existing browser sessions, multi-tab management, form automation, and content extraction via use_browser MCP tool","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fexternal_plugins\u002Fsuperpowers-chrome\u002Fskills\u002Fbrowsing\u002FSKILL.md",[188],{"categoryNo":189,"categoryName":190,"taxonomyType":82,"taxonomyTypeDesc":83},"01JBSEEDCAT000000000000023","Skill与智能体开发",[184,192,193,194,195,196,197,198,199,200,201,38,202,203,204,205,102,177,103,151],"MCP","automation","chrome","sessions","protocol","browser","devtools","chrome devtools","tool","direct","browser control","control","via","form",{"skillNo":207,"name":208,"nameZh":6,"description":209,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":75,"licenseFileUrl":210,"sourceHtmlUrl":211,"categories":212,"keywords":219,"publishedAt":44},"01M6HS6BZT2CKDNQ6YF20DXN4T","slack-gif-creator","Knowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like \"make me a GIF of X doing Y for Slack.\"","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fexternal_plugins\u002Fslack-gif-creator\u002FLICENSE.txt","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fexternal_plugins\u002Fslack-gif-creator\u002FSKILL.md",[213,216],{"categoryNo":214,"categoryName":215,"taxonomyType":82,"taxonomyTypeDesc":83},"01JBSEEDCAT000000000000005","邮件与沟通",{"categoryNo":217,"categoryName":218,"taxonomyType":82,"taxonomyTypeDesc":83},"01JBSEEDCAT000000000000016","图像与多媒体",[220,221,222,223,224,225,226,227,228,38,229,150,230,231,232,103,152,28],"slack gif creator","slack","gif","creator","validation","Tools","constraints","Animation","knowledge","me","make","Utilities","concepts"]