---
title: "Pourquoi &str Ne Rentre Pas dans &String en Rust: Fixes Sympas pour les String Mismatches !"
description: "Pourquoi passer un &str là où un &String est attendu ne compile pas, ce que la coercition de déréférencement fait — et ne fait pas."
url: "https://mayorana.ch/fr/blog/string-str-mismatch-rust-fr"
language: "fr"
date: "2025-08-26"
author: "Mohamed Bennekrouf"
tags:
- "rust"
- "memory"
- "string"
- "str"
- "ownership"
en_version: "https://mayorana.ch/en/blog/string-str-mismatch-rust.md"
---
# Pourquoi &str Ne Rentre Pas dans &String en Rust: Fixes Sympas pour les String Mismatches !
En Rust, tu ne peux pas passer un `&str` directement à une fonction attendant un `&String` à cause de leurs types distincts, ce qui assure la type safety et prévient les assumptions sur l'ownership mémoire. Ci-dessous, j'explique pourquoi ce mismatch survient et comment le gérer efficacement.
## Le problème Central : Type Mismatch
- **`&String`** : Une référence vers un `String` heap-allocated, extensible.
- **`&str`** : Une string slice qui peut pointer vers mémoire heap, stack, ou static.
- Ce sont des **types différents**, donc Rust rejette les conversions implicites pour la sécurité.
Ce mismatch de types n'est pas de la bureaucratie — les deux références contiennent physiquement des choses différentes :
**Exemple : Le Problème** :
```rust,compile_fail
fn print_string(s: &String) {
println!("{}", s);
}
fn main() {
let my_str = "hello"; // Type: `&'static str`
print_string(my_str); // ERREUR: expected `&String`, found `&str`
}
```
## Solutions pour Relier &str et &String
### 1. Deref Coercion (Conversion Automatique)
Rust convertit automatiquement `&String` vers `&str` via le trait `Deref`, mais pas l'inverse. Le meilleur fix est de changer la fonction pour accepter `&str` pour plus de flexibilité.
```rust
fn print_str(s: &str) { // Maintenant accepte `&str` et `&String`
println!("{}", s);
}
fn main() {
let my_string = String::from("hello");
let my_str = "world";
print_str(&my_string); // Fonctionne: `&String` coerce vers `&str`
print_str(my_str); // Fonctionne directement
}
```
**Pourquoi ça marche** : `String` implémente `Deref`, permettant à `&String` de coercer vers `&str`.
### 2. Conversion explicite (Quand Tu As Besoin de &String)
Si la fonction doit prendre `&String`, convertis `&str` vers `String` d'abord :
```rust
fn print_string(s: &String) {
println!("{}", s);
}
fn main() {
let my_str = "hello";
print_string(&my_str.to_string()); // Alloue un nouveau `String`
}
```
**Inconvénient** : Ceci alloue un nouveau buffer heap, ce qui devrait être évité si possible à cause des coûts de performance.
### 3. Utilise `AsRef` pour flexibilité Maximum
Pour des fonctions qui devraient marcher avec tout type string-like :
```rust
fn print_as_str>(s: S) {
println!("{}", s.as_ref());
}
fn main() {
let my_string = String::from("hello");
let my_str = "world";
print_as_str(&my_string); // Fonctionne
print_as_str(my_str); // Fonctionne
}
```
**Bonus** : Accepte aussi `Cow`, `Box`, etc.
## La correction, en bref
**Préféré** : Utilise `&str` dans les arguments de fonction (flexible et zero-cost).
**Si coincé avec `&String`** : Convertis `&str` vers `String` (alloue).
**Pour les APIs** : Utilise `AsRef` ou `impl Deref` pour compatibilité maximum.
**Pourquoi Rust Applique Ceci** :
- Prévient les allocations accidentelles ou assumptions sur l'ownership mémoire.
- Encourage des APIs efficaces, borrow-friendly.
Passer un `String` à `print_str` sans le `&` est une erreur de type, pas une erreur de move : la
coercition de déréférencement ne s'applique qu'à travers une référence, donc le compilateur n'a
rien à coercer.