String vs. &str – Lequel Utiliser et Quand ?

Comprendre la différence entre String et str est fondamental pour une gestion efficace de la mémoire.

String et str, côte à côte

Layout mémoire

String : Stocke les données sur la heap avec trois composants :

• Pointeur vers buffer heap
• Length (taille actuelle)
• Capacity (taille allouée)

&str : Un "fat pointer" contenant :

• Pointeur vers données string (heap, stack, ou mémoire static)
• Length de la slice

Cas d'usages

Utilise String quand :

• Tu as besoin de modifier ou faire grandir la string
• Tu as besoin d'ownership (ex : retourner depuis une fonction)
• Construire des strings dynamiquement

let mut owned = String::from("hello");
owned.push_str(" world");  // Mutation nécessite String

Utilise &str quand :

• Tu n'as besoin que d'une vue read-only d'une string
• Travailler avec des paramètres de fonction (évite les allocations inutiles)
• Gérer des string literals (stockées en mémoire read-only)

fn process_str(s: &str) -> usize {
    s.len()  // Accès read-only
}

Exemple : Ownership vs Borrowing

fn process_string(s: String) { /* prend ownership */ }
fn process_str(s: &str)      { /* emprunte */ }

fn main() {
    let heap_str = String::from("hello");
    let static_str = "world";
    
    process_string(heap_str);  // Ownership moved
    process_str(static_str);   // Borrowed
    
    // heap_str plus accessible ici
    // static_str encore accessible
}

Considérations de performance

Paramètres de Fonction :

// Inefficace - force l'allocation
fn bad(s: String) -> usize { s.len() }

// Efficace - accepte String et &str
fn good(s: &str) -> usize { s.len() }

// Exemple:
let owned = String::from("test");
good(&owned);     // Deref coercion: String -> &str
good("literal");  // &str direct

Allocation Mémoire :

• String alloue sur heap, nécessite désallocation
• &str vers literals pointe vers le binaire du programme (zero allocation)
• &str depuis String partage l'allocation existante

Patterns courants

Renvoyer des "Owned" :

fn build_message(name: &str) -> String {
    format!("Hello, {}!", name)  // Retourne String owned
}

Paramètre d'entrée flexible :

fn analyze(text: &str) -> usize {
    // Fonctionne avec inputs String et &str
    text.chars().count()
}

Éviter les Clones Inutiles :

// Mauvais - allocation inutile
fn process_bad(s: &str) -> String {
    s.to_string()  // Seulement si tu as vraiment besoin de données owned
}

// Bon - travaille avec données borrowed quand possible
fn process_good(s: &str) -> &str {
    s.trim()  // Retourne slice de l'original
}

Lequel écrire

• String : Owned, mutable, heap-allocated
• str : Borrowed, immutable, flexible (heap/stack/static)
  Préfère &str pour les paramètres de fonction sauf si tu as besoin d'ownership ou mutation

.to_string() alloue dans les deux cas, mais pas pour la même raison : sur un littéral il copie depuis les données en lecture seule du binaire, sur un String il clone un buffer heap existant.