# Memory Safety Patterns

> 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.

Source: https://skillsagentes.com/skills/wshobson/agents/memory-safety-patterns
Repository: https://github.com/wshobson/agents
Author: wshobson
License: MIT
Updated: hace 2 meses
Context cost: 51 tok installed, 647 tok once triggered, 3.4k tok with every bundled file
Bundle: 2 files, 13 KB
Permissions requested: none declared

## Install

```bash
npx -y skills add wshobson/agents --skill memory-safety-patterns --agent claude-code
```

## What it does

- Aplica patrones RAII, ownership y smart pointers para escribir código seguro en memoria en Rust, C++ y C
- Clasifica tipos de bugs de memoria (use-after-free, double-free, leaks, buffer overflow, data races) y su prevención
- Recomienda herramientas de depuración como AddressSanitizer, Valgrind, ThreadSanitizer y Miri

## Use it when

- Al escribir código de sistemas seguro en memoria
- Al gestionar recursos como archivos, sockets o memoria
- Al prevenir use-after-free y memory leaks
- Al implementar patrones RAII o depurar problemas de memoria

## What triggers it

- "Ayúdame a implementar RAII en C++ para gestionar este recurso"
- "¿Cómo evito un use-after-free en este código Rust?"
- "Configura AddressSanitizer para detectar leaks en mi programa C"

## Before you install

- Requiere compiladores/herramientas como Clang, GCC, Valgrind o cargo con nightly para Miri según el patrón usado.

## Files

- SKILL.md — 3 KB
- references/details.md — 11 KB

## SKILL.md

Reproduced verbatim from wshobson/agents under MIT. This section is the upstream document and is in English.

# Memory Safety Patterns

Cross-language patterns for memory-safe programming including RAII, ownership, smart pointers, and resource management.

## When to Use This Skill

- Writing memory-safe systems code
- Managing resources (files, sockets, memory)
- Preventing use-after-free and leaks
- Implementing RAII patterns
- Choosing between languages for safety
- Debugging memory issues

## Core Concepts

### 1. Memory Bug Categories

| Bug Type             | Description                      | Prevention        |
| -------------------- | -------------------------------- | ----------------- |
| **Use-after-free**   | Access freed memory              | Ownership, RAII   |
| **Double-free**      | Free same memory twice           | Smart pointers    |
| **Memory leak**      | Never free memory                | RAII, GC          |
| **Buffer overflow**  | Write past buffer end            | Bounds checking   |
| **Dangling pointer** | Pointer to freed memory          | Lifetime tracking |
| **Data race**        | Concurrent unsynchronized access | Ownership, Sync   |

### 2. Safety Spectrum

```
Manual (C) → Smart Pointers (C++) → Ownership (Rust) → GC (Go, Java)
Less safe                                              More safe
More control                                           Less control
```

## Detailed patterns and worked examples

Detailed pattern documentation lives in `references/details.md`. Read that file when the navigation tier above is insufficient.

## Best Practices

### Do's

- **Prefer RAII** - Tie resource lifetime to scope
- **Use smart pointers** - Avoid raw pointers in C++
- **Understand ownership** - Know who owns what
- **Check bounds** - Use safe access methods
- **Use tools** - AddressSanitizer, Valgrind, Miri

### Don'ts

- **Don't use raw pointers** - Unless interfacing with C
- **Don't return local references** - Dangling pointer
- **Don't ignore compiler warnings** - They catch bugs
- **Don't use `unsafe` carelessly** - In Rust, minimize it
- **Don't assume thread safety** - Be explicit

## Debugging Tools

```bash
# AddressSanitizer (Clang/GCC)
clang++ -fsanitize=address -g source.cpp

# Valgrind
valgrind --leak-check=full ./program

# Rust Miri (undefined behavior detector)
cargo +nightly miri run

# ThreadSanitizer
clang++ -fsanitize=thread -g source.cpp
```

---

Skills Agentes — https://skillsagentes.com/skills/wshobson/agents/memory-safety-patterns