[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7BW2Q4TR5G8280B5SCVC6E4":3,"skill-same:01M7BW2Q4TR5G8280B5SCVC6E4":47},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":24,"commitSha":25,"skillDirectory":26,"forksCount":27,"repositoryHtmlUrl":28,"repositoryHomepageUrl":29,"ownerHtmlUrl":30,"ownerBlogUrl":6,"ownerDescription":31,"updatedAt":32,"install":33,"resources":46},"01M7BW2Q4TR5G8280B5SCVC6E4","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.","YYC-Cube\u002FYYC3-Knowledge-Base","YYC-Cube","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F235006543?v=4","01M79J2PH4SWD2X0825X6PN748","yyc3","01M79J2PHVK3F6ZBYT8K2SCZCW",1,"MIT","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-Plugin-插件协议\u002FYYC3-Plugin-插件协议-external_plugins\u002Fsystems-programming\u002Fskills\u002Fmemory-safety-patterns\u002FSKILL.md",[],[],"2026-11-15 14:19:17",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","87afe6ce96220accf50a345dea46784c8c9f210e","YYC3-Plugin-插件协议\u002FYYC3-Plugin-插件协议-external_plugins\u002Fsystems-programming\u002Fskills\u002Fmemory-safety-patterns",0,"https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base","https:\u002F\u002Fkb.yyc3.top\u002F","https:\u002F\u002Fgithub.com\u002FYYC-Cube","万象归元于云枢 | 深栈智启新纪元","2026-11-10 10:37:32",{"source":8,"skillName":5,"commands":34,"prompt":44,"zipAvailable":45},[35,38,41],{"tool":36,"command":37},"npx","npx skills add YYC-Cube\u002FYYC3-Knowledge-Base --skill memory-safety-patterns",{"tool":39,"command":40},"bunx","bunx skills add YYC-Cube\u002FYYC3-Knowledge-Base --skill memory-safety-patterns",{"tool":42,"command":43},"pnpm","pnpm dlx skills add YYC-Cube\u002FYYC3-Knowledge-Base --skill memory-safety-patterns","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-Plugin-插件协议\u002FYYC3-Plugin-插件协议-external_plugins\u002Fsystems-programming\u002Fskills\u002Fmemory-safety-patterns\u002FSKILL.md",true,[],[48,55,62,69,76,83],{"skillNo":49,"name":50,"nameZh":6,"description":51,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":52,"categories":53,"keywords":54,"publishedAt":19},"01M7CTDWHERCXPQCP0K03A86AS","vercel-sandbox","Run agent-browser + Chrome inside Vercel Sandbox microVMs for browser automation from any Vercel-deployed app. Use when the user needs browser automation in a Vercel app (Next.js, SvelteKit, Nuxt, Remix, Astro, etc.), wants to run headless Chrome without binary size limits, needs persistent browser sessions across commands, or wants ephemeral isolated browser environments. Triggers include \"Vercel Sandbox browser\", \"microVM Chrome\", \"agent-browser in sandbox\", \"browser automation on Vercel\", or any task requiring Chrome in a Vercel Sandbox.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fvercel-sandbox\u002FSKILL.md",[],[],{"skillNo":56,"name":57,"nameZh":6,"description":58,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":59,"categories":60,"keywords":61,"publishedAt":19},"01M7CTD8D2BNJY54S65M47HEJA","slack","Interact with Slack workspaces using browser automation. Use when the user needs to check unread channels, navigate Slack, send messages, extract data, find information, search conversations, or automate any Slack task. Triggers include \"check my Slack\", \"what channels have unreads\", \"send a message to\", \"search Slack for\", \"extract from Slack\", \"find who said\", or any task requiring programmatic Slack interaction.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fslack\u002FSKILL.md",[],[],{"skillNo":63,"name":64,"nameZh":6,"description":65,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":66,"categories":67,"keywords":68,"publishedAt":19},"01M7CTCSSB8ZP3Q58C3YZDZK1W","electron","Automate Electron desktop apps (VS Code, Slack, Discord, Figma, Notion, Spotify, etc.) using agent-browser via Chrome DevTools Protocol. Use when the user needs to interact with an Electron app, automate a desktop app, connect to a running app, control a native app, or test an Electron application. Triggers include \"automate Slack app\", \"control VS Code\", \"interact with Discord app\", \"test this Electron app\", \"connect to desktop app\", or any task requiring automation of a native Electron application.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Felectron\u002FSKILL.md",[],[],{"skillNo":70,"name":71,"nameZh":6,"description":72,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":73,"categories":74,"keywords":75,"publishedAt":19},"01M7CTCBJY76688V4DCZGWFHGQ","dogfood","Systematically explore and test a web application to find bugs, UX issues, and other problems. Use when asked to \"dogfood\", \"QA\", \"exploratory test\", \"find issues\", \"bug hunt\", \"test this app\u002Fsite\u002Fplatform\", or review the quality of a web application. Produces a structured report with full reproduction evidence -- step-by-step screenshots, repro videos, and detailed repro steps for every issue -- so findings can be handed directly to the responsible teams.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fdogfood\u002FSKILL.md",[],[],{"skillNo":77,"name":78,"nameZh":6,"description":79,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":80,"categories":81,"keywords":82,"publishedAt":19},"01M7CTC4H0FFGVEAQR9PA4GA1A","agent-browser","Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to \"open a website\", \"fill out a form\", \"click a button\", \"take a screenshot\", \"scrape data from a page\", \"test this web app\", \"login to a site\", \"automate browser actions\", or any task requiring programmatic web interaction.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fagent-browser\u002FSKILL.md",[],[],{"skillNo":84,"name":85,"nameZh":6,"description":86,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":87,"categories":88,"keywords":89,"publishedAt":19},"01M7CTBKVFYBG78FDSABSDJTTQ","shadcn","Manages shadcn components and projects — adding, searching, fixing, debugging, styling, and composing UI, including chat interfaces. Provides project context, component docs, and usage examples. Applies when working with shadcn\u002Fui, component registries, presets, --preset codes, or any project with a components.json file. Also triggers for \"shadcn init\", \"create an app with --preset\", \"switch to --preset\", and for building a design system or applying a DESIGN.md or brand spec to shadcn\u002Fui.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-UI-界面组件\u002FYYC3-UI-界面组件-ui\u002Fskills\u002Fshadcn\u002FSKILL.md",[],[]]