es
Feedback

¡No caigas en manos de tramposos! Telemetrio encuentra y marca estos canales 👉 Si quieres ver la etiqueta, suscríbete

Грокаем C++

Грокаем C++

Ir al canal en Telegram

Два сеньора C++ - Владимир и Денис - отныне ваши гиды в этом дремучем мире плюсов. По всем вопросам (+ реклама) @ninjatelegramm Менеджер: @Spiral_Yuri Реклама: https://telega.in/c/grokaemcpp Мы на TGstat: https://tgstat.ru/channel/@grokaemcpp/stat

Mostrar más
9 362
Suscriptores
+324 horas
+257 días
+1530 días
Archivo de publicaciones
КосмоХакатон 11–13 сентября. Кейс на спутниковых данных 🚀 Два формата: очно в Благовещенске (ДФО) или онлайн из любой точки
КосмоХакатон 11–13 сентября. Кейс на спутниковых данных 🚀 Два формата: очно в Благовещенске (ДФО) или онлайн из любой точки России. Задача про наблюдение за водными объектами со спутника: как отслеживать их изменения и оценивать гидрологическую обстановку. Паводки, обмеление, разливы. Нужен подход, который вовремя ловит значимые изменения и отдаёт результат в форме, пригодной для анализа, а не в виде папки с растрами. 🏆 Призовой фонд площадки — 600 000 ₽ 🛰 Команды от 3 до 5 человек. Собери свою или присоединяйся к другим на нашей платформе. 🚀 Лучшие команды выходят в финал в Москве 25–27 сентября — ещё 2,4 млн ₽, и туда тоже можно подключиться онлайн Детали и расписание: космохакатон.рф/blagoveshchensk
09 sep, 09:00
14 sep, ~16:38

​​Результаты ревью #опытным Спасибо всем комментаторам за актив и зоркие глаза! Да, да, ревью - это не только про знания, но еще и про умение замечать все мельчайшие недочеты. Но это лирика, погнали по проблемам. Напомню код:
#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

​​Ревью #опытным Как-то мы обходили стороной некоторые обновления в стандартной 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

​​Какой метод не переопределяется? #новичкам Для начала. Что будет если не пометить переопределенный в дочернем классе метод как 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. #cppcore
30 ago, 08:00

​​Человеческие сообщения об ошибках в 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. #cpp26
28 ago, 06:00

❓Кто этот призрак в вашем коде: изучаем особенности работы с легаси на C++ Легаси — вот что объединяет всех разработчиков на
❓Кто этот призрак в вашем коде: изучаем особенности работы с легаси на C++ Легаси — вот что объединяет всех разработчиков на всех языках программирования. Мы учимся уживаться с «наследием», встраиваем его в современную кодовую базу или стараемся не трогать. Пришло время разобраться с легаси в email-проекте Ghost in the code. Вы получите семь писем от инженеров, в числе которых представитель России в Международной рабочей группе по стандартизации C++ Антон Полухин и эксперт по архитектуре Константин Владимиров. Вместе с ними и другими опытным разработчиками пройдете путь от навигации по «зрелому» коду с помощью AI до выстраивания процессов с учетом легаси. ➡️Подписывайтесь на серию писем, это бесплатно. Оставляйте email-адрес на сайте проекта — первое письмо придет 15 сентября.
28 ago, 03:00
27 sep, ~05:35

​​Какой тип 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. #cpp11
25 ago, 05:00

​​Критическая секция. Примитив синхронизации #опытным Стандартный ответ на обычный вопрос "а какие примитивы синхронизации вы знаете?" - мьютексы, атомарные переменные, условные переменные. Для них есть привычные инструменты в языке - 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

Приглашаем на бесплатный открытый вебинар курса «Программист С»: «С без компромиссов: обработка ошибок и полиморфизм»   Когда: 25 августа, 20:00 (мск) Язык С даёт полный контроль над памятью и железом, но за эту мощь приходится платить — в нём нет встроенных исключений и классов. Однако, это не значит, что отказоустойчивость и гибкость недоступны. На вебинаре разберём техники, которые обычно остаются за кадром, и покажем, как писать на С надёжно, масштабируемо и без ущерба для производительности. Что будет на вебинаре: Рассмотрим setjmp/longjmp — аналог исключений, который позволяет «телепортироваться» сквозь стек вызовов; Создадим виртуальные таблицы (vtable) — руками реализуем полиморфизм, как в C++; Соединим обе техники в одном проекте – создадим систему логирования с централизованной обработкой ошибок. Зарегистрироваться https://otus.pw/4vWb/ Бесплатное занятие приурочено к старту курса «Программист С», на котором вы освоите продвинутые приёмы работы с памятью, многопоточностью, сетевым взаимодействием и созданием высоконагруженных систем на чистом С. Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576, www.otus.ru
24 ago, 03:05
01 sep, ~11:21

