Разбираем безопасное побитовое преобразование типов!

Сейчас научимся преобразовывать данные одного типа в другой без неопределённого поведения — с помощью функции std::bit_cast.

Сначала подключим необходимые библиотеки из стандартной поставки:

#include <bit>      // std::bit_cast
#include <cstdint>  // uint32_t
#include <iostream>
#include <iomanip>  // std::hex, std::setw, std::setfill

Теперь создадим число с плавающей точкой и преобразуем его в uint32_t, чтобы увидеть его внутреннее битовое представление:

float value = 3.1415926f;
uint32_t raw = std::bit_cast<uint32_t>(value);

std::cout << "Биты числа: 0x"
          << std::hex << std::setw(8) << std::setfill('0') << raw << '\n';

Преобразуем обратно, чтобы убедиться, что значение не потеряно:

float restored = std::bit_cast<float>(raw);
std::cout << std::dec << "Восстановлено: " << restored << '\n';

Результат при запуске программы:

Биты числа: 0x40490fda  
Восстановлено: 3.14159

🔥 Таким образом ты можешь безопасно перепаковывать данные между типами одинакового размера — без UB, memcpy и хаков.

📣 C++ Ready | #практика

🐱 Project-Based Learning — обучение через проекты!

Этот репозиторий собирает лучшие гайды, где вместо теории — реальные проекты, которые можно реализовать с нуля. Внутри есть десятки идей. В разделах по C++ и C# можно найти идеи разного уровня: работа с файлами, сетевое взаимодействие, графика, многопоточность и др. задачи.

Оставляю ссылочку: GitHub 📱

📣 C++ Ready | #репозиторий

Почему push_back() во время обхода vector может привести к багу?

Потому что при добавлении нового элемента std::vector может перевыделить память. А после этого все итераторы, ссылки и указатели на его элементы становятся невалидными.

Проблема в том, что range-based for тоже опирается на итераторы. И если внутри цикла вызвать:

v.push_back(5);

контейнер может переехать в другую область памяти. Тогда цикл продолжит работу уже с невалидными итераторами, а это undefined behavior.

То есть внешне код выглядит безобидно, но в реальности может:
• работать “случайно нормально”
• пропускать элементы
• падать
• давать нестабильное поведение

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

🔥 У vector добавление элемента может инвалидировать итераторы. Менять контейнер во время его обхода нужно очень осторожно.

📣 C++ Ready | #совет

📂 Напоминалка по иерархии памяти и работе storage!

Например, регистры — это самый быстрый уровень памяти внутри CPU, кэш (L1/L2/L3) снижает latency за счёт локальности данных, RAM хранит рабочее состояние приложений, а SSD/HDD используются для персистентного хранения с существенно более высоким временем доступа.

На картинке — базовая иерархия памяти, взаимодействие CPU — cache — RAM — disk, а также упрощённая модель работы HDD и архитектура SSD.

Сохрани, чтобы не потерять!

📣 C++ Ready | #ресурс

Не копировать объект, а просто обменять: std::swap как базовый инструмент

Иногда нужно просто поменять значения двух переменных местами. Вручную это обычно делают через временную переменную, но в C++ для этого уже есть готовый и понятный инструмент — std::swap.

Простой пример:

int a = 10;
int b = 20;

std::swap(a, b);

std::cout << a << ' ' << b << '\n';

После вызова значения переменных меняются местами:
a == 20
b == 10

То же самое работает не только с числами, но и с контейнерами:

std::vector<int> x{1, 2, 3};
std::vector<int> y{4, 5};

std::swap(x, y);

std::cout << x.size() << ' ' << y.size() << '\n';

Такой обмен обычно дешевле и чище, чем ручное переприсваивание. А главное — сразу видно намерение: мы не “что-то присваиваем”, а именно меняем объекты местами.

🔥 std::swap делает код проще и выразительнее: обмен значений — одной строкой и без лишнего шума.

📣 C++ Ready | #практика

🧐 Ravesli — подробный курс по C++ с нуля!

Это структурированный обучающий сайт, где собрано более 200 уроков по C++, охватывающих как базовые, так и углублённые темы языка. Отдельное внимание уделено практике: на сайте есть задания, проекты и даже разборы создания игр, что позволяет применять знания в реальных задачах.

📌 Оставляю ссылочку: ravesli.com

📣 C++ Ready | #сайт

Почему после push_back() нельзя слепо использовать старый итератор?

Потому что std::vector хранит элементы в непрерывной области памяти.
Если при добавлении нового элемента текущей capacity уже не хватает, вектор перевыделяет память и переносит элементы в новое место.

После этого все итераторы, ссылки и указатели на старые элементы становятся невалидными.

В таком коде:

std::vector<int> v = {1, 2, 3};

auto it = v.begin();
v.push_back(4);

std::cout << *it << "\n";

it мог указывать на элемент в старом буфере памяти.
Если во время push_back() произошел reallocation, разыменование it — это уже undefined behavior.

Из-за этого баг особенно неприятный: код может

* работать “нормально” на маленьких примерах,
* ломаться только на других данных,
* проявляться нестабильно и не сразу.

Если после изменения vector тебе снова нужен итератор, его лучше получить заново.
А если хочешь уменьшить шанс перевыделения памяти, можно заранее вызвать reserve().

🔥 У vector итераторы живут только до тех пор, пока контейнер не изменил свое хранилище.

📣 C++ Ready | #совет

😎 Нашёл полезную статью на Хабре — отличный пример, как начать писать простую игру на C++ с помощью SFML!

