Skip to content

borrow-checker-limits.md

Latest commit

 

History

History
104 lines (78 loc) · 3.01 KB

borrow-checker-limits.md

File metadata and controls

104 lines (78 loc) · 3.01 KB

Limites du Borrow Checker - Quand il est Trop Strict! 🎯

Learning Objectives

  • Comprendre les limites du borrow checker (c'est important!)
  • Voir les cas où il est trop strict
  • Utiliser des solutions de contournement
  • Maintenir la sécurité

Core Explanation

For Absolute Beginners - C'est Comme un Gardien Trop Strict! 🚧

Imaginez un gardien 🚧 trop strict:

  • Borrow checker = Le gardien qui protège
  • Parfois, il est trop strict (graphes, structures auto-référentielles)
  • Mais il y a des solutions sûres!

C'est exactement comme les limites du borrow checker! C'est super important à comprendre!

Schéma Visuel - Limites

┌─────────────────────────────────────────┐
│  🚧 BORROW CHECKER = GARDIEN 🚧        │
├─────────────────────────────────────────┤
│                                         │
│  ✅ Protège bien:                       │
│  - Structures simples                   │
│  - Ownership clair                      │
│                                         │
│  ⚠️ Trop strict:                       │
│  - Graphes complexes                    │
│  - Structures auto-référentielles      │
│                                         │
│  Solutions: Rc/RefCell, Arc/Mutex ✅    │
│                                         │
└─────────────────────────────────────────┘

Mnémonique: "Gardien" - Le borrow checker est comme un gardien: il protège bien, mais parfois trop strict, utilisez Rc/RefCell ou Arc/Mutex pour les cas complexes!

Limites

Example 1: Graph Structures

// Le borrow checker ne peut pas vérifier les graphes
struct Node {
    value: i32,
    children: Vec<Node>,  // Simple mais limité
}

// Pour des graphes complexes, utiliser Rc/RefCell ou unsafe

Example 2: Self-Referential Structures

// ❌ IMPOSSIBLE: Structure auto-référentielle
// struct Node {
//     value: i32,
//     parent: &Node,  // ERREUR: lifetime
// }

// ✅ SOLUTION: Utiliser des indices ou Rc/Weak
struct Node {
    value: i32,
    parent: Option<usize>,  // Index dans un Vec
}

Example 3: Contournements Sûrs

use std::cell::RefCell;
use std::rc::{Rc, Weak};

struct Node {
    value: i32,
    parent: Option<Weak<Node>>,
    children: Vec<Rc<RefCell<Node>>>,
}

Solutions

  • Rc/RefCell : Single-threaded
  • Arc/Mutex : Multi-threaded
  • Indices : Graph structures
  • Arenas : Allocation groupée

Official Resources

Security Notes

Les contournements doivent maintenir la sécurité :

  • Utiliser les types sûrs (Rc, Arc)
  • Tester exhaustivement
  • Documenter les raisons
  • Éviter unsafe sauf si nécessaire