​​Критическая секция. Блок кода #новичкам Термин "критическая секция" имеет 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. #concurrency
20 ago, 05:00

​​Гибридные вектора #опытным 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

💻 АЦП в ESP32. Оцифровать сигнал, а не "погоду на Марсе". Нюансы, особенности, повышение точности Приглашаем на открытый уро
💻 АЦП в ESP32. Оцифровать сигнал, а не "погоду на Марсе". Нюансы, особенности, повышение точности Приглашаем на открытый урок. 🗓 24 августа в 20:00 МСК 🆓 Бесплатно. Урок в рамках старта курса «Embedded-разработчик». Мы рассмотрим весь пусть сигнала - от датчика до его цифровой формы в микроконтроллере ESP32. Вспомним основные параметры, погрешности АЦП, увидим их влияние "вживую", узнаем, почему иногда теоремы Котельникова недостаточно и что с этим делать? Поговорим о важности источника опорного напряжения, произведем расчет бюджета погрешностей тракта АЦП. Применим калибровку и сравним результаты до\после на АЦП, после чего рассмотрим простые методы фильтрации исходно зашумленных сигналов. Вебинар будет полезен: радиолюбителям, начинающим разработчикам электроники, инженерам-схемотехникам, разработчикам встраиваемого программного обеспечения В результате вебинара слушатели узнают: ✔️ все основные параметры АЦП и смогут увидеть их влияние вживую на примере ESP32 ✔️ особенности и нюансы схемотехники при проектировании тракта АЦП ✔️ что такое "алиасинг" и как его избежать ✔️ как провести обобщенный расчет погрешностей тракта АЦП ✔️ как откалибровать АЦП в ESP32 ✔️ простые методы фильтрации зашумленных сигналов 🔗 Ссылка на регистрацию: https://otus.pw/X5Wt/ Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576
18 ago, 03:00
24 ago, ~07:50

​​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 #STL
15 ago, 05:00

​​Мапим значения на типы. Ч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 #cpp17
10 ago, 06:00

🏎 Реши реальную задачу из закрытого мира HFT – соревнование с призовым фондом 12 000 USD и коротким треком найма Spectral::T
🏎 Реши реальную задачу из закрытого мира 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

​​Мапим значения на типы. Ч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

​​Ответ #опытным 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 #cppcore
05 ago, 05:00

Какие из утверждений ниже правдивы?
Anonymous voting
04 ago, 06:00

Квиз Выберете правильные утверждения о вызовах в коде:
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

💻 Тайный язык общения чипов. Подключаем всё к ESP32 Приглашаем на открытый урок. 🗓 12 августа в 20:00 МСК 🆓 Бесплатно. Уро
💻 Тайный язык общения чипов. Подключаем всё к ESP32 Приглашаем на открытый урок. 🗓 12 августа в 20:00 МСК 🆓 Бесплатно. Урок в рамках старта курса «Embedded-разработчик». Что будет на вебинаре? ✔️ Познакомимся с современными возможностями высокоскоростного обмена данными с микроконтроллерами, с периферийными устройствами, в которых применяется интерфейс/протокол SPI. ✔️ Изучим устройство и особенности программирования самого скоростного и эффективного способа передачи данных между (микроконтроллерными) устройствами при помощи встроенных в ESP32 аппаратных контроллеров SPI. ✔️ Разберем, как воспользоваться драйвером файловой системы RTOS не проиграв в производительности, померяем скорость обмена с реальными устройствами. ✔️ Соберем «квази-компьютер» с диском и экраном (SD-картой и LCD-дисплеем) 🔗 Ссылка на регистрацию: https://vk.cc/d0aTzI Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576
04 ago, 03:00
11 ago, ~04:30