Rust Литературные Типы Полное Руководство и Примеры

Вы когда-нибудь задумывались, почему Rust считается одним из самых безопасных языков? Всего 2 ключевых концепции — владение и заимствование — меняют всё. В этом материале «Rust: Литературные Типы – Полное Руководство и Примеры» я разберу, как работают базовые кирпичики кода. Давайте погрузимся в детали.

Знакомство с Rust

Я долго изучал разные языки, но Rust меня покорил. Это язык системного программирования. Он дает невероятную скорость. Безопасность памяти здесь на первом месте. Я заметил, что компилятор работает как строгий учитель. Он не пропустит ошибку. Это круто. Вы получаете производительность C++, но без вылетов по памяти. Просто магия!

Что же такое литералы?

Литералы — это просто фиксированные значения. Мы пишем их прямо в коде. Они не меняются сами по себе. Это основа любого выражения. Без них мы бы не смогли присвоить переменной начальное значение. Я понял, что литерал — это способ сказать компилятору: «Вот тебе конкретное значение, используй его».

• Целочисленные литералы
• Литералы с плавающей точкой
• Булевы значения
• Символьные литералы
• Строковые литералы
• Сырые (raw) строки
• Шестнадцатеричные числа
• Двоичные литералы

Работа с числами

Числа в Rust бывают разными. Есть целые, есть дробные. Я часто использую разные системы счисления. Это удобно для работы с железом. Можно писать в десятичной системе. Можно в шестнадцатеричной. А можно вообще в двоичной. Главное — не запутаться в суффиксах. Ошибка новичков — пытаться сложить разные типы чисел без преобразования. Компилятор сразу ударит по рукам!

1. Повышение читаемости кода при работе с битами.
2. Удобство задания адресов памяти в HEX.
3. Точное управление размером переменной.
4. Оптимизация под конкретную архитектуру процессора.
5. Быстрое задание констант для флагов.
6. Совместимость с низкоуровневыми протоколами.
7. Упрощение написания масок для битовых операций.

Например, число 255 можно записать как 255, 0xFF или 0b11111111. Все это одно и то же значение, но разный вид.

Тонкости строковых литералов

Строки в Rust — это отдельная песня. Строковый литерал всегда имеет тип &str. Это ссылка на данные в памяти. Я заметил, что они хранятся прямо в бинарном файле программы. Если нужно вставить спецсимвол, используем экранирование. Например, для новой строки. Но иногда это бесит. Тогда на помощь приходят raw strings. Они начинаются с r". В них всё пишется как есть.

Пример из жизни: Представьте, что я пишу путь к файлу в Windows. Там много обратных слэшей. Обычная строка превратится в кашу из \. Я просто использую raw string, и путь выглядит чисто и понятно.

Логика: истина или ложь

Тут всё просто. Есть true и false. Это булевы литералы. Я использую их в каждом втором условии if. Они маленькие, быстрые и понятные. Никаких чисел вместо логики, как в старом C. Только четкое «да» или «нет».

Символы и Unicode

Символ в Rust — это не один байт. Это полноценный Unicode-скаляр. Пишется в одинарных кавычках. Я решил проверить, и оказалось, что можно вставить даже эмодзи или иероглиф. Один символ char занимает 4 байта. Это позволяет поддерживать любые языки мира без костылей.

Связь литералов и типов данных

Rust очень умный. Он умеет сам угадывать типы. Это называется вывод типов. Если я пишу let x = 5;, Rust решит, что это i32. Но иногда я хочу другого. Тогда я указываю тип явно: let x: u64 = 5;. Или добавляю суффикс: 5u64. Преобразование типов здесь строгое. Нельзя просто так взять и засунуть большое число в маленькую переменную.

1. Диапазон значений (нужен ли знак минус).
2. Требуемая точность для дробных чисел.
3. Объем доступной оперативной памяти.
4. Требования внешней библиотеки или API.
5. Скорость выполнения арифметических операций.

Литералы в действии

Я постоянно использую литералы в выражениях. Складываю, вычитаю, сравниваю. Арифметика простая. Логические операции тоже. Но помню про приоритеты. Скобки — мои лучшие друзья. Без них можно получить результат, который меня сильно удивит (в плохом смысле).

• Всегда проверяйте совместимость типов перед сложением.
• Используйте скобки для ясности сложных выражений.
• Следите за возможным переполнением целых чисел.
• Не забывайте про разницу между = и ==.
• Используйте _ в больших числах для читаемости (например, 1_000_000).
• Проверяйте типы при работе с float из-за точности.
• Используйте подходящие литералы для констант.

Константы и их значения

Константы в Rust определяются через const. Они должны иметь явный тип. Значением константы всегда является литерал или выражение, которое можно вычислить при компиляции. Я использую их для настроек программы. Это надежно. Значение зашито намертво, изменить его в рантайме нельзя.

Продвинутый уровень: макросы

Есть вещи поинтереснее. Например, макросы. Они могут генерировать код. Некоторые макросы принимают литералы и превращают их в сложные структуры. Это почти метапрограммирование. Я один раз попробовал написать свой макрос — голова пошла кругом, но результат того стоил. Это позволяет сократить тонны рутины.

Разбор реальных примеров

Давайте посмотрим, как это работает в жизни. Я написал небольшой кусочек кода. В нем есть всё: и числа, и строки, и булевы значения. Я заметил, что использование разных форматов записи чисел делает код понятнее для коллег. Если я вижу 0x, я сразу понимаю, что речь о байтах или адресах.

Допустим, я создаю конфигурацию для сервера. Порт — это целое число. IP-адрес — строка. Флаг включения — булево значение. Все эти данные я задаю через литералы. Это быстро и эффективно.

Частые вопросы

Можно ли менять значение литерала?
Нет. Литерал — это само значение. Вы можете менять переменную, которой присвоен литерал (если она mut), но не сам литерал.

В чем разница между "text" и r"text"?
Первый вариант требует экранирования спецсимволов. Второй — сырой, он воспринимает всё буквально. Я рекомендую сырые строки для путей и регулярных выражений.

Почему я не могу просто прибавить 1 к строке?
Потому что Rust — строго типизированный язык. Строка и число — это разные миры. Вам нужно сначала преобразовать строку в число.

Зачем нужны суффиксы типа 10u8?
Чтобы сказать компилятору точно, какой размер памяти выделить. Без этого он выберет стандартный i32, что не всегда удобно.

Все ли символы в char занимают 4 байта?
Да, в Rust тип char всегда занимает 4 байта, чтобы вместить любой символ Unicode.