Грокаем C++
Ir al canal en Telegram
Два сеньора C++ - Владимир и Денис - отныне ваши гиды в этом дремучем мире плюсов. По всем вопросам (+ реклама) @ninjatelegramm Менеджер: @Spiral_Yuri Реклама: https://telega.in/c/grokaemcpp Мы на TGstat: https://tgstat.ru/channel/@grokaemcpp/stat
Mostrar más9 362
Suscriptores
+324 horas
+257 días
+1530 días
Archivo de publicaciones
9 360
КосмоХакатон 11–13 сентября.
Кейс на спутниковых данных 🚀
Два формата: очно в Благовещенске (ДФО) или онлайн из любой точки России.
Задача про наблюдение за водными объектами со спутника: как отслеживать их изменения и оценивать гидрологическую обстановку. Паводки, обмеление, разливы. Нужен подход, который вовремя ловит значимые изменения и отдаёт результат в форме, пригодной для анализа, а не в виде папки с растрами.
🏆 Призовой фонд площадки — 600 000 ₽
🛰 Команды от 3 до 5 человек. Собери свою или присоединяйся к другим на нашей платформе.
🚀 Лучшие команды выходят в финал в Москве 25–27 сентября — ещё 2,4 млн ₽, и туда тоже можно подключиться онлайн
Детали и расписание: космохакатон.рф/blagoveshchensk
09 sep, 09:00
14 sep, ~16:38
9 360
Результаты ревью
#опытным
Спасибо всем комментаторам за актив и зоркие глаза! Да, да, ревью - это не только про знания, но еще и про умение замечать все мельчайшие недочеты. Но это лирика, погнали по проблемам. Напомню код:
#include <atomic>
#include <mutex>
#include <queue>
#include <thread>
struct Worker {
Worker()
: t([](std::stop_source st) {
while (!st.stop_requested()) {
std::lock_guard<std::mutex> lock(m);
q.push(1);
}
}) {}
std::thread t;
std::mutex m;
std::queue<int> q;
};
int main() {
Worker w;
}
Начнем с простых и дойдем до серьезных:
🔞 Лишний хэдэр, соответственно лишнее время, которое тратится при компиляции на его анализ.
🔞 Внутри коллбэка используются поля класса, при этом захват у лямбды по умолчанию. Эта штука не заработает без захвата this.
🔞 Зачем-то в цикле идет захват лока, хотя никакой реальной конкурентной обработки очереди в данном конкретном случае нет. Его просто можно выкинуть.
🔞 Поток-то мы создали, а завершаться он как будет? std::thread всегда нужно мануально завершать. Но вообще говоря, токены останова сильно намекают на jthread'ы, поэтому можно их использовать и все заведется.
🔞 Коллбэк запуска потоков принимает std::stop_source. Для того, чтобы механизм остановки через стоп-сигналы из С++20 работал, коллбэку std::jthread нужно принимать std::stop_token.
🔞 Ну и основная "нетривиальная" проблема в этом коде. При создании потока в списке инициализации мы захватываем по сути еще неготовый объект. Мьютекс и очередь еще даже по умолчанию не инициализированы. И поток вполне может запуститься со ссылкой на эти неинициализированные данные. А это уже UB.
🔞 В ту же колоду отходит проблема при разрушении объекта. Даже, если мы сделаем jthread и он сможет хоть как-то разрушиться. Вызовы деструкторов полей класса происходят в порядке обратном объявлению. А значит очередь и мьютекс разрушаться до вызова деструктора потока. Что опять же приводит к dangling reference и ub.
Пофиксить просто - объявляем поток в самом низу и дело в шляпе.
Вот исправленная версия:
#include <queue>
#include <thread>
struct Worker {
Worker()
: t([this](std::stop_token st) {
while (!st.stop_requested()) {
q.push(1);
}
}) {}
std::queue<int> q;
std::jthread t;
};
int main() {
Worker w;
}
Спасибо, @vm05s24 и @thonease за пристальное ревью)
Fix your flaws. Stay cool.06 sep, 05:00
9 360
Ревью
#опытным
Как-то мы обходили стороной некоторые обновления в стандартной concurrency библиотеке С++.
Можно было бы начать прям сразу, но зайдем с небольшого интерактива в рамках рубрики #ревью.
Все просто: мы даем небольшой кусочек кода, а вы накидываетесь и оставляете комменты о том, что в этом коде на ваш взгляд не так. Все как в стандартном процессе кодревью.
Единственное, надо учитывать формат "небольшого кусочка кода", который тяжело сделать практически полезным.
Вот и сам код:
#include <atomic>
#include <mutex>
#include <queue>
#include <thread>
struct Worker {
Worker()
: t([](std::stop_source st) {
while (!st.stop_requested()) {
std::lock_guard<std::mutex> lock(m);
q.push(1);
}
}) {}
std::thread t;
std::mutex m;
std::queue<int> q;
};
int main() {
Worker w;
}
Комментатора с самым большим количеством корректно отмеченных проблем упомянем в завтрашнем посте с разбором.
Раз, два, три, код в порядок приведи!
Critique your decisions. Stay cool.04 sep, 05:00
9 360
Какой метод не переопределяется?
#новичкам
Для начала. Что будет если не пометить переопределенный в дочернем классе метод как override?
Обычно говорят, что override генерирует проверку компилятора, что данный метод действительно переопределяет метод базового класса. И соотвественно ошибку в случае, если это не так.
Проверки - это дело важное и нужное, их нужно использовать. Но в том-то и дело, что override - это лишь проверка. Она никак не влияет на то, реально ли переопределяется метод или нет.
Взглядните на этот код:
struct Base {
virtual void foo(int i) const {
std::cout << "Base" << std::endl;
}
};
struct Derived : Base {
void foo(int) const {
std::cout << "Derived" << std::endl;
}
};
int main() {
std::unique_ptr<Base> p = std::make_unique<Derived>();
p->foo(42);
}
Является ли метод foo в Derived переопределением метода из Base?
Казалось бы, нет пометок ни virtual, ни override.
Но это и не важно. Главное, чтобы сигнатура метода из дочернего класса была ровно такой же, какой была сигнатура виртуального метода в базовом классе. Здесь с этим все в порядке, поэтому метод действительно переопределяется..
То есть метод не переопределяется только в случае отличной сигнатуры. Поставьте в этом случае override и тогда будет ошибка компиляции. Поставьте в наследнике virtual и сделаете новый метод виртуальный метод в наследнике. Ничего не делаете и получите просто новый невиртуальный метод в наследнике.
Что же влияет на сигнатуру?
1️⃣ Имя функции и набор параметров. Это банально и все знают.
2️⃣ CV-квалификация метода. Грубо говоря, константный метод или нет.
3️⃣ Ref-квалификация метода. Говорили о них тут.
Если что-то из этого не соответствует виртуальному методу в родительском классе, то дочерний метод не будет переопределять родителя.
Use checks. Stay cool.
#cppcore30 ago, 08:00
9 360
Человеческие сообщения об ошибках в static_assert
#опытным
Одной неприятной особенностью static_assert еще с С++11 были ограничения на сообщения об ошибках. По сути могли использоваться только строковые литералы. ТО есть просто фиксированные строки. Никаких динамических преобразований:
template <class T>
void g() {
static_assert(sizeof(T) == 4, "Type T size is not 4");
}
Из сообщения об ошибке компиляции: error: static assertion failed: Type T size is not 4 мы узнаем лишь то, что размер не равен 4.
Хотя, вообще говоря, было бы неплохо увидеть размер переданного типа прямо в сообщении об ошибке для упрощения дебага. Но сделать мы этого не могли, даже константные выражения не могли использоваться.
До С++26, когда завезли константные выражения в сообщения об ошибках. После запятой может быть объект msg, у которого должны быть 2 constexpr метода .data() для получения указателя на начало строки и .size() для получения размера.
Это позволило использовать различные библиотеки форматирования внутри сообщения об ошибке. Например std::format:
template <class T>
void f() {
static_assert( sizeof(T) == 4,
std::format("Type T size should be 4, actual: {}", sizeof(T)) );
}
int main() {
f<std::int32_t>();
f<std::int64_t>();
}
И это работает уже на gcc.
Так что внутри static_assert теперь разрешены любые выкрутасы, главное чтобы они были константными выражениями.
Be flexible. Stay cool.
#cpp2628 ago, 06:00
9 360
❓Кто этот призрак в вашем коде: изучаем особенности работы с легаси на C++
Легаси — вот что объединяет всех разработчиков на всех языках программирования. Мы учимся уживаться с «наследием», встраиваем его в современную кодовую базу или стараемся не трогать.
Пришло время разобраться с легаси в email-проекте Ghost in the code.
Вы получите семь писем от инженеров, в числе которых представитель России в Международной рабочей группе по стандартизации C++ Антон Полухин и эксперт по архитектуре Константин Владимиров. Вместе с ними и другими опытным разработчиками пройдете путь от навигации по «зрелому» коду с помощью AI до выстраивания процессов с учетом легаси.
➡️Подписывайтесь на серию писем, это бесплатно. Оставляйте email-адрес на сайте проекта — первое письмо придет 15 сентября.
28 ago, 03:00
27 sep, ~05:35
9 360
Какой тип nullptr?
#опытным
Для многих nullptr - это магическая хреновина, которая магически и правильно "зануляет"(что бы это не значило) указатель. А как это работает - уже не важно. И даже на этом уровне понимания можно прекрасно писать хороший код и не знать забот. Но мы здесь собрались для грокания С++, поэтому будем разбираться.
Для начала, nullptr - это литерал указателя. Есть литералы целочисленые(
42, -100), есть литералы строковые("123", "qwerty"), а есть литерал указателя и nullptr - его единственный представитель. Литерал - это prvalue.
Этот литерал обозначает константу нулевого указателя. То есть при присваивании указателю nullptr'а, он зануляется. Происходит это потому что существует неявное преобразование nullptr к значению нулевого указателя любого указательного типа.
Но это не единственная константа нулевого указателя. Есть также литералы 0 и NULL.
У каждого литерала есть свой тип. У nullptr это std::nullptr_t. А у 0 и NULL - int. И этом кроется вся суть:
void g(int*)
{
std::cout << "Function g called\n";
}
int main()
{
g(nullptr); // Fine
g(NULL); // Fine
g(0); // Fine
// But
auto null1 = nullptr;
auto null2 = NULL;
auto null3 = 0;
g(null1); // Fine
g(null2); // ERROR: non-literal zero cannot be a null pointer constant
g(null3); // ERROR: non-literal zero cannot be a null pointer constant
}
Как только мы присвоили NULL или 0 какой-то переменной, они потеряли способность инициализировать указатели. Потому что они просто стали какой-то переменной типа int, а какими-то рандомными числами очень странно инициализировать указатели.
Но с nullptr другая штука. null1 - это переменная типа std::nullptr_t. И здесь нет никакой неоднозначности. Этот тип придуман для того, чтобы представлять нулевой указатель. Он больше ни для чего не нужен. Поэтому также есть неявные преобразование любых значений типа std::nullptr_t к значению нулевого указателя. Это значит, сколько бы раз не был прокинут nullptr в разные переменные, он всегда будет означать именно нулевой указатель.
Don't be ambiguous. Stay cool.
#cpp1125 ago, 05:00
9 360
Критическая секция. Примитив синхронизации
#опытным
Стандартный ответ на обычный вопрос "а какие примитивы синхронизации вы знаете?" - мьютексы, атомарные переменные, условные переменные. Для них есть привычные инструменты в языке - std::mutex, std::atomic и std::condition_variable.
Иногда проскальзывают в ответах более опытных людей людей семафоры и барьеры - std::counting_semophore и std::barrier.
Но очень очень редко кто-то да упомянет критическую секцию.
Если вы пишите только на плюсах и кроссплатформенный код, то вряд ли вообще слышали про этот примитив. В стандартной библиотеке нет класса std::critical_section. Тем не менее такой примитив действительно есть, просто в чистом Windows API.
По названию понятно, что примитив CRITICAL_SECTION защищает блок кода (критическую секцию в первом значении) от одновременного исполнения более чем одним потоком. Но общепринятый примив для такой ситуации - мьютекс. В чем тогда разница CRITICAL_SECTION и мьютекса?
Сейчас мы отходим от языка и погружаемся в системное апи.
Оба эти примитива выполняют одинаковую функцию - обеспечивают взаимное исключение потоков. Разница в нюансах
Мьютекс может быть использован для синхронизации между несколькими процессами. CRITICAL_SECTION помогает синхронизировать потоки только внутри одного процесса.
CRITICAL_SECTION также чуть лучше перформит за счет того, что перед блокировкой потока там стоит спинлок, который позволяет избежать дорогого обращение к ядру для помещения потока в очередь ожидания.
Вот и вся разница.
Наиболее близким аналогом CRITICAL_SECTION в линуксе можно считать futex, в котором дорогостоящий системный вызов происходит только, когда несколько потоков прям вот сейчас пытаются войти в защищаемый блок кода.
На уровне С++ мы имеем все тот же std::mutex, который скорее всего также использует эту оптимизацию, поэтому в языке про CRITICAL_SECTION ни сном, ни духом.
Think critical. Stay cool.
#concurrency
24 ago, 06:00
9 360
Приглашаем на бесплатный открытый вебинар курса «Программист С»: «С без компромиссов: обработка ошибок и полиморфизм»
Когда: 25 августа, 20:00 (мск)
Язык С даёт полный контроль над памятью и железом, но за эту мощь приходится платить — в нём нет встроенных исключений и классов. Однако, это не значит, что отказоустойчивость и гибкость недоступны. На вебинаре разберём техники, которые обычно остаются за кадром, и покажем, как писать на С надёжно, масштабируемо и без ущерба для производительности.
Что будет на вебинаре:
Рассмотрим setjmp/longjmp — аналог исключений, который позволяет «телепортироваться» сквозь стек вызовов;
Создадим виртуальные таблицы (vtable) — руками реализуем полиморфизм, как в C++;
Соединим обе техники в одном проекте – создадим систему логирования с централизованной обработкой ошибок.
Зарегистрироваться https://otus.pw/4vWb/
Бесплатное занятие приурочено к старту курса «Программист С», на котором вы освоите продвинутые приёмы работы с памятью, многопоточностью, сетевым взаимодействием и созданием высоконагруженных систем на чистом С.
Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576, www.otus.ru
24 ago, 03:05
01 sep, ~11:21
9 360
Критическая секция. Блок кода
#новичкам
Термин "критическая секция" имеет 2 значения и это несколько конфузит как новичков, так и опытных разрабов, кто просто не встречался с двумя личинами термина. Сейчас и в следующем посте разберем оба значения.
Начнем с простого.
Одна из самых больших опасностей многопоточного кода - это гонка данных. Когда 2 потока пытаются читать и записывать в одну ячейку памяти без использования синхронизации.
Проблема гонки на самом деле в том, что потоки могут увидеть промежуточное состояние комплексной операции и вклиниться посередине. Даже банальный инкремент инта это 3 операции: чтение, модификация и запись.
int counter = 0; // unprotected variable
void increment() {
for (int i = 0; i < 10000; ++i) {
++counter; // data race
}
}
int main() {
std::thread t1(increment);
std::thread t2(increment);
t1.join();
t2.join();
// expected 20000, but there is data race so counter will never be eq to the number
std::cout << "Final counter value: " << counter << std::endl;
return 0;
}
Но если мы уже будем говорить про такие комплексные операции, как вставка элемента в контейнер, то проблема становится очень явной. Невозможно потокобезопасно, например, проверить превышение size на capacity в векторе, выделить новую память, перенести туда все элементы вектора и создать новый объект. И чтобы между этих операций в контейнер не вмешался другой поток.
Чуть более понятный пример:
struct Balance {
void withdraw_balance(int amount) {
if (balance_ >= amount {
balance_ -= amount;
}
}
private:
int balance_;
};
Если 2 потока одновременно зайдут в эту функцию, то оба уменьшат баланс. Мало того, что с клиента снимут больше денег, так он еще и должным может остаться(баланс уйдет в минуса).
То есть существуют участки кода, внутри которых происходит доступ к разделяемому ресурсу и там каждый момент времени может исполняться максимум один поток. Такие участки кода называют критическими секциями.
Критические секции должны быть защищены примитивами синхронизации, обеспечивающими взаимное исключение потоков. Например, мьютекс:
struct Balance {
vvoid withdraw_balance(int amount) {
std::lock_guard lg{mtx_};
if (balance_ >= amount {
balance_ -= amount;
}
}
private:
int balance_;
std::mutex mtx_;
};
Критической секцией также может быть только часть функции:
template<typename T>
class ThreadSafeQueue {
std::queue<T> queue_;
std::mutex mtx_;
public:
std::queue<T> pop_all() {
std::queue<T> result;
{ // critical section begin
std::lock_guard<std::mutex> lock(mtx_);
std::swap(result, queue_);
} // critical section end
return result;
}
};
В этом случае очень удобно обозначать ее вложеным скоупом (фигурными скобками) для лучшего выделения на фоне остального кода. Также выход из блока кода триггерит разрушение его локальных объектов, поэтому вам в большинстве случаев не нужно явно вызывать mtx.unlock().
Критические секции стоит делать как можно меньшего размера, чтобы время блокировки потоков было минимально.
Спасибо @antom1n за идею для поста
Think critical. Stay cool.
#concurrency20 ago, 05:00
9 360
Гибридные вектора
#опытным
std::inplace_vector воплощает в себя преимущества динамического расширения размеров и отсутствия аллокаций. Полезная штука, но и она ограничена. Literally: вы не можете добавить в массив элементов больше, чем capacity.
И это нормальные ограничения. Нельзя иметь неограничено расширяемый массив на стеке.
Но что если я знаю, что в 99% случаев мой массив будет содержать не больше N элементов. Но все же иногда нужно будет хранить потенциально намного больше элементов. Что делать?
Ну для начала есть small object optimization для стандартного std::vector. Вместо того, чтобы хранить элементы в куче, небольшое число маленьких по размеру элементов можно хранить на стеке. И при добавлении элементов больше порога уже использовать динамические аллокации. Как SSO в std::string.
Но это не гарантированная оптимизации и зависит от реализации стандартной библиотеки. Плюс невозможно управлять размером этого маленького буфера.
Но можно сделать и более управляемый вариант.
Пусть будет динамический контейнер, в котором мы гарантировано сможем расположить на стеке N элементов, а при превышении этого порога будет триггериться динамическое выделение памяти под буфер большего размера.
Такой комбинированный подход позволяет и рыбку съесть, и на правильный стул сесть. Аллокаций на минимуме, перф суперблейзинговый и привычный интерфейс.
Вот несколько представителей этого подхода:
- absl::InlinedVector.
- boost::container::small_vector.
- llvm::SmallVector.
- folly::small_vector.
Combine advantages. Stay cool.
#performance #memory #optimization
18 ago, 06:00
9 360
💻 АЦП в ESP32. Оцифровать сигнал, а не "погоду на Марсе". Нюансы, особенности, повышение точности
Приглашаем на открытый урок.
🗓 24 августа в 20:00 МСК
🆓 Бесплатно. Урок в рамках старта курса «Embedded-разработчик».
Мы рассмотрим весь пусть сигнала - от датчика до его цифровой формы в микроконтроллере ESP32. Вспомним основные параметры, погрешности АЦП, увидим их влияние "вживую", узнаем, почему иногда теоремы Котельникова недостаточно и что с этим делать? Поговорим о важности источника опорного напряжения, произведем расчет бюджета погрешностей тракта АЦП.
Применим калибровку и сравним результаты до\после на АЦП, после чего рассмотрим простые методы фильтрации исходно зашумленных сигналов.
Вебинар будет полезен: радиолюбителям, начинающим разработчикам электроники, инженерам-схемотехникам, разработчикам встраиваемого программного обеспечения
В результате вебинара слушатели узнают:
✔️ все основные параметры АЦП и смогут увидеть их влияние вживую на примере ESP32
✔️ особенности и нюансы схемотехники при проектировании тракта АЦП
✔️ что такое "алиасинг" и как его избежать
✔️ как провести обобщенный расчет погрешностей тракта АЦП
✔️ как откалибровать АЦП в ESP32
✔️ простые методы фильтрации зашумленных сигналов
🔗 Ссылка на регистрацию: https://otus.pw/X5Wt/
Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576
18 ago, 03:00
24 ago, ~07:50
9 360
std::inplace_vector
#опытным
Стандартная библиотека традиционно запаздывает с внедрением полезного функционала.
Вот у нас есть std::vector. Прекрасный контейнер, расширяемый. более менее все им пользуются. Однако у него есть проблема - динамические аллокации. От них не уйти. А если вам они не нужны, то вы вынуждены использовать другие инструменты. Да и еще и ограниченное использование вектора в constexpr контексте.
Ну ладно. Есть std::array. Нет скрытых аллокаций, давно можно использовать в constexpr. Красота.
Но как бы не так: не расширяемый он. Еще и элементы должны быть созданы сразу все и должны соответствовать требованию DefaultConstructable.
Короче опять недостатки.
Но в С++26 появился контейнер, который объединяет преимущества std::vector и std::array. Называется он std::inplace_vector.
По сути это динамически расширяемый массив с фиксированной в compile-time емкостью:
1️⃣ Элементы массива хранятся прям внутри объекта, поэтому нет никаких дополнительных аллокаций.
2️⃣ Объект inplace_vector сразу при создании содержит буфер размера capacity.
3️⃣ Можно создать объект без элементов вообще и изменять их набор как угодно во время выполнения программы. Главное не превышать capacity.
4️⃣ Так как этот массив не предполагает дополнительных динамических аллокаций, то контейнер можно полноценно использовать в constexpr контексте.
Рассмотрим небольшой примерчик, где нам нужно отфильтровать из std::array пложительные числа и возвести их в квадрат:
template<size_t N>
constexpr std::inplace_vector<int, N> square_positive(const std::array<int, N>& arr) {
std::inplace_vector<int, N> result;
for (int x : arr) {
if (x > 0 && result.size() < result.capacity()) {
result.push_back(x * x);
}
}
return result;
}
int main() {
constexpr std::array<int, 6> data = {-3, 5, -1, 7, 0, 4};
constexpr auto squares = square_positive<6, 6>(data);
static_assert(squares.size() == 3);
static_assert(squares.capacity() == 6);
static_assert(squares[0] == 25);
static_assert(squares[1] == 49);
static_assert(squares[2] == 16);
return 0;
}
Мы не можем заранее сказать, сколько элементов вернет функция square_positive. Но мы можем гарантировать, что их количество <= размеру входного массива.
Создается inplace_vector пустым и элементы накидываются в него по очереди.
Проверки static_assert гарантируют, что все вычисления происходят в compile-time.
Еще одна особенность - у inplace_vector меньше требований к типу своих элементов:
struct S {
S() = delete;
S(int) { }
};
std::array<S, 5> arr; // compile error: S does not have a default constructor
std::inplace_vector<S, 5> inplace_vec; // ok
Так как std::array создает сразу все свои элементы, конструирование arr завершится ошибкой, потому что S не имеет конструктора по умолчанию. Но inplace_vec успешно создается, потому что не имеет этого требования.
Также std::inplace_vector - хороший пример того, что стандартная библиотека в новых стандартах старается поддерживать апи с использованием исключений и без них. Есть принципиально 2 разных подхода к добавлению элементов в этот массив:
👉🏿 constexpr reference push_back( const T& value ) — классический вариант, который выбрасывает std::bad_alloc при попытке превысить capacity.
👉🏿 constexpr std::optional<reference> try_push_back( const T& value ) - добавляет элемент и возвращает на него ссылку или не добавляет элемент и возвращает std::nullopt. То есть ошибка обрабатывается с помощью возвращаемого значения
Есть кстати еще метод constexpr reference unchecked_push_back( const T& value );, который забивает на все проверки и перекладывает эту ответственность на пользователя. В случае превышения емкости получаем UB.
В общем, крутой новый контейнер, который явно найдет себе место в системах с ограничениями кучи или суперпроизводительном софте.
Combine advantages. Stay cool.
#cpp26 #STL15 ago, 05:00
9 360
Мапим значения на типы. Ч2
#опытным
Напомню проблему:
enum class DataType: uint8_t {
kInt32,
kDouble,
kUint64
};
template<typename T>
T create_from_buffer(const void* buffer) {
static_assert(std::is_trivially_copyable_v<T>,
"Type T must be trivially copyable");
T obj;
std::memcpy(&obj, buffer, sizeof(T));
return obj;
}
Как на основе DataType создать объект соответствующего типа?
Compile-time мапа из массива, где по индексу подкапотного числа, стоящего за каждым перечислителем, позволяет получить соответствующий нужный тип и выбрать правильный обработчик. И все это за О(1) с тратами на сдвиг элемента в массиве
Если же перечислителям явно присвоены числа, то этот номер не прокатит и надо думать дальше.
Без шаблонной магии нам не обойтись, ведь мы хотим только добавлять маппинги, но не менять самого кода обработчиков и логику их выбора.
И давайте заодно попробуем уйти от полной специализации шаблонов, как было в предыдущей части.
Сделаем структуру аля ноду маппинга:
template <DataType D, typename T>
struct Node { static constexpr DataType key = D; using type = T; };
В структуре хранится конкретный перечислитель, получаемый из шаблонного параметра, и соответствующий ему тип.
И в качестве пака шаблонных параметров нашей шаблонной функции мы будем передавать список нод Node<DataType::kInt32, int32_t>, Node<DataType::kDouble, double>, Node<DataType::kUint64, uint64_t>.
В функции мы должны сделать примерно следующее. Перебираем рантайм значение enum'а на соответствие значению Key из нод пака параметров. Перебираем, пока не найдем нужный и после используем правильную ноду для получения замаппленого типа.
И вот этот перебор можно делать через fold expression и короткозамкнутый оператор ||. Как только условие истинно, вычисления прекращаются.
template <typename... Es>
DataVariant ConvertImpl(const void* buffer, DataType type) {
DataVariant result;
bool found = ((Es::key == type
? (result = create_from_buffer<typename Es::type>(buffer), true)
: false) || ...);
if (!found) throw std::runtime_error("Unknown type");
return result;
}
DataVariant Convert(const void* buffer, DataType type) {
return ConvertImpl<
Entry<DataType::kInt32, int32_t>,
Entry<DataType::kDouble, double>,
Entry<DataType::kUint64, uint64_t>
>(buffer, type);
}
Также тут используется фишка оператора запятой, что результатом выражения является только самый крайний справа операнд.
Теперь вместо поиска элемента в массиве по индексу мы занимаемся линейным проходом выполнения логического ИЛИ для типов.
На первый взгляд это может быть сильно дольше, но компиляторы хорошо умеют оптимизировать fold expression, даже в худшем случае большой разницы не будет.
Код кстати по размеру уже не сильно больше изначального свитча.
Вот примерчик с рабочим кодом, можете поиграться.
Use tricks. Stay cool.
#template #cpp1710 ago, 06:00
9 360
🏎 Реши реальную задачу из закрытого мира HFT – соревнование с призовым фондом 12 000 USD и коротким треком найма
Spectral::Technologies занимается высокочастотным трейдингом (HFT) и уже более семи лет торгует на рынках по всему миру с помощью собственных стратегий и low-latency инфраструктуры. Ребята делают это крайне успешно: инженеры у них получают сотни тысяч долларов фиксом на руки, команда постоянно растет.
Сейчас Spectral нанимает на вакансии C++ SWE и AI SWE (C++, Python). Чтобы вы могли лучше понять, чем занимаются их инженеры – они открыли одну из своих реальных задач в формате соревнования.
Цель соревнования – разработать систему, которая передает поток данных от одного источника нескольким получателям с минимальной задержкой. Добиться низкой задержки в среднем или на медиане можно достаточно стандартными приемами. Настоящий челлендж – сделать так, чтобы на высоких квантилях и под нагрузкой задержка ухудшалась минимально, даже когда растут объем передаваемых данных и количество получателей.
Вместе с участниками эту же задачу будет решать Claude-агент. Его решение будет находиться в публичном репозитории, и вы сможете использовать его как baseline.
Оценивать будут распределение задержки, масштабируемость, корректность и воспроизводимость решения. Использовать AI-инструменты при разработке можно.
Участие индивидуальное. Опыт в HFT необязателен, но пригодятся уверенные знания C++, системного программирования, сетей и оптимизации производительности.
🏆 Призы:
1 место – 6 000 USD gross
2 место – 3 600 USD gross
3 место – 2 400 USD gross
Авторам лучших работ – и не только участникам из топ-3 – предложат сокращенный трек найма на позиции C++ Software Engineer или AI Software Engineer. Лучших участников также ждет мерч.
Соревнование уже идет. Присоединиться можно в любой момент до дедлайна.
⏰ Дедлайн сдачи решений – 30 августа, 23:59 GMT+3
Регистрация и доступ к GitLab с задачей – @spectral_challenge_bot
10 ago, 05:00
11 ago, ~07:06
9 360
Мапим значения на типы. Ч1
#опытным
Иногда требуется на основе какого-то рантайм значения, например перечисления, получить какой-то соответствующий тип.
Например, у вас есть шаблонная функция и вы хотите вызвать правильную ее инстанциацию:
enum class DataType: uint8_t {
kInt32,
kDouble,
kUint64
};
template<typename T>
T create_from_buffer(const void* buffer) {
static_assert(std::is_trivially_copyable_v<T>,
"Type T must be trivially copyable");
T obj;
std::memcpy(&obj, buffer, sizeof(T));
return obj;
}
Как на основе DataType создать объект нужного типа?
Пойдем доисторическим способом. Там, где есть enum, всегда где-то в углу стоит застенчивый switch и хочет быть использован. Ну давайте попробуем:
using DataVariant = std::variant<int32_t, double, uint64_t>;
DataVariant foo(const void* buffer, DataType type) {
switch (type) {
case DataType::kInt32:
return create_from_buffer<int32_t>(buffer);
// ...
default:
throw std::runtime_error("Unknown type");
}
}
И это вроде работает. Но не зря switch стоит в углу:
1️⃣ Он смешивает логику выбора, соответствия сущностей и обработки
2️⃣ Часто он приводит к длинным функциям, которые сложно поддерживать
3️⃣ switch может и быстрый, но засоряет клиентский код.
К тому же код кучу раз повторяется конкретно в этом кейсе.
Давайте пробовать решать.
Если наш enum плотный aka вы не присваивали никаким перечислителям числа, то можно примерно все красиво вынести в compile-time.
Начнем с того, что нужно создать compile-time маппинг между типами и перечислителями. Это поможет в коде отделить логику соответствия enum'а и типов:
enum class DataType : uint8_t { kInt32, kDouble, kUint64, kCount };
template <DataType> struct EnumMap;
template <> struct EnumMap<DataType::kInt32> { using Type = int32_t; };
template <> struct EnumMap<DataType::kDouble> { using Type = double; };
template <> struct EnumMap<DataType::kUint64> { using Type = uint64_t; };
template <DataType D>
using EnumMappedType = typename EnumMap<D>::Type;
Используем полную специализацию шаблонов и зависимые типы.
Дальше нужна логика обработки
using DataVariant = std::variant<int32_t, double, uint64_t>;
using MakerFn = DataVariant()(const void);
template <std::size_t... Is>
constexpr auto make_table(std::index_sequence<Is...>) {
return std::array<MakerFn, sizeof...(Is)>{
+[](const void* buffer) -> DataVariant {
return create_from_buffer<EnumMappedType<static_cast<DataType>(Is)>>(buffer);
}...
};
}
static constexpr auto dispatcher =
make_table(std::make_index_sequence<static_cast<std::size_t>(DataType::kCount)>{});
Через fold expression делаем массив обработчиков для каждого элемента перечисления. Это гарантирует std::make_index_sequence<static_cast<std::size_t>(DataType::kCount)>, который раскрывается в последовательность индексов перечислителей вплоть до последнего kCount.
Для этого и было условие плотности enum'а, чтобы make_index_sequence корректно передавал индексы.
Для каждого обработчика выбираем нужный тип через EnumMappedType.
Плюсик перед лямбдой кастит ее к указателю на функцию. Это чтобы не использовать опасный для перфа std::function.
Ну а логику выбора написать уже очень просто:
DataVariant foo(const void* buffer, DataType type) {
auto idx = static_cast<std::size_t>(type);
if (idx >= dispatcher.size())
throw std::runtime_error("Unknown type");
return dispatcheridx;
}
Итого, мы явно разделили 3 задачи: описание обработчиков, маппинг и сам выбор обработчика.
Да, код все еще повторяется при описании маппинга EnumMap. Однако этот код намного более атомарно фундаментальный чтоли. Намного менее вероятно, что он изменится, потому что в нем зашита только необходимый маппинг и больше ничего. Можно делать через туплы парных сущностей, но выглядело бы это сильно менее понятным.
Для неплотных перечислений тоже есть способы, обсудим их в следующем посте.
Divide and conquer. Stay cool.09 ago, 11:00
9 360
Ответ
#опытным
2 вещи нужно знать(помимо всего остального С++😆), чтобы правильно ответить на квиз выше:
1️⃣ Сокрытие имен
Когда в классе объявляют метод с неким именем, все методы с этим именем из базовых классов становятся невидимыми (скрытыми), независимо от их параметров.
То есть
struct A {
void func(const std::string&);
};
struct B : A {
void func(float);
};
B b;
у объекта b можно вызвать только флотовый вариант func.
Почему так?
Компилятор увидел вызов метода и должен выполнить overload resolution. Он видит, что у объекта b статический тип B и идет смотреть, какие методы из этого класса подходят для вызова.
И вот здесь срабатывает ключевая особенность поиска. Компилятор ищет имя func по цепочке областей видимости — снизу вверх (от производного класса к базовому). Как только он находит хотя бы одно объявление с именем func, поиск по иерархии немедленно останавливается . Дальше вверх (в A) он уже не заглядывает.
В классе B есть func(float) — имя найдено. Поиск завершён. В набор кандидатов для overload resolution попадает только B::func(float). Метод A::func(const std::string&) в этот набор даже не рассматривается — он остался за границей поиска.
Поэтому:
b.func(15.f); // OK: float
b.func("hello"); // Compile Error
2️⃣ Вообще говоря, это сокрытие имен - это проблема с точки зрения привычного нам ООП.
"У меня есть базовый класс, от которого я наследую функциональность. Почему я не могу использовать метод базового класса?"
Сокрытие имен - процесс неявный. Но мы можем явно сказать, какой сокрытый метод мы как разработчики хотим видеть в наследнике.
С помощью директивы using можно вернуть видимость методу базового класса в наследник:
struct A {
void func(const std::string&);
};
struct B : A {
using A::func;
void func(float);
};
B b;
b.func(15.f); // OK
b.func("hello"); // OK
using A::func; позволяет компилятору увидеть метод, принимающий строку, и успешно вызывать его при передаче строкового литерала.
Такой же прием кстати используется в реализации overloaded паттерна.
Когда мы это знаем, правильные ответы находятся на поверхности:
struct A {
void func(const std::string&); // #1
};
struct B : A {
void func(float); // #2
};
struct C : B {
using A::func;
void func(int); // #3
};
C c;
B& b = c;
c.func(3.14f); // вызывает #3 за счет неявного приведения float к int
c.func(123); // вызывает #3
c.func("hello"); // вызывает #1 за счет using
b.func(3.14f); // вызывает #2
Don't let others shadow you. Stay cool
#cppcore05 ago, 05:00
9 360
Квиз
Выберете правильные утверждения о вызовах в коде:
struct A {
void func(const std::string&); // #1
};
struct B : A {
void func(float); // #2
};
struct C : B {
using A::func;
void func(int); // #3
};
C c;
B& b = c;04 ago, 06:00
9 360
💻 Тайный язык общения чипов. Подключаем всё к ESP32
Приглашаем на открытый урок.
🗓 12 августа в 20:00 МСК
🆓 Бесплатно. Урок в рамках старта курса «Embedded-разработчик».
Что будет на вебинаре?
✔️ Познакомимся с современными возможностями высокоскоростного обмена данными с микроконтроллерами, с периферийными устройствами, в которых применяется интерфейс/протокол SPI.
✔️ Изучим устройство и особенности программирования самого скоростного и эффективного способа передачи данных между (микроконтроллерными) устройствами при помощи встроенных в ESP32 аппаратных контроллеров SPI.
✔️ Разберем, как воспользоваться драйвером файловой системы RTOS не проиграв в производительности, померяем скорость обмена с реальными устройствами.
✔️ Соберем «квази-компьютер» с диском и экраном (SD-картой и LCD-дисплеем)
🔗 Ссылка на регистрацию: https://vk.cc/d0aTzI
Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576
04 ago, 03:00
11 ago, ~04:30