В этой статье:
• Как создать окно SFML и настроить главный цикл с обработкой событий
• Реализация singleton-контроллера для управления движением по клавишам
• Подключение и отображение текстур в игровом цикле

🔊 Советую продолжить читать на Habr!

📣 C++ Ready | #статья

📂 Принципы проектирования и архитектуры API!

Например, REST задаёт стандарт взаимодействия по HTTP, GraphQL — гибкую выборку данных, а gRPC — эффективную бинарную коммуникацию.

На схеме — основные области: основы (контракты, HTTP, stateless), паттерны (REST, RPC, WebSockets), безопасность (OAuth2, JWT, TLS), а также дизайн и эволюция API.

Сохрани, чтобы не потерять!

📣 C++ Ready | #ресурс

Почему lambda с [=] может работать не так, как ты ожидаешь?

Потому что [=] копирует только локальные переменные из текущей области видимости.
Но если внутри метода класса ты обращаешься к полям объекта, на самом деле захватывается не сам объект целиком, а указатель this.

В таком коде:

cpp id="r8n2fs"
pool.enqueue([=] {
    process(data_);
});

может казаться, что data_ безопасно скопирован внутрь lambda. Но это не так.

Фактически lambda использует this, а значит обращается к полю исходного объекта.
Если к моменту выполнения задачи объект уже уничтожен, код получит висячий указатель и undefined behavior.

Из-за этого баг особенно неприятный:

• внешне всё выглядит как “захват по значению”
• код может долго работать нормально
• а потом упасть в асинхронном сценарии, где объект уже не живёт

Если нужен именно снимок данных на момент создания lambda, лучше захватывать его явно:

cpp id="x1kz7d"
auto data = data_;
pool.enqueue([data] {
    process(data);
});

А если нужен сам объект, важно явно контролировать его lifetime.

🔥[=] внутри метода класса не копирует поля объекта автоматически. Чаще всего ты захватываешь this, а не данные.

📣 C++ Ready | #совет

👀 Хочешь понять криптографию не только на уровне терминов, а через код?

Нашёл статью, где автор разбирает два собственных блочных шифра на C++: ESCK-7 и Seal. Это интересный инженерный разбор того, как может быть устроено блочное шифрование.

В статье:
• структура блочного шифра и работа с 64-битными числами
• генерация ключа и преобразования через XOR, NOT и циклические сдвиги
• примеры функций шифрования, расшифровки и изменения ключа

🔊 Продолжай читать на habr!

📣 C++ Ready | #статья

Безопасное извлечение значения из map: try_emplace вместо лишних проверок!

Когда нужно добавить значение в std::map, если ключа ещё нет, код часто превращается в проверку через find, а потом отдельную вставку. Работает, но получается многословно.

В C++17 для этого есть try_emplace. Он добавляет элемент только если такого ключа ещё нет.

Например:

#include <map>
#include <string>
#include <iostream>

std::map<std::string, int> counters;

counters.try_emplace("errors", 0);

Если ключа "errors" ещё не было, он появится со значением 0.

Если ключ уже есть, значение не будет перезаписано:

counters["errors"] = 5;

counters.try_emplace("errors", 0);

std::cout << counters["errors"] << '\n'; // 5

Это удобно, когда значение дорого создавать или когда важно не затереть уже существующие данные.

try_emplace также возвращает пару: итератор и флаг, была ли вставка выполнена.

auto [it, inserted] = counters.try_emplace("warnings", 0);

if (inserted) {
    std::cout << "created\n";
} else {
    std::cout << "already exists\n";
}

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

🔥 try_emplace помогает аккуратно добавлять элементы в map: только если ключа ещё нет.

📣 C++ Ready | #практика

📂 Напоминалка для работы с OOP Design Patterns!

Например, Factory помогает делегировать создание объектов, а Observer — удобно реализовать систему подписок и событий.

На картинке — 9 самых нужных паттернов, которые часто встречаются в реальных проектах и архитектуре.

Сохрани, чтобы не потерять!

📣 C++ Ready | #ресурс

Почему lambda с [=] может работать не так, как ты ожидаешь?

Потому что [=] копирует только локальные переменные из текущей области видимости.
Но если внутри метода класса ты обращаешься к полям объекта, на самом деле захватывается не сам объект целиком, а указатель this.

В таком коде:

cpp id="r8n2fs"
pool.enqueue([=] {
    process(data_);
});

может казаться, что data_ безопасно скопирован внутрь lambda. Но это не так.

Фактически lambda использует this, а значит обращается к полю исходного объекта.
Если к моменту выполнения задачи объект уже уничтожен, код получит висячий указатель и undefined behavior.

Из-за этого баг особенно неприятный:

• внешне всё выглядит как “захват по значению”
• код может долго работать нормально
• а потом упасть в асинхронном сценарии, где объект уже не живёт

Если нужен именно снимок данных на момент создания lambda, лучше захватывать его явно:

cpp id="x1kz7d"
auto data = data_;
pool.enqueue([data] {
    process(data);
});

А если нужен сам объект, важно явно контролировать его lifetime.

🔥 [=] внутри метода класса не копирует поля объекта автоматически. Чаще всего ты захватываешь this, а не данные.

📣 C++ Ready | #совет

📂 Напоминалка по памяти и накопителям!

Например, RAM используется для временного хранения данных во время работы программы, а ROM хранит постоянную информацию вроде прошивки.

На картинке — основные типы памяти и storage: RAM, ROM, SRAM, DRAM и др.

Сохрани, чтобы не потерять!

📣 C++ Ready | #ресурс