Так ли просто написать «Hello, World!» на языке Rust — про ссылки и разыменование

Сегодня столкнулся с интересной проблемой, которая показалась мне забавной. Простенькая задачка, что будет если добавить амперсанд к строке «Hello, World!». Собственно, давайте попробуем разобраться, что происходит когда мы делаем ссылку на «&str» тип.

Посмотрите на код ниже, далее мы подробно разберем каждую строку.

fn main() {
println!("{}", "Hello, World!");
println!("{}", &"Hello, World!");
println!("{}", &*"привет!");
println!("{}", &&*"Hello, World!");
println!("{}", &&&&"Hello, World!");
// error[E0614]: type `str` cannot be dereferenced
// Но почему ошибка? Ответ кроется в том как создаются ссылки.
println!("{}", &&&&**"Hello, World!");
println!("{}", &&&&****"Hello, World!");
}

Разберём пошагово, что происходит в каждом вызове println! и почему возникает ошибка E0614.

Основы: типы и ссылки в Rust

• "привет!" — строковый литерал типа &'static str (неизменяемая ссылка на строку в статической памяти).
• & — оператор взятия ссылки (borrowing).
• * — оператор разыменования (dereferencing).

Разбор каждого вызова

1. println!("{}", "привет!");
   Работает. "привет!" уже имеет тип &str, который можно вывести.
2. println!("{}", &"привет!");
   Работает. Берём ссылку на &str → получаем &&str. println! умеет работать с ссылками на строки.
3. println!("{}", &*"привет!");
   Работает.
   • *"привет!" — разыменование &str → получаем значение типа str (но это не ссылка!).
   • &*... — берём ссылку на str → снова &str.
     Итог: эквивалентно первому варианту.
4. println!("{}", &&*"Hello, World!");
   Работает.
   • *"Hello, World!" → str.
   • &*... → &str.
   • &&*... → &&str.
     println! справляется с &&str.
5. println!("{}", &&&&"Hello, World!");
   Работает. Просто создаём многоуровневую ссылку: &&&&str. println! может вывести и такое.
6. println!("{}", &&&&**"Hello, World!");
   Ошибка E0614.
   Почему:
   • **"Hello, World!" — попытка дважды разыменовать &str.
   • Первое * → str (значение, не ссылка).
   • Второе * → попытка разыменовать str, но str не является указателем и не поддерживает разыменование.
7. println!("{}", &&&&****"Hello, World!");
   Тоже ошибка E0614.
   Разбор:
   • ****"Hello, World!" — четыре операции разыменования.
   • После первого * → str.
   • Остальные три * пытаются разыменовать str, что невозможно.

Почему str нельзя разыменовать?

• str — это не указатель, а динамически размещённый тип (DST, dynamically sized type).
• Он представляет собой «сырые» байты строки без информации о длине.
• В Rust DST всегда используются через ссылки (&str, Box<str> и т. д.), потому что ссылка содержит длину.
• Попытка разыменовать str как указатель приводит к ошибке, так как у него нет адреса для разыменования.

Если свести все к одному предложению.

Ошибка возникает, когда мы пытаемся применить оператор * к значению типа str (а не к ссылке на него). Строковые литералы ("...") уже являются ссылками (&str), и их можно разыменовать только один раз — чтобы получить str.

Дальнейшее разыменование невозможно.

Немного усложним задачу

Что будет, если сделать так:

fn main() { 
println!("{}", &*&*&*&*"Hello, World!");
}

Код все еще прекрасно работает и выводит в консоль приветствие всему миру.

Из этого можно сделать неверный вывод, что нельзя ставить несколько знаков разыменование подряд. Давайте сразу развенчаем эту теорию.

fn main() {    
    let hello = &&&&&&"Hello, World!";
    println!("{}", *****hello);
}

Код снова компилируется. Так в чем же дело?

Почему работает первый пример

fn main() {    
    println!("{}", &&&&***&&"Hello, World!");
}

Если добавить четвертый символ разыменование программа не скомпилируется, но сейчас она запускается и выводит приветствие.

Хотя мы читаем код слева направо, выполнение операций и их семантическая интерпретация зависят от приоритета операторов, который в данном случае заставляет компилятор связывать операторы * и & справа налево.

&&&&( ***( &&"Hello, World!" ) )
││││ └─┬─┘└────────┬────────┘
3456   2           1
││││   │           └───► Проверка типа &str и добавление двух ссылок.
││││   └───► Тройное разыменование ***:
││││        1. *(&&&str) → &&str
││││        2. *(&&str)  → &str 
││││        3. *(&str)   → str (DST!)
││││        4. Далее разыменование невозможно ERROR E0614
│││└─► Внешняя ссылка & (третий уровень)
││└──► Внешняя ссылка & (второй уровень)
│└───► Внешняя ссылка & (первый уровень)
└────► Внешняя ссылка & (нулевой уровень)

"Hello, World!"
└──► Исходный литерал: &'static str
_____________________________
Результат выражения: &&&&str.

Резюмируя