Грокаем C++
Відкрити в Telegram
Два сеньора C++ - Владимир и Денис - отныне ваши гиды в этом дремучем мире плюсов. По всем вопросам (+ реклама) @ninjatelegramm Менеджер: @Spiral_Yuri Реклама: https://telega.in/c/grokaemcpp Мы на TGstat: https://tgstat.ru/channel/@grokaemcpp/stat
Показати більше9 357
Підписники
+124 години
+97 днів
+2030 днів
Архів дописів
9 357
Атрибуты лямбды
#опытным
В прошлом посте код с картинки реально компилируется и, если вы не поняли, что это за чертовщина, то следующие несколько постов будут для вас.
В С++11 у нас появилась возможность указывать атрибуты для функции. Например:
[[nodiscard]] int ComplicatedCompute() {
return 2*2;
}
ComplicatedCompute();
// warning: ignoring return value of 'int ComplicatedCompute()',
// declared with attribute nodiscard
Вы можете, например, пометить возвращаемое значение функции, как то, которое нельзя игнорировать, и компилятор даст вам по сопатке, если вы его все же заигнорите.
Ну это функции. А как же лямбды? Хочется и для них указывать атрибуты.
И атрибуты для возвращаемого значения лямбды завезли в С++23. Выглядит это так:
auto complicated_compute = [] [[nodiscard]] () { return 2 * 2; };
complicated_compute();
// warning: ignoring return value of 'main()::<lambda()>',
// declared with attribute 'nodiscard'
После скобок для захвата вы указываете список атрибутов в квадратных скобках. Выглядит интересно. Не очень элегантно, но интересно.
Одни скажут: "усложнение синтаксиса!". Другие скажут, что давно пора лямбды подтягивать ко всем возможностям обычных функций.
Тут как бы все просто: не хотите - не используйте. У лямбды и так полно опциональных обвесок, одним больше, одним меньше. Можно определить шаблонную лямбду и обвесить ее всякими концептами с trailing return type. И это будет страшный зверь. Можно сделать отдельный пост, как может выглядеть ультимативная лямбда.
Ну а если вы хотите немного больше синтаксически говорить кодом, то теперь можете использовать атрибуты для лямбд.
Don't ignore. Stay cool.
#cpp2304 груд 2025, 05:00
9 357
👨💻Ошибки в памяти, утечки, неопределённое поведение — всё это неизбежная часть разработки на C++. Даже опытные инженеры порой тратят часы на поиск невидимых дефектов, которые ломают логику программы. Но есть инструменты, которые позволяют ловить такие баги ещё до того, как они попадут в прод.
На открытом уроке 9 декабря в 20:00 мск мы подробно разберём санитайзеры — инструменты, которые показывают, где и почему программа ведёт себя неправильно. Вы поймёте, как использовать их в реальных проектах, какие типы ошибок они находят и где проходят границы применимости.
Это полезно всем, кто пишет на C++. Санитайзеры — минимальный набор безопасности, который помогает не только отлавливать критические ошибки, но и формировать инженерную культуру «чистого» кода. Вы увидите, как всего одно включение инструмента даёт прозрачность, на которую обычно уходят недели отладки.
🚀Присоединяйтесь к открытому уроку в преддверие старта курса «C++ Developer»: https://otus.pw/zbN7/
Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576
04 груд 2025, 02:00
07 груд 2025, ~03:31
9 357
И это все компилируется!
Сможете сказать, откуда каждая скобка взялась?)
02 груд 2025, 07:00
9 357
Оборачиваем вспять байты
#новичкам
Когда мы низкоуровнево работаем с сетью, то надо понимать, что в данных, полученных по сети, нужно реверсировать порядок байтов, чтобы правильно интерпретировать значения. Также реверсировать порядок нужно при отправке данных по сети. Это происходит из-за того, что в стеке протоколов TCP/IP принят порядок Big-endian - старший байт хранится по младшему адресу. А на большинстве хостов(десктопов и серверов) - Little-endian: младший байт хранится по младшему адресу.
Соответственно нужны функции для реверсирования байтов. Обычно для этого используют либо компиляторные интринсики:
### GCC/Clang uint16_t swapped16 = __builtin_bswap16(value); uint32_t swapped32 = __builtin_bswap32(value); uint64_t swapped64 = __builtin_bswap64(value); ### MSVC: uint16_t swapped16 = _byteswap_ushort(value); uint32_t swapped32 = _byteswap_ulong(value); uint64_t swapped64 = _byteswap_uint64(value);Либо системное апи:
#include <arpa/inet.h> // Linux/macOS
// или
#include <winsock2.h> // Windows
uint16_t network_to_host16 = ntohs(value);
uint16_t host_to_network16 = htons(value);
uint32_t network_to_host32 = ntohl(value);
uint32_t host_to_network32 = htonl(value);
uint64_t network_to_host64 = ntohll(value);
uint64_t host_to_network64 = htonll(value);
Либо какое-нибудь библиотечное решение:
#include <boost/endian/conversion.hpp>
uint32_t value = 0x12345678;
uint32_t swapped = boost::endian::endian_reverse(value);
uint32_t to_big = boost::endian::native_to_big(value);
uint32_t to_little = boost::endian::native_to_little(value);
Но в С++23 появилась стандартная функция для разворачивания порядка байтов!
template< class T >
constexpr T byteswap( T n ) noexcept;
Работает она только для интегральных типов и вот ее возможная реализация:
template<std::integral T>
constexpr T byteswap(T value) noexcept
{
static_assert(std::has_unique_object_representations_v<T>,
"T may not have padding bits");
auto value_representation = std::bit_cast<std::array<std::byte, sizeof(T)>>(value);
std::ranges::reverse(value_representation);
return std::bit_cast<T>(value_representation);
}
Результат у нее собственно ровно тот, который и ожидается:
template<std::integral T>
void dump(T v, char term = '\n')
{
std::cout << std::hex << std::uppercase << std::setfill('0')
<< std::setw(sizeof(T) * 2) << v << " : ";
for (std::size_t i{}; i != sizeof(T); ++i, v >>= 8)
std::cout << std::setw(2) << static_cast<unsigned>(T(0xFF) & v) << ' ';
std::cout << std::dec << term;
}
int main()
{
static_assert(std::byteswap('a') == 'a');
std::cout << "byteswap for U16:\n";
constexpr auto x = std::uint16_t(0xCAFE);
dump(x);
dump(std::byteswap(x));
std::cout << "\nbyteswap for U32:\n";
constexpr auto y = std::uint32_t(0xDEADBEEFu);
dump(y);
dump(std::byteswap(y));
std::cout << "\nbyteswap for U64:\n";
constexpr auto z = std::uint64_t{0x0123456789ABCDEFull};
dump(z);
dump(std::byteswap(z));
}
// OUTPUT
// byteswap for U16:
// CAFE : FE CA
// FECA : CA FE
// byteswap for U32:
// DEADBEEF : EF BE AD DE
// EFBEADDE : DE AD BE EF
// byteswap for U64:
// 0123456789ABCDEF : EF CD AB 89 67 45 23 01
// EFCDAB8967452301 : 01 23 45 67 89 AB CD EF
Как всегда стандарт запаздывает лет на 10-15-20, но хорошо, что все-таки завезли эту полезную функцию, которую можно кроссплатформенно использовать.
Use standard solutions. Stay cool.
#cpp2301 груд 2025, 04:00
9 357
Все секреты и лайфхаки по работе со строками — на втором вебинаре по оптимизации игр от PVS-Studio ❤️
Приглашённые эксперты из gamedev-индустрии поделятся удачными (и не очень) историями развития собственных решений.
А ещё:
🔵 расскажут о пулах строк и способах экономии памяти;
🔵 разберут, как ускорить поиск подстроки в строке и почему одна реализация может быть быстрее другой.
Вас ждут доклады:
🔵 «String interning и все, все, все» от Сергея Кушниренко, Senior Software Engineer в команде Age of Empires 2 (студия Forgotten Empires);
🔵 «Векторизованный поиск подстроки в строке» от Дениса Ярошевского, Performance engineer, условно активный член C++ сообщества, один из разработчиков библиотеки для векторизации EVE;
🔵 «std::string – путешествие туда и обратно» от Андрея Карпова, сооснователя PVS-Studio и автора Telegram-канала «Бестиарий программирования».
🗓 4 декабря, 15:00
Присоединяйтесь по ССЫЛКЕ
01 груд 2025, 02:00
03 груд 2025, ~01:50
9 357
Передача владения
#новичкам
Захотелось совсем немного развить тему предыдущего поста.
В целом, мув семантика она не столько про оптимизацию(для этого есть например rvo/nrvo), сколько про передачу владения объектами. И то, что std::move ничего не мувает(а пытается сделать каст к rvalue reference) хорошо укладывается в эту концепцию. Данные не перемещаются, но вы говорите, что передаете владение этими данными.
void bar(std::vector<int>&& vec) {
// do nothing
}
void foo() {
std::vector<int> vec = {1, 2, 3};
bar(std::move(vec));
}
Здесь мы передаем владение вектором из foo в bar. Заметьте, что bar оперирует правой ссылкой, то есть никакие перемещающие конструкторы не вызывались. Но такая сигнатура говорит о главном: bar ожидает эксклюзивного права владения над этим вектором. Вы должны явно мувнуть объект, чтобы вызвать bar. И не важно, что он дальше bar с этим вектором делает. Может ничего не сделает, а может и использует как-то данные. Но так решил автор кода: вызов bar предполагает передачу ему владения вектором.
Другой пример:
std::vector<int> double_elements(std::vector<int> vec) {
for (auto& elem: vec) {
elem *= 2;
}
return vec;
}
void foo() {
std::vector<int> vec = {1, 2, 3};
{
auto doubled = double_elements(vec);
std::println("{}", doubled);
}
vec.push_back(4);
{
auto doubled = double_elements(std::move(vec));
std::println("{}", doubled);
}
}
Функция double_elements принимает вектор по значению и возвращает набор из удвоенных элементов.
Функция foo 2 раза вызывает удвоение значений элементов. По логике функции foo, ей еще нужен vec в целости и сохранности(нужно доложить в него элемент). Поэтому она и передает в первый раз vec в double_elements по значению. Но после второго вызова вектор ей больше не нужен. Поэтому можно передать владение им в double_elements: возможно он им распорядится лучше.
Еще одна вещь, которая подчеркивает передачу владения: moved-from объект практически никак в общем случае нельзя безопасно использовать, кроме как безопасно разрушить или переприсвоить(в комментах под прошлым постом более конкретно обсуждали этот момент). Даже если функция принимает rvalue reference, это не значит, что она не изменяет объект: возможно внутренние вызовы это делают.
Поэтому можно принять за правило, что, передав владение, вы больше физически не имеете права пользоваться объектом. Это как продав компанию, вы бы продолжили иметь то же влияние на нее. Нетушки. Либо крестик снимите, либо трусы наденьте. Либо передали владение и забыли, либо скопировали и дальше попользовались.
Give away what you don't need. Stay cool.
#cppcore #cpp1129 лист 2025, 04:00
9 357
🔥OS DevConf 25 powered by GigaChat — конференция про разработку системного ПО, ядра Linux и open source.
Один день, 500 участников, 30+ докладов, 3 трека — концентрат практического опыта, знаний и инструментов, готовых к внедрению сразу по возвращению в офис. И, конечно, мега-возможности для нетворкинга с коллегами и экспертами сообщества!
Что будем обсуждать?
-Инструменты и примеры отладки, виртуализации, оптимизации производительности
-Практический опыт оптимизации сетевых решений с DPDK
-Эффективные методы безопасной разработки ядра Linux
-Реальные кейсы создания драйверов на Rust
-Все про GPU, NPU, ASIC и как запускать AI на железе под Linux и не только. Как AI встраивается в современную разработку
-Современные подходы к разработке системного и embedded ПО
Участие бесплатное, но количество мест ограничено — зарегистрируйтесь прямо сейчас 💻
#реклама
О рекламодателе
29 лист 2025, 03:00
01 груд 2025, ~00:33
9 357
Мувать не всегда дешево
#новичкам
С приходом мув семантики настали "прекрасные плюсы будущего". Нет никакого копирования, чудо-оптимизации бороздят просторы стека и кучи. Не жизнь, а сказка.
Но мир не такой уж солнечный и приветливый. Это очень опасное...
Если вы придерживаетесь RAII, пользуетесь контейнерами и умными указателями, то вы практически всегда пользуетесь правилом нуля и никогда не определяете самостоятельно специальные методы класса и, в частности, конструктор перемещения и оператор перемещающего присваивания. Компилятор сгенерирует их за вас, ленивых дядь.
Рано или поздно вы немного отрываетесь от "низов": вас уже не интересует КАК конкретно эти методы реализованы. Вы оперируете более высокоуровневыми сущностями и полагаетесь на компилятор.
И вот вы в ситуации, когда у вас есть данные, обернутые в класс, которые легально по контексту кода можно мувнуть или скопировать. Условно говоря, у вас есть функция Process, которая принимает данные по значению, чтобы поддержать оба варианта передачи: копирование и мув:
void Process(Data data);
Что выбрать?
"Конечно мувнуть, это же не долгое копирование, выполнится быстро" - вот к таким не совсем корректным мыслям может привести "оторванность от низов".
Кажется, что у некоторых людей есть ощущение, что данные из одного объекта как-то перетекают в другой объект и это происходит очень быстро.
Но это не так! Перемещение - это поверхностное копирование.
Возьмем простой пример:
struct Data {
int a;
double b;
};
Data obj1{3, 3.14};
Dara obj2 = std::move(obj1);
Что будет происходить при перемещении obj1? Копирование a и b.
Чуть сложнее:
struct Data {
std::array<int, 5> arr;
};
Data obj1{.arr = {1, 2, 3, 4, 5}};
Dara obj2 = std::move(obj1);
Что будет при перемещении obj1, а значит и arr? Тоже копирование! std::array - это массив, фиксированного размера, расположенный на стеке. Как вы собираетесь его перемещать в другой объект? Под другой объект уже выделена своя память на стеке, вы не можете один кусок стека переместить в другой. Вы можете только скопировать значения.
Можно еще занулить конечно, но это редко происходит из соображений перфоманса.
Получается, что реально "переместить" вы можете только данные, выделенные на куче. И то они никуда не перемещаются. Вы просто копируете указатель из одного объекта в другой, при этом сами данные никак не затрагиваются.
struct Data {
std::string * str;
// member functions for making it work properly
};
Data obj1{.str = new std::string("Hello, World!")};
Dara obj2 = std::move(obj1);
obj2 теперь имеет такое же значение указателя str, как и obj1, но сама строка оказалась нетронутой.
Более того. Даже если вы используете std::string, то не всегда мув будет быстрее копирования! Thanks to SSO.
Получается, что никто никуда не течет. Все так же пресловуто копируется, кроме динамических данных под указателями.
Теперь снова актуализируем вопрос: мувать или копировать?
И ответ уже не плоскости оптимизации, а в плоскости логики кода. Перемещайте, когда вам в текущем скоупе объект больше не нужен и копируйте, если нужен. Тогда вы не пытаетесь оптимизировать код, а передаете владение объектом другому коду. Редко, когда вы на авито продаете вещи, чтобы заработать. Вы их продаете, чтобы от лишнего избавиться и дать их тем, кому они нужны, особой выгоды не ожидая. Вот здесь примерно это и должно происходить.
В реальности все немного сложнее и всегда будут исключения, но просто хочу обратить внимание, что мув семантика - это в первую очередь про передачу владения объектом и только потом уже оптимизация.
Think logically. Stay cool.
#cppcore #cpp1127 лист 2025, 04:00
9 357
magic_enum
#опытным
Много раз уже упоминали эту библиотечку в комментах, пора удостоить ее отдельного поста.
В чем проблема: хочется enum сериализовывать/десериализовывать в строку и из строки. То есть значение перечислителя заменить его строковым представлением в коде.
Такая задача требует рефлексии, которая в С++ только в 26 стандарте появится. Рефлексия - способность программы знать о том, как она написана на языке программирования. В скомпилированной программе перечислитель это всего лишь число, а чтобы получить имя, которое он имел в С++ коде, в программе должна эта информация где-то сохраниться.
Ну то есть, если у вас нет С++26, то нужно терпеть(но мы привыкли) и писать костыли. Что делается обычно:
enum class Color { RED, GREEN, BLUE };
std::unordered_map<Color, std::string> map = {{Color::RED, "RED"}, {Color::GREEN, "GREEN"}, {Color::BLUE, "BLUE"}};
std::cout << map[Color::RED] << std::endl;
Для больших перечислений опупеете писать эти мапы, плюс код в принципе засоряется ими.
Но на любую проблему стандартных плюсов найдется своя библиотека, которая ее решит. В этом случае пригодится magic_enum.
Это хэдэр-онли С++17 библиотечка, которая предоставляет статическую рефлексию для перечислений и работает без макросни в интерфейсе и без бойлерплейта.
Простой пример:
Color color = Color::RED;
std::string color_name = magic_enum::enum_name(color);
assert(color_name == "RED);
Как это работает?
magic_enum рассчитан на работу с небольшими enum'ами. По дефолту интервал underlying значений от -128 до 127.
Если сильно упрощенно, то magic_enum пытается инстанцировать специальную функцию для каждого значения из этого интервала. Так как шаблонный параметр будет NTTP, его значение будет вшито в саму сигнатуру функции. А ее можно получить с помощью __PRETTY_FUNCTION__ или __FUNCSIG__:
template <auto V>
constexpr std::string_view get_enum_name() {
return extract_name(PRETTY_FUNCTION);
}
Только для реально существующих перечислителей __PRETTY_FUNCTION__ будет содержать корректное имя. Так и происходит маппинг значений перечислителей на их имена.
Вот примеры сигнатуры функции для существующего и несуществующего перечислителя:
enum class Color { RED, GREEN, BLUE };
constexpr Color c = static_cast<Color>(4);
get_enum_name<c>(); // constexpr void get_enum_name() [with auto V = (Color)4]
get_enum_name<Color::GREEN>(); // constexpr void get_enum_name() [with auto V = Color::GREEN]
Чтобы это все реализовать и вместе собрать нужно еще много шаблонной магии, но суть такова.
magic_enum еще много чего умеет:
👉🏿 Обратный маппинг имен на значения перечисления
std::string color_name{"GREEN"};
auto color = magic_enum::enum_cast<Color>(color_name);
if (color.has_value()) {
// color.value() -> Color::GREEN
}
👉🏿 Доступ к элементам перечисления по индексу
std::size_t i = 0;
Color color = magic_enum::enum_value<Color>(i);
👉🏿 Можно получить количество элементов enum'а:
constexpr std::size_t color_count = magic_enum::enum_count<Color>();
👉🏿 Свои перегруженные io операторы:
using magic_enum::iostream_operators::operator<<; // out-of-the-box ostream operators for enums.
Color color = Color::BLUE;
std::cout << color << std::endl; // "BLUE"
и много чего еще.
Обзор фукнциональности можно найти в репе на гитхабе. Обратите особое внимание на ограничения библиотеки.
Use magic. Stay cool.
#tools #template25 лист 2025, 05:00
9 357
⚡️C++ давно вышел за рамки системного программирования — сегодня на нём создают визуальные приложения, графику и полноценные пользовательские интерфейсы. Если вы когда-нибудь задумывались, как работают кнопки, чекбоксы и окна — этот урок для вас.
На открытом вебинаре разберём, как создавать собственные элементы интерфейса на чистом C++ — без громоздких фреймворков и магии “за кулисами”. Вы научитесь обрабатывать события мыши и клавиатуры, отрисовывать элементы, управлять объектами и проектировать реакцию интерфейса на действия пользователя.
Урок будет полезен тем, кто хочет глубже понять, как работает графика “под капотом”, и добавить в свои проекты реальный интерактив. Вы получите понимание принципов низкоуровневого UI, навыки работы с графикой и возможность создавать собственные визуальные приложения.
👉27 ноября в 20:00 МСК. Открытый вебинар проходит в преддверии старта курса «C++ Developer. Professional». Регистрация открыта: https://otus.pw/geP4/
Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576
25 лист 2025, 02:02
01 груд 2025, ~02:48
9 357
Удобно превращаем enum в число
#опытным
В прошлом посте мы выяснили, что с С++11 можно самостоятельно указывать нижележащий тип, который и хранит все элементы enum'а.
Но вот представьте себе, что вам где-то нужно получить числовое представление одного из перечислителя. К какому типу кастовать?
Это важно, потому что scoped enum неявно не приводится к числам. Нам нужно явно указывать тип:
enum class ColorMask : std::uint32_t
{
red = 0xFF,
green = (red << 8),
blue = (green << 8),
alpha = (blue << 8)
};
// std::cout << ColorMask::red << std::endl; // ERROR
std::cout << static_cast<int>(ColorMask::red) << std::endl;
Если вам просто нужно вывести число в поток, то кастуйте к инту, ничего страшного не будет. Однако математические операции над полученным числом могут доставить неприятности, если тип будет не тот и будут использоваться сужающие-расширяющие преобразования.
Современные IDE-шки возможно будут вам показывать нужный тип, а возможно и нет. Если тип enum'а явно указан, то можно взять его. Но если нет, то гадать не хочется. Хочется стандартного решения.
С++11 также вводит тип шаблонный тип std::underlying_type, который предоставляет зависимый тип type, содержащий подкапотный тип enum'a:
enum e1 {};
enum class e2 {};
enum class e3 : unsigned {};
enum class e4 : int {};
constexpr bool e1_t = std::is_same_v<std::underlying_type_t<e1>, int>;
constexpr bool e2_t = std::is_same_v<std::underlying_type_t<e2>, int>;
constexpr bool e3_t = std::is_same_v<std::underlying_type_t<e3>, int>;
constexpr bool e4_t = std::is_same_v<std::underlying_type_t<e4>, int>;
std::cout
<< "underlying type for 'e1' is " << (e1_t ? "int" : "non-int") << '\n'
<< "underlying type for 'e2' is " << (e2_t ? "int" : "non-int") << '\n'
<< "underlying type for 'e3' is " << (e3_t ? "int" : "non-int") << '\n'
<< "underlying type for 'e4' is " << (e4_t ? "int" : "non-int") << '\n';
// OUTPUT
// underlying type for 'e1' is non-int
// underlying type for 'e2' is int
// underlying type for 'e3' is non-int
// underlying type for 'e4' is int
Соответственно, для каста нужно сделать такую штуку:
auto num = static_cast<std::underlying_type_t<ColorMask>>(ColorMask::red);
Плохо, что это очень громоздкая конструкция, где к тому же типы повторяются. Поэтому в С++23 ввели хэлпер-сахарок std::to_underlying, который за нас все это делает:
auto num = std::to_underlying(ColorMask::red);
Красота!
Know your type. Stay cool.
#cpp11 #cpp2322 лист 2025, 06:00
9 357
Размер enum'а
#опытным
Перечисления - это по факту именованные числа. Каждому перечислителю ставится в соответствие число, к которому перечислитель может приводиться. Оно либо указывается явно, либо проставляется компилятором.
Но тогда встает вопрос: а сколько весит enum? Мы же про эффективность и хотим, чтобы данные занимали минимально возможное пространство.
Мы можем явно написать:
enum MY_FAVOURITE_FRUITS
{
E_APPLE = 0x01,
E_WATERMELON = 0x02,
E_COCONUT = 0x04,
E_STRAWBERRY = 0x08,
E_CHERRY = 0x10,
E_PINEAPPLE = 0x20,
E_BANANA = 0x40,
E_MANGO = 0x80,
E_MY_FAVOURITE_FRUITS_FORCE8 = 0xFF // 'Force' 8bits, how can you tell?
};
Мы как бы явно говорим, что ограничиваем размер enum'а 8-ью битами. Но будет ли его размер реально 8 бит?
Не факт. Компилятор может выбрать любой подходящий по размеру тип, главное, чтобы он мог вместить все элементы перечисления. Это может быть char, short или int. И все это разного размера.
Неприятно, что на это нельзя было влиять.
Но прочь неприятности, потому что в С++11, помимо enum class появилась возможность указания размера scoped и unscoped enum'ов:
enum class E_MY_FAVOURITE_FRUITS : unsigned char
{
E_APPLE = 0x01,
E_WATERMELON = 0x02,
E_COCONUT = 0x04,
E_STRAWBERRY = 0x08,
E_CHERRY = 0x10,
E_PINEAPPLE = 0x20,
E_BANANA = 0x40,
E_MANGO = 0x80,
E_DEVIL_FRUIT = 0xFF
};
И теперь вы может контролировать и сами задавать размер перечисления.
Control your size. Stay cool.
#cpp1120 лист 2025, 05:00
9 357
📌 Многие разработчики уверены, что проблема в алгоритме. Но на практике код «тормозит» чаще из-за того, как он работает с памятью.
На открытом уроке 25 ноября в 19:00 мы разберём, почему два одинаковых на вид фрагмента кода в C++ могут показывать кардинально разную производительность. Поговорим о том, как устроены уровни памяти, какие паттерны доступа ускоряют программу в разы и как формируется та самая «интуиция» эффективного инженера.
Вы увидите на практических примерах, как принципы оптимизации, привычные для работы с HDD, прекрасно масштабируются до SSD и оперативной памяти. Это знания, которые повышают ценность любого C++ разработчика — от начинающего до уверенного middle.
⚡️Оставьте заявку и присоединяйтесь к открытому уроку в преддверие старта курса «C++ Developer»: https://otus.pw/HElN/
Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576
20 лист 2025, 02:00
25 лист 2025, ~06:48
9 357
enum struct
#опытным
В прошлом посте мы рассказали про enum class. И в 99.999% случаев эту сущность будут писать в коде именно, как enum class.
Но можно написать enum struct и это тоже будет работать!
enum class FileMode { Read, Write, Append };
enum struct LogLevel { Debug, Info, Warning, Error };
int main() {
FileMode mode = FileMode::Read;
LogLevel level = LogLevel::Info;
std::cout << (mode == FileMode::Read) << std::endl;
std::cout << (level == LogLevel::Info) << std::endl;
}
Немного кто знает вообще о существовании такой конструкции. Свойства enum struct абсолютно аналогичны enum class и структуры перечислений были введены просто для консистентности и поддержания паритета в возможности использования двух ключевых слов.
Вот такой короткий и бесполезный факт из мира плюсов)
Be useful. Stay cool.
#fun #cpp1119 лист 2025, 06:00
9 357
enum class
#новичкам
Перечисления пришли в С++ еще из С и отлично живут. Однако плюсовикам не очень с ними комфортно работать с силу наследования слабой типизации и неявных преобразований enum'ов в числовые типы и в другие enum'ы
В С++11 появился новый тип перечислений - scoped enumerations. Или ограниченные областью видимости перечисления. Определяются они так:
enum class Enumeration {CATEGORY1, CATEGORY2, CATEGORY3};
Он решает две большие проблемы обычных перечислений:
👉🏿 Обычные перечисления неявно преобразуются в int и обратно, что вызывает ошибки, когда не предполагается использование перечисления в качестве целого числа.
Можно например попробовать получить следующее значение перечисления, просто прибавив единицу:
enum Color { RED, GREEN, BLUE };
Color c = RED;
Color next = c + 1; // Implicit conversion to int and visa versa!
Что значит прибавить красному цвету единицу - решительно непонятно.
Неявные преобразования enum class'ов же запрещено:
enum class Color { RED, GREEN, BLUE };
Color c = Color::RED;
Color next = c + 1; // ERROR!
Если вам сильно нужно преобразовать перечислитель к числу, то вы это должны сделать явно:
Color c = Color::RED;
Color next = static_cast<Color>(static_cast<int>(c) + 1);
👉🏿 Обычные перечисления экспортируют свои перечислители в окружающую область видимости, вызывая конфликты имён с другими сущностями в этой окружающей области:
enum Color { RED, GREEN, BLUE };
enum TrafficLight { RED, YELLOW, GREEN }; // ERROR!
void graphics_library() {
Color c = RED;
}
У soped enum'ов такой проблемы нет. Имена перечислителей находятся в скоупе своего перечисления:
enum class Color1 { RED, GREEN, BLUE };
enum class Color2 { RED, GREEN, BLUE };
void graphics_library() {
Color1 c1 = Color1::RED;
Color2 c2 = Color2::RED;
}
И все прекрасно компилируется.
С учетом неймспейсов и любви к явным кастам в коммьюнити, в С++ лучше использовать enum class'ы вместо обычных перечислений.
Protect your scope. Stay cool.
#cppcore #cpp1118 лист 2025, 04:00
9 357
+4
Этот митап уже становится доброй традицией: ведь это — Сплошные Плюсы и никаких минусов ❤️
ЦУ и PVS-Studio приглашают плюсистов на четвёртую встречу клуба С++ разработчиков.
«Сплошные плюсы» — это прежде всего интересное общение в дружеской обстановке и атмосфера комьюнити. А ещё вас ждут приятные бонусы, увлекательные квизы и эксклюзивный мерч. 🔥
Темы докладов:
🔵 Неопределённое поведение
Если про него не думаете, это не значит, что его нет C++ — опасный инструмент, и не помешает лишний раз напомнить, как правильно держать его в руках. Причём с приходом инструментов вайб-кодинга ситуация, скорее всего, даже ухудшится, так как станет ещё сложнее удерживать неопределённое поведение под контролем. Обсудим эту тему, заглянув в будущее.
🔵 Российские операционные системы реального времени семейства Багет
В докладе будет представлена уникальная отечественная разработка, созданная в НИЦ «Курчатовский институт» — НИИСИ, — ОСРВ семейства Багет (2.x, 3. x, 4. x), поддерживающие жесткие требования реального времени, современные стандарты, включая POSIX и ARINC 653, и работающие на российских процессорах собственной разработки.
🗓 Когда: 25 ноября в 18:00
📍Где: Москва, кампус ЦУ, ул. Гашека, д.7 стр. 1.
Подробности и регистрация по ссылке 🔗
18 лист 2025, 02:00
21 лист 2025, ~04:12
9 357
Двойной unlock
#опытным
Если не пользоваться RAII, то можно наткнуться на массу проблем. Все знают про double free. Но менее известна проблема double unlock.
Все просто, вы используете ручной lock-unlock мьютекса и возможно попадаете в ситуацию двойного освобождения:
void unsafe_function(int value) {
mtx.lock();
if (value < 0) {
std::cout << "Error: negative value\n";
mtx.unlock();
// forget to return!
}
shared_data = value;
std::cout << "Data has updated: " << shared_data << std::endl;
mtx.unlock(); // second unlock
}
Практически всегда двойной unlock происходит из-за некорректного кода в той или иной степени. Забыть вызвать return кажется детской проблемой, но если вы например не написали тесты на эту ветку, то возможно вы наткнетесь на проблемы только в проде.
А проблемы могут быть примерно любыми. Потому что двойной unlock мьютекса - UB по стандарту. Соответственно, можете получить много непрятностей, от сегфолта до бесконечного ожидания.
Поэтому просто используйте RAII и спина болеть не будет:
void safe_function(int value) {
std::lock_guard lg{mtx};
if (value < 0) {
std::cout << "Error: negative value\n";
return;
}
shared_data = value;
std::cout << "Data has updated: " << shared_data << std::endl;
}
Use safe technics. Stay cool.
#concurrency #cpp1116 лист 2025, 04:00
9 357
Как динамически выделить память на стеке?
#опытным
В книжке "Вредные советы для С++ программистов" от PVS-студии есть такой вредный совет: "массив на стеке - это лучшее решение"
Типа выделение памяти в куче - это зло. char c[256] хватит всем, а если не хватит, то потом поменяем на 512. В крайнем случае – на 1024.
Да, использование буферов, фиксированного размера действительно может привести в проблемам в коде. Запилили новую фичу, изменили размер данных, а забыли поменять размер массива. Пожалуйста, UB.
Но возникает вопрос: а как тогда можно динамически выделять память на стеке? Ведь стандартные C-style массивы работают только с известными в compile-time размерами.
Пара способов есть, но они с "нюансом":
1️⃣ Variable Length Array. Вы просто берете и создаете массив переменного размера:
void foo(size_t n) {
float array[n];
// ....
}
Круто!
Да, но это не часть стандарта С++) Это фича языка С, доступная с С99. Однако GCC например поддерживает ее, как компиляторное расширение языка и вы сможете g++'ом сгенерировать код выше.
2️⃣ alloca. Функция, которая аллоцирует заданное количество байт на стеке:
void *alloca(size_t size);
void foo(size_t n) {
float array = (float)alloca(sizeof(float) * n);
}
Память, выделенная alloca автоматически освобождается при выходе из функции.
Эта также нестандартная функция, которая не является даже частью ANSI-C стандарта, но поддерживается многими компиляторами(в т.ч. является частью Linux API).
Ну и на этом все.
Стандартных решений нет. И на это есть причина. Дело в том, что такой код провоцирует возникновение в программах уязвимостей.
В стандарте MISRA C есть правило MISRA-C-18.8, указывающее не использовать VLA. Другие руководства, такие как SEI CERT C Coding Standard (ARR32-C) и Common Weakness Enumeration (CWE-129), не запрещают использовать эти массивы, но призывают проверять перед созданием их размер.
Не учли, что могут прийти неожиданные данные, выделили охренелион байт и получили переполнение стека. Это вариант DoS-атаки уровня приложения.
На счет alloca вообще есть интересные интересности. Представьте себе, что будет если компилятор попытается встроить код этой функции:
void DoSomething() {
char pStr = alloca(100);
//......
}
в вызывающий код:
void Process() {
for (i = 0; i < 1000000; i++) {
DoSomething();
}
}
Так как память, выделенная alloca освобождается только после завершения функции, а не выходе из скоупа, то получает взрыв размера стека.
И теперь представьте лицо программиста, который написал этот код с учетом вызова alloca именно во фрейме функции DoSomething.
Манипуляции со стеком - не очень безопасно, поэтому ничего такого и не вводят в плюсы.
Be safe. Stay cool.
#NONSTANDARD #goodoldc14 лист 2025, 03:00
9 357
join
#опытным
Как прекрасно сделан в питоне метод join у строки. Чтобы соединить список строк разделителем нужно просто написать:
my_list = ["John", "Peter", "Vicky"]
x = " ".join(myTuple)
print(x)
# OUTPUT
# John Peter Vicky
И как же сложно того же результата достичь в плюсах!
То делают через потоки:
std::string join(const std::vector<std::string>& vec, const std::string& delimiter) {
if (vec.empty()) return "";
std::ostringstream oss;
oss << vec[0];
for (size_t i = 1; i < vec.size(); ++i) {
oss << delimiter << vec[i];
}
return oss.str();
}
то через std::accumutate:
std::string join(const std::vector<std::string>& vec, const std::string& delimiter) {
if (vec.empty()) return "";
return std::accumulate(
std::next(vec.begin()), vec.end(),
vec[0],
[&delimiter](const std::string& a, const std::string& b) {
return a + delimiter + b;
}
);
}
Ну вы что! Стандартная строка же себе не может позволить иметь метод join, принимающий коллекцию строк и возвращающий объединенную строку с разделителями. Это же не универсально и никому не надо...
Но в С++23 наконец-то появилось хоть что-то похожее на адекватное решение. Используем std::views::join_with:
std::string join(const std::vector<std::string> &vec,
const std::string &delimiter) {
return vec | std::views::join_with(delimiter) |
std::ranges::to<std::string>();
}
Можете обмазать все это шаблонами с головы до пят, чтобы получить универсальное решение, либо использовать этот код прям inplace, он и так довольно понятный.
И жизнь стала чуть-чуть счастливее...
Make thing simple. Stay cool.
#cpp2312 лист 2025, 05:00
9 357
Комьюнити, полезное для всех бекенд-разработчиков
Как работает VK изнутри? Что происходит за интерфейсами, когда миллионы пользователей одновременно отправляют сообщения, загружают фото и смотрят клипы?
В канале Backend VK Hub мы рассказываем о работе всех наших сервисах: от VK Play до Tarantool. Делимся подходами к масштабированию, оптимизации и новым архитектурным решениям. Открыто дискутируем, а также регулярно публикуем вакансии в нашу команду.
Здесь — реальные кейсы, технические разборы, советы от наших экспертов и возможность поговорить с ними в любой момент.
Подписывайся!
12 лист 2025, 02:00
17 лист 2025, ~02:00
