fa
Feedback

فریب کلاهبرداران را نخورید! تل‌متریو این کانال‌ها را شناسایی و برچسب‌گذاری می‌کند 👉 برای مشاهده برچسب، اشتراک تهیه کنید

Грокаем C++

Грокаем C++

رفتن به کانال در Telegram

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

نمایش بیشتر
9 357
مشترکین
-124 ساعت
+147 روز
+1430 روز
آرشیو پست ها
​​Баг универсальной инициализации В С++11 нам завезли прекрасную фичу - автоматический вывод типов с помощью ключевого слова auto. Теперь мы можем не беспокоится по поводу выяснения типа итераторов для какой-нибудь мапы от мапы о вектора и написания этого типа. Вместо этого можно просто сделать вот так:
const auto it = map_of_map_of_vectors_by_string_key.find(value);
И тогда же ввели еще одну замечательную фичу - braced initialization. Она предотвращает парсинг вашей инициализации, как объявления функции, и убирает эффекты неявного приведения типов. Например, при компиляции такого кода
struct MyClass {
  int a = 0;
};

int main() {
  MyClass x();
  std::cout << x.a << std::endl;
}
компилятор выдаст что-то такое: warning: empty parentheses interpreted as a function declaration. Ну вот захотел я вызвать дефолтный конструктор явно. А мое определение трактуют как объявление функции(most vexing parse). Если круглые скобки заменить на фигурные, то все будет пучком. Однако эта универсальная инициализация, как ее называет Майерс, принесла с собой и несколько багов. Один из них мы уже обсуждали в этом посте. Но сегодня посмотрим еще на один. Вот хотим мы объявить целочисленную переменную и вдруг забыли как пишется int. Да, здесь мы сильно натягваем даже не сову, а прям воробья на глобус.
auto i{0};
А что, имеем право. auto ведь из инициализатора выводит тип, да?. Передали в качестве инициализатора целочисленный литерал. Какой тип будет у i? i будет иметь тип std::initializer_list<int>. Снова проблема именно в синтаксисе определения std::initializer_list и фигурными скобками. Такое поведение совсем контринтуитивное. Считается, что фигурноскобочная инициализация - более предпочитаемый паттерн для использования, но такие приколюхи сильно снижают универсальность этого паттерна. Да, в будущих стандартах эту "особенность" убрали, но не все могут пользоваться самими современными стандартами. Но хорошие новости, что, скорее всего, на современных версиях компиляторов при -std=c++11 вы не получите этого бага. Этот момент я объясню в следующем посте. Don't be confusing. Stay cool. #cpp11 #cppcore
19 دسامبر 2024, 04:00

​​Почему перегрузки не могут иметь разные возвращаемые значения #новичкам Обычно люди просто принимают на веру факт, что перегрузки различаются только набором аргументов. Впрочем, как и все, что вливается в голову в начале обучения. Но никогда не поздно задуматься над смыслом. А почему мы не можем перегружать функции по возвращаемому значению? Может вот так абстрактно рассуждая, и не сразу придет ответ. Но на самом деле все просто, если посмотреть на конкретный пример. Давайте представим, что никаких запретов нет. Теперь перегрузки могут различаться только возвращаемым значением. И у нас есть 2 функции, почти одинаковые , но имеют разные возвращаемые значения.
int GetRandomNumber();
float GetRandomNumber();
Пускай мы хотим генерировать и целые числа, и дробные числа. И то, и то число, общее название оправдано. Теперь попробуем вызвать первую версию.
int number = GetRandomNumber();
А вы уверены, что мы сейчас вызвали именно первую версию? Флоат спокойно кастуется к инту. Ничего не мешает компилятору выбрать вторую версию для этого вызова. Ситуация становится комичной, если использовать auto:
auto number = GetRandomNumber();
Тут как бы вообще нет ни намека на то, какую версию вызывать. Компилятор не умеет читать ваши мысли и намерения. Он не знает, какую версию вы хотели вызвать. Просто рандомно он выбрать не может. Появляется парадокс и вселенная схлопывается. Вот и получили противоречие. Компилятор просто не может отличить вызовы таких функций. Поэтому это и запрещено. Don't be confusing. Stay cool. #cppcore
17 دسامبر 2024, 05:00

❓ Знаете, что делает код на C++ мощным? Правильная работа с библиотеками! 👉 Если вы хотите стать востребованным C++ разработ
❓ Знаете, что делает код на C++ мощным? Правильная работа с библиотеками! 👉 Если вы хотите стать востребованным C++ разработчиком, пора прокачивать навыки работы с библиотеками. Это ваш ключ к написанию профессионального и оптимизированного кода! Что вас ждет на открытом уроке: - узнаете, какие бывают библиотеки и чем они отличаются; - научитесь подключать сторонние библиотеки и собирать свои; - поймете, как библиотеки упрощают вашу работу и делают код эффективнее. ⭐️ Спикер Денис Злобин — старший инженер-программист в Astra Linux, опытный наставник разработчиков. ⏰ 18 декабря в 19:00 мск. Для начинающих и Junior-разработчиков, готовых к карьерному росту. Вебинар проходит в преддверии старта курса «C++ Developer», участники урока получат скидку на большое обучение. 👉 Для участия зарегистрируйтесь: https://otus.pw/uE2f/ Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576, www.otus.ru
17 دسامبر 2024, 02:00
21 دسامبر 2024, ~05:16

std::visit #опытным Не так уж и просто работать с вариантными типами. Надо точно знать, какого типа объект находится внутри. Если не угадали - получили исключение. Ну или тестить объект на содержание в нем конкретного типа с помощью лапши из if-else. Так вот чтобы голова не болела при работе с std::variant надо 2 раза в день после еды принимать std::visit. Эта функция позволяет применять функтор к одному или нескольким объектам std::variant. И самое главное, что вам не нужно беспокоиться по поводу того, какой именно объект находится за личиной варианта. Компилятор все сам сделает.
template< class Visitor, class... Variants >  
constexpr visit( Visitor&& vis, Variants&&... vars );

template< class R, class Visitor, class... Variants >  
constexpr R visit( Visitor&& vis, Variants&&... vars );
Так выглядят ее сигнатуры. Первым параметром передаем функтор, дальше идут варианты. Попробуем использовать эту функцию:
using var_t = std::variant<int, long, double, std::string>;

std::vector<var_t> vec = {10, 15l, 1.5, "hello"};

for (auto& v: vec)
{
  var_t w = std::visit([](auto&& arg) -> var_t { return arg + arg; }, v);
  std::visit([](auto&& arg){ std::cout << arg; }, w);
}
//OUTPUT:
// 20 30 3 hellohello
Главное, чтобы функтор умел обрабатывать любую комбинацию типов, которую вы можете передать в него. Обратите внимание, что мы используем здесь generic лямбду, которая может принимать один аргумент любого типа. Если вы хотите передать в std::visit несколько объектов, то функтор должен принимать ровно такое же количество аргументов и уметь обрабатывать любую комбинацию типов, которая может содержаться в вариантах.
std::visit([](auto&&... arg){ ((std::cout << arg << " "), 
                               ..., 
                               (std::cout << std::endl)); }, vec[0], vec[1]);
std::visit([](auto&&... arg){ ((std::cout << arg << " "), 
                               ..., 
                               (std::cout << std::endl)); }, vec[0], vec[1], vec[2]);
// OUTPUT
// 10 15 
// 10 15 1.5
Используем здесь дженерик вариадик лямбду, чтобы она могла принимать столько аргументов, сколько нам нужно. И эта конструкция работает для любого количества переданных объектов std::variant; Так что std::variant и std::visit - закадычные друзья и им друг без друга грустно! Не заставляйте их грустить. Have a trustworthy helper. Stay cool. #template #cpp17
16 دسامبر 2024, 05:00

Подробно рассказываем о высокопроизводительных решениях с фреймворком userver на новом бесплатном вебинаре! Он предназначен д
Подробно рассказываем о высокопроизводительных решениях с фреймворком userver на новом бесплатном вебинаре! Он предназначен для создания надежных и молниеносных микросервисов и веб-серверов. Освойте передовой C++ фреймворк всего за 90 минут! ✅ Вы узнаете: - Уникальные архитектурные особенности и преимущества userver, которые сделают вашу работу легче и эффективнее. - Как быстро настроить окружение и запустить свой первый проект, не тратя лишнего времени. - Советы высококлассных профессионалов по работе с асинхронностью, которые помогут вам стать мастером своего дела и очень много другой полезной сочной информации! 💡 Будет особенно интересно: - C++ разработчикам, стремящимся освоить мощный инструмент для создания микросервисов. - Backend-инженерам и Team Lead'ам, ищущим высокопроизводительные решения для своих задач. - Специалистам, работающим над масштабируемыми системами. ❌❌Получите практический и ценный опыт работы с userver, который можно сразу применить в своих проектах - регистрируйтесь по ссылке: https://otus.pw/Ocpbe/ P.S. Все зарегистрированные участники получат приличную скидку на обновленный топовый курс «C++ Developer. Professional» Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576
16 دسامبر 2024, 02:01
21 دسامبر 2024, ~05:16

Получаем адрес перегрузки #новичкам Представьте, что у вас есть функция, которая вызывает любой коллбэк:
template<class T, class... Args>
void call_callback(T callback, Args... args) {
    callback(args...);
}
И есть другая функция, которую вы вызываете через call_callback.
int func() {
    return 42;
}

call_callback(func);
Все работает прекрасно. Но теперь мы добавляем перегрузку func и пытаемся их вызвать через call_callback.
int func() {
    return 42;
}

int func(int num) {
    return num;
}

call_callback(func);
call_callback(func, 42);
Получаем ошибку
error: no matching function for call to
 ‘call_callback(<unresolved overloaded function type>)
Компилятор не может понять, какую конкретно перегрузку вы имели ввиду. Дело в том, что имя функции неявно приводится к указателю на эту функцию. Тип указателя на функцию зависит от ее сигнатуры. И просто по имени невозможно понять, с какой сигнатурой функцию мы имеем ввиду. Что же делать? Дать компилятору подсказку и использовать static_cast.
call_callback(static_cast<int(*)()>(func));
call_callback(static_cast<int(*)(int)>(func), 42);
Теперь все работает, как надо. Give useful hints. Stay cool. #cppcore
15 دسامبر 2024, 04:00

Получаем адрес стандартной функции Иногда людям приходится работать с указателями на функции. И у них может возникнуть надобность взять адрес у стдшной функции. Например, вы хотите как-то трансформировать каждый символ в строке c помощью std::transform и в качестве коллбэка передаете именно указатель на функцию
std::transform(s.begin(), s.end(), s.begin(), std::toupper);
Вроде ничего страшного не должно случиться. Но согласно стандарту, поведение программы в этом случае unspecified и потенциально даже ill-formed. Все потому что нельзя брать адреса у стандартных функций. Начиная с С++20 это явно прописано в стандарте.
Let F denote a standard library function, a standard 
library static member function, or an instantiation of 
a standard library function template.

Unless F is designated an addressable function, 
the behavior of a C++ program is unspecified 
(possibly ill-formed) if it explicitly or implicitly 
attempts to form a pointer to F.

Possible means of forming such pointers include 
application of the unary & operator, addressof, 
or a function-to-pointer standard conversion.

Moreover, the behavior of a C++ program is 
unspecified (possibly ill-formed) if it attempts 
to form a reference to F or if it attempts to form 
a pointer-to-member designating either a standard library 
non-static member function  or an instantiation of
a standard library member function template.
Нельзя формировать указатели и ссылки на стандартные функции и нестатические методы. Но почему? Чем они отличаются от обычных функций? На самом деле ничем. Дело в том, что будет с функциями в будущем. Вы без проблем получите адрес одиночной функции. Но если вы добавите к ней перегрузку, то у вас все резко перестанет компилироваться, потому что компилятор не сможет понять, какую конкретно вы используете перегрузку. А стандарт - это штука не статичная. В него постоянно добавляются новые фичи и обновляются в том числе старые инструменты. Например, с приходом С++11 у нас появилась мув-семантика. И условный метод вектора push_back обзавелся новой перегрузкой для правой ссылки. И это сломало код, который брал адрес метода push_back.
#include <vector>

template<typename T>
void Invoke(std::vector<int>& vec, T mem_fun_ptr, int arg)
{
  (vec.*mem_fun_ptr)(arg);
}

int main()
{
  std::vector<int> vec;
  Invoke(vec, &std::vector<int>::push_back, 42);
}
Этот код успешно собирается на 98 плюсах, но не может этого сделать на 11-м стандарте. Можете поиграться с примером на годболте. Если вам все равно нужно сделать что-то подобное, то оберните вызов стандартной функции в лямбду. Тогда вы ничего не нарушите.
std::transform(s.begin(), 
               s.end(), 
               s.begin(), 
               [](unsigned char c){ return std::toupper(c); });
Don't break your future. Stay cool. #cppcore #cpp20
14 دسامبر 2024, 04:11

⚡XMAS HACK к нам мчится! С 20 по 23 декабря под звон Jingle bells пройдет самый яркий и праздничный хакатон 2024 года - XMAS
⚡XMAS HACK к нам мчится!  С 20 по 23 декабря под звон Jingle bells пройдет самый яркий и праздничный хакатон 2024 года - XMAS HACK.  🎁Дед Мороз и Снегурочка уже положили под елочку XMAS HACK особый подарок - 1 000 000 рублей!  ✨Уникальный кейс от Интерюнис-ИТ: Реновация пользовательского интерфейса программного обеспечения акустико-эмиссионного измерительного комплекса.  👨‍💻Задача: Улучшить текущий пользовательский интерфейс программы без модификации содержательной части кода. Основной фокус модификации визуальных элементов, навигации и общем удобстве использования, сохраняя при этом все существующие функциональные возможности. 🚀Осталось собрать команду и до 19 декабря подать заявку на участие: https://tglink.io/642c1efadcff?erid=LjN8KCi28 🎅XMAS HACK к нам мчится, скоро все случится!🌟 #реклама О рекламодателе
14 دسامبر 2024, 02:00
15 دسامبر 2024, ~06:04

​​std::jthread С std::thread в С++ есть один интересный и возможно назойливый нюанс. Давайте посмотрим на код:
int main()
{
  std::thread thr{[]{ std::cout << "Hello, World!" << std::endl;}};
}
Простой Хелло Ворлд в другом потоке. Но при запуске программы она тут же завершится примерно с таким сообщением: terminate called without an active exception. Эм. "Я же просто хотел быть счастливым вывести в другом потоке сообщение. Неужели просто так не работает?" В плюсах много чего просто так не работает) А вот такая программа:
int main()
{
  std::thread thr{[]{ std::cout << "Hello, World!" << std::endl;}};
  std::this_thread::sleep_for(std::chrono::seconds(1));
}
Все-таки напечатает Hello, World!, но потом все равно завершится с std::terminate. Уже лучше, но осадочек остался. Ничего не понятно. Давайте разбираться. С помощью слипа мы немного затормозили main тред и сообщение появилось. То есть мы оттянули выход из main и завершение программы и дали возможность подольше поработать новосозданному потоку. А что происходит при выходе из скоупа функции? Вызов деструкторов локальных объектов. Так вот в деструкторе единственного локального объекта и проблема. Согласно документации, для каждого потока мы обязательно должны выбрать одну из 2-х стратегий поведения: отсоединить его от родительского потока или дождаться его завершения. Делается это методами detach и join соответственно. И если мы не вызовем один из этих методов для объекта потока, то в своем деструкторе он вызовет std::terminate. То есть корректный код выглядит так:
int main()
{
  std::thread thr{[]{ std::cout << "Hello, World!" << std::endl;}};
  thr.join();
}
Мы дожидаемся конца исполнения потока и только после этого завершаем программу. Теперь никаких терминаторов. Но зачем эти формальности? Вообще говоря, часто мы хотим присоединить поток почти сразу перед вызовом его деструктора. А вот отсоединяем поток мы почти сразу после создания объекта. Мы же заранее знаем, хотим ли мы отпустить поток в свободное плавание или нет. И, учитывая эти факты, было бы приятно иметь возможность не вызывать join самостоятельно, а чтобы он за нас вызывался в деструкторе. И С++20 приходит здесь нам на помощь с помощью std::jthread. Он делает ровно это. Если его не освободили и не присоединили мануально, то он присоединяется в деструкторе. Поэтому такой код сделает то, что мы ожидаем:
int main()
{
  std::jthread thr{[]{ std::cout << "Hello, World!" << std::endl;}};
}
jthread не только этим хорош. Его исполнение можно еще отменять/приостанавливать. Но об этом уже в другой раз. Кстати. Вопрос на засыпку. Слышал, что там какие-то сложности у кланга с jthread были. Сейчас все нормально работает? Make life easier. Stay cool. #cpp20 #concurrency
13 دسامبر 2024, 04:00

Дефолтные и ссылочные параметры Есть такой паттерн или стиль написания кода, как входные+выходные параметры у функции. Вместо того, чтобы возвращать результат работы функции в возвращаемом значении, его возвращают через ссылочные параметры. И вот допустим, у нас программист Иннокентий. У него в проекте есть функция, которая хорошо и без нареканий работает и отправляет запрос базе
bool DBConnection::SendQuery(const char* query, 
                             const DbQueryParams& params = DbQueryParams{});
Если запрос отослан удачно, возвращаем тру, если нет, то фолс. Строка запроса к базе может содержать плейсхолдеры(это метки в подготовленном запросе, куда будут подставляться актуальные значения параметров), а может и не содержать. Если они есть, то вместе с query передаются и параметры для подстановки в запрос. Если нет, то у нас есть пустое значение по-умолчанию. Но жизнь течет, все изменяется. Кенни поступила задачка проверять состояние конекшена перед отправкой запроса, возвращать результат проверки наружу и ...(построить какую-то логику на результате). А в проекте у него используется паттерн с выходными параметрами. Обычно это реализовывается так: в начале в аргументах функции идут все входные параметры и затем все выходные. Вроде как логично. Он, согласно своему код стайлу, пишет:
bool DBConnection::SendQuery(const char* query, 
                             const DbQueryParams& params = DbQueryParams{}, 
                             DbConnectionState& state);
Реализовал функцию и запустил билд. А он, хромоногий, упал. Нельзя указывать параметры функции без значения по умолчанию после параметров, имеющих это значение. Видимо это сделано так, потому что иначе появляется пространство для неопределенности. Ладно еще в этом случае компилятор видит разные типы и может как-то соотнести 2 и 2. Но например в случае тривиальных типов все не так однозначно. Они могут неявно конвертироваться друг в друга и тут уже распарсить нельзя.
void foo(int i, float j = 5.0, unsigned k);

foo(1, 2); // Невозможно понять, вызвали ли вы foo(1, 5.0, 2) или 
например по ошибке передали слишком мало аргументов
Закатив глаза и особо не думая, он исправляет:
bool DBConnection::SendQuery(const char* query, 
                             const DbQueryParams& params = DbQueryParams{}, 
                             DbConnectionState& state = DbConnectionState::OK);
И билд тоже падает! Но теперь уже по другому поводу. Неконстантные левоссылочные параметры нельзя определять со значениями по-умолчанию. Причина тут очень простая. Вы не можете создать левую ссылку из значения типа rvalue reference. У объекта должно быть имя, чтобы его можно было присвоить неконстантной левой ссылке. У DbConnectionState::OK имени нет, поэтому и упали. Выход только один. Нарушать свой код-стайл. Придется пихать параметр DbConnectionState& state либо первым параметром, либо между query и params. Первый способ вообще в принципе нарушает все негласные соглашения в объявлениях функции среди всех языков. Второй вроде подходит, когда мы не передаем params. Но в случае, если в запросе есть плейсхолдеры и нам приходится передавать params, то выглядит все не менее ужасно. Кенни не придумал ничего лучше и сильно расстроился. Пошел в лес, увидел там машину, сел в нее и сгорел. А что Иннокентий в принципе мог сделать в этой ситуации? Жду ваших вариантов в комментариях) Don't worry. All difficulties will pass. #cppcore
12 دسامبر 2024, 05:00

🛠Приглашаем на открытый вебинар: Автоматическая регулировка усиления каскадов на операционных усилителях и транзисторах Вы у
🛠Приглашаем на открытый вебинар: Автоматическая регулировка усиления каскадов на операционных усилителях и транзисторах Вы узнаете теоретические и практические аспекты реализации автоматической регулировки усиления каскадов, построенных на операционных усилителях и транзисторах, работающих в частотном диапазоне до 10 МГц. Вы обучитесь подходам к изменению коэффициентов усиления и ограничению мощности входного сигнала. На практике попробуете проектировать каскады с АРУ, использовать SPICE симулятор KiCad и добавлять модели компонентов для анализа. Всё это — в интерактивном формате с реальными примерами. Присоединяйтесь! 🔥Регистрируйтесь на урок 17 декабря, в 20:00 мск и получите скидку на большое обучение «Электроника и электротехника»: https://otus.pw/SkiK/ Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576
12 دسامبر 2024, 02:00
16 دسامبر 2024, ~06:27

Подкасты Если вы думали, что подкаст - это такая штука, которая нужна только, чтобы под нее ехать в транспорте, кушать или тренироваться, то у меня для вас хорошие новости. Подкасты еще могут помогать образовываться! Основная проблема подкастов - чтобы поддерживать адекватный уровень вовлеченности должна быть или интересная личность или просто нескончаемый поток годной и полезной информации. Кажется, есть кандидат, который сочетает в себе и то, и другое. Еще и на смежную с плюсами тему! У компании Ядро(неподтвержденная информация) есть свой подкаст "Битовые маски", где специалисты высочайшего класса обсуждают низкоуровневое программирование, процессоры, компиляторы и операционные системы. Порог входа там довольно большой, но именно благодаря таким материалам вы можете серьезно повысить по крайней мере свою осведомленность о том, что происходит под капотом привычных нам инструментов. У ребят уже 18 выпусков, так что контента вам хватит за глаза. Если что это не реклама. Ребята реально делают качественный контент, поэтому этот пост для всех тех, кто по каким-то причинам пропустил битовые маски мимо своего информационного поля. Вот ссылочка на плейлист с выпусками: https://www.youtube.com/watch?v=wknD9AGvKdc&list=PL0YYm7t_DM63uOt3OF2qRpB5rL27aceLs Enjoy education. Stay cool.
11 دسامبر 2024, 04:00

​​std::apply #опытным Метапрогеры очень любят работать с компайл-тайм структурами, типа std::array, std::pair и std::tuple. Когда работают с такими структурами, то интересны прежде всего элементы этих структур. И очень хочется иногда как-то единообразно передавать их распакованные элементы куда-то в другую функцию. Именно этим и занимается std::apply, которая появилась в С++17. По факту, эта такое дженерик решение для того, чтобы вызвать какую-то функцию с аргументами из элементов tuple-like объектов. Простейшее, что можно с ней делать - вывести на экран все элементы тапла.
const std::tuple<int, char> tuple = std::make_tuple(5, 'a');
std::apply([](const auto&... elem)
{
  ((std::cout << elem << ' '), ..., (std::cout << std::endl));
}, tuple);
Здесь мы применяем fold-expression и оператор-запятая. Можете освежить знания в этом посте. Можно придумать чуть более сложную задачу. Надо написать функцию, которая принимает неограниченное число параметров, в том числе и tuple-like объекты. Все параметры надо распаковать в строку, а tuple-like объекты выделить с помощью фигурных скобок. Объекты естественно могут быть вложенные. Может получится что-то такое:
template <typename T, typename = void>
struct is_tuple_like : std::false_type {};
template <typename T>
struct is_tuple_like<T, std::void_t<decltype(std::tuple_size<T>::value), decltype(std::get<0>(std::declval<T>()))>> : std::true_type {};
template <typename T>
constexpr bool is_tuple_like_v = is_tuple_like<T>::value;

template<typename Tval, typename ... T>
void serialize_tuple_like(std::stringstream &outbuf, const Tval& arg, const T& ... rest) noexcept {
  if constexpr (is_tuple_like_v<Tval>){
    outbuf << "{ ";
    std::apply([&outbuf](auto const&... packed_values) {
      serialize_tuple_like(outbuf, packed_values ...);
      }, arg);
    outbuf << " }";
  }
  else{
    outbuf << arg;
  }
  
  if constexpr(sizeof...(rest) > 0){
    outbuf << ' ';
    serialize_tuple_like(outbuf, rest ...);
  }
}

template<typename ... T>
std::string args_to_string(const T& ... args) noexcept {
  std::stringstream outbuf{};
  if constexpr(sizeof...(args) > 0){
    serialize_tuple_like(outbuf, args ...);
  }
  return outbuf.str();
}

int main(){
  std::cout << args_to_string("test", 1,
                std::tuple{"tuple1", 2, 3.0,
                  std::tuple{"tuple2", "boom"}},
                std::pair{"pair", 4},
                std::array{5, 6, 7, 8, 9});
}
Вывод будет такой:
test 1 { tuple1 2 3 { tuple2 boom } } { pair 4 } { 5 6 7 8 9 }
Даже не знаю, как эту лапшу разбирать. Идея такая что is_tuple_like_v проверяет аргумент на соответствие tuple-like объекту. Если нам на очередном вызове serialize_tuple_like попался такой объект, то мы берем и распаковываем его параметры в рекурсивный вызов serialize_tuple_like. Если у нас не tuple-like объект, то просто выводим его в стрим. Наверное, нужны проверки на то, что объект можно вывести в стрим, но решил, что это немного борщ для этого кода. У функции довольно специфичные кейсы использования. Впрочем, как и у всей метапроги. Don't live in metaverse. Stay cool. #template #cpp17
10 دسامبر 2024, 05:00

👍Узнайте, как создавать приложения на Си с GUI грамотно! На бесплатном уроке онлайн-курса «Программист С» — «Создаем приложе
👍Узнайте, как создавать приложения на Си с GUI грамотно! На бесплатном уроке онлайн-курса «Программист С» — «Создаем приложение на С с графическим интерфейсом пользователя»: регистрация Приложения на Си с GUI сочетают в себе высокий уровень контроля над ресурсами системы с богатым пользовательским интерфейсом, что обеспечивает высокую производительность, гибкость, кроссплатформенность, эффективность взаимодействия с системным окружением. На бесплатном вебинаре рассмотрим: - Основные технологии создания приложения с GUI - Обзор библиотеки GTK+ для создания GUI на языке С - Разработаем простое приложения для работы с базой данных на GTK+ 🔥После вебинара вы сможете продолжить обучение на курсе по спеццене, в том числе, в рассрочку. Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576
10 دسامبر 2024, 02:00
13 دسامبر 2024, ~03:02

​​Почему приватные методы находятся в описании класса? #опытным Публичные, защищенные методы - понятно, они нужны либо для пользователей класса, либо для наследников. Поля - понятно, они влияют на размер объекта, а клиенты должны уметь правильно аллоцировать нужное количество памяти под объект. Ну а приватные-то методы зачем раскрывать? Приватные методы - это вообще-то детали реализации. Если я в своем фреймворке по-приколу назову какой-нибудь приватный метод KillTheNigga, то другим людям уже нельзя будет пользоваться этим фреймворком. Закенселлят еще меня. Хотя какая блин разница, какие у меня там приватные методы? Они типа и названы private, чтобы показать, что они МОИ ЛИЧНЫЕ(никому не отдам). А их оказывается нужно еще и показывать всем. Что-то не сходится. Ну во-первых. Представим, что этого ограничения нет. Тогда все приватные методы объявлялись и определялись бы в файле реализации, который никто не видит. Но если я могу в файле реализации определить приватный метод, то кто угодно может это сделать. Это будет давать рандомным людям прямой доступ к закрытым полям класса. Если мы завершили определение класса, то у нас нет способов как-то пометить именно наши файлы, как "благословленные владельцем". Есть всего лишь юниты трансляции и они равнозначны. Получается, что единственный способ сказать, что вот этот набор методов официально одобрен создателем - это объявить его в описании класса. На самом деле, в С++ мы имеем прямой доступ к памяти, в значит, мы легко можем поменять байтики для приватных полей и все. Или даже создать тип, с таким же описанием, только с дополнительным методом. Кастануть недоступный тип к своему и вуаля, вы можете как хотите вертеть объектом во всех удобных вам позах. Но это уже хаки, мы такого не одобряем. Не используя манипуляции с памятью, мы не сможем добавлять рандомную функциональность в рандомный класс. А во-вторых, оказывается в С++ приватные методы участвуют в разрешении перегрузок(внезапно). В целом, так оно и должно быть. Никто не мешает вам определить публичный метод и перегрузить его приватным методом. Проблема(или фича) в том, что этап разрешения перегрузок стоит перед проверкой модификатора доступа. То есть даже если метод приватный и его никто не должен увидеть, он все равно участвует в разрешении перегрузок наряду со всеми остальными методами. Поэтому каждый клиент должен видеть полный набор приватных методов. Об этом мы уже говорили в контексте pimpl идиомы. В чем прикол такого дизайн решения? Давайте представим, что такого правила нет. И вот у нас есть две перегрузки, одна приватная для double, другая публичная для int. И перегрузка с double всегда отбрасывалась бы только лишь по причине того, что она приватная. Тогда мы легко можем вызвать публичную функцию с дробным числом 1.5 и нам ничего не будет. Оно просто неявно приведется к int и все на этом. А теперь посмотрим, что будет, если мы поменяем модификатор приватной перегрузки на публичный? Ничего не упадет, НО! наш вызов метода с аргументом 1.5 теперь пойдет в другую функцию! То есть изменится поведение объекта. Комитет хотел избежать таких ситуаций, поэтому ввели такое вот ограничение. Наверное, причина не одна. Но это весомый аргумент. Однако, такой протокол поведения влечет за собой различные сайд-эффекты. Я могу удалить(=delete) приватную перегрузку публичного метода, например какую мы обсуждали выше. И вызвать публичный метод опять с дробным числом. Но компилятор на меня наругается, потому что я попытался вызвать удаленную перегрузку метода. Хотя она вообще-то объявлена, как приватная! А то, что я ее удалил - это детали реализации. Получается раскрытие деталей реализации. Stay aware. Stay cool. #design #howitworks #cppcore #hardcore
09 دسامبر 2024, 03:28

Все надоело Айтишечка - очень напряженная сфера труда. Вам, чтобы развиваться и достигать новых высот, нужно не просто идти в
Все надоело Айтишечка - очень напряженная сфера труда. Вам, чтобы развиваться и достигать новых высот, нужно не просто идти в ногу со временем, а буквально бежать. Постоянно новые фичи, новые стандарты, новые модномолодежные фреймворки. Все это надо изучать. На работе еще нужно перформить, аки папа Карло, чтобы хорошие оценки были на перфоманс ревью. Не удивительно, что все рано или поздно выгорают. Если у фрезеровщиков профессиональная болезнь - отсутствие пальцев, то у программистов - выгорание. Пропадает улыбка, интерес к работе, да и в целом к жизни. Все больше хочется позалипать в смартфончике на ютубчик или котиков. Многие думают, что дело в работе. Берут долгий отпуск, меняют компанию. Но потом все равно возвращаются в ту же точку. Изнутри системы очень сложно справиться с проблемой. Нужен опытный человек снаружи, который поможет ее решить. Психолог взрослого человека - канал для айтишников, у которых периодически опускаются руки и отключается мозг. ▪️ Как научиться отвлекаться от работы и отдыхать? ▪️ Как совместить кучу рабочих задач и время с семьей? ▪️ Как справиться с прокрастинацией? ▪️ Как не растерять запал, даже если начальник и коллеги 💩 и кажется, что ничего не выходит? На все эти вопросы вам поможет найти ответы Вадим Петров, автор канала. Он постоянно проводит живые сессии и по полочкам разбирает насущные специфические проблемы айтишников. На одном коде жизнь не заканчивается. Подписывайтесь на канал @vadimpetrov_psy и работайте без упахивания, выгорания и ущерба для личной жизни! 👨🏻‍💻 Псс. Обязательно загляните в закреп канала - там вас ждут много полезных плюшек, и даже бесплатный мини-курс по выходу из апатии. Рекомендую подписаться: https://t.me/+LX08JcPGX8NiMWQy
09 دسامبر 2024, 01:10
11 دسامبر 2024, ~04:15

​​const this Все мы знаем, что this - указатель на объект, на котором сейчас находится контекст исполнения. Будь то метод, default member initializer или лямбда выражение. И вот есть в этих ваших интернетах такое мнение, что этот this - нулевой неявный аргумент метода и он передается в него в таком виде:
void Foo::bar(Foo * const this, Type1 param1, Type2 param2) {}
То есть типа this - константный указатель. Так наверное можно думать, но это не совсем правда. Точнее так. Действительно, this подразумевает под собой адрес неявного аргумента-объекта. Но нигде не написано, что он константный. Да ему нельзя ничего присваивать. Например
void Foo::change(Foo *foo) { this = foo; }
При компиляции кода появится примерно такая ошибка: lvalue required as left operand of assignment. Но если приглядеться, то ни про какой const там речь не идет. Ему не хватает lvalue слева. Все потому что this - prvalue выражение. То есть можно даже сказать, что это и не указатель. Это выражение, значение которого равно адресу объекта. Оно не может быть использовано слева от знака равенства и у него нельзя взять адрес. И именно поэтому ему нельзя ничего присваивать, а не потому что это константный указатель. Но вот cv-квалификация метода может повлиять на cv-квалификацию указателя на объект. Тип this в обычном методе - Foo *(указатель на Foo). Однако для cv-квалифицированных методов this становится cv Foo *. То есть:
void Foo::ConstMemberFunction(Type1 param1, Type2 param2) const {
  // this - const Foo *
  this->field = param1; // Error!
}
Сделано это, естественно, чтобы мы никак не могли изменить объект, на который указывает this, в константном методе. Так что this - prvalue и точка! Make points in your life. Stay cool. #cppcore
08 دسامبر 2024, 04:18

​​Double lookup #опытным Решил сделать небольшое дополнение к предыдущему посту по результатам дискуссии в комментариях. Не нужно использовать методы count(key) и contains(key), если вы потом собираетесь работать с этим ключом в ассоциативном контейнере(например изменять объект по ключу). Это может привести к так называемому double lookup. То есть двойной поиск по контейнеру. Возьмем для примера std::map для показательности. И вот такой код:
std::map<std::string, std::string> map;

std::string get_value(const std::string& key) {
  if (!map.contains(key)) {
    std::string value = longCalculations(key);
    map[key] = value;
    return value;
  } else {
    return map[key];
  }
}
Здесь мы по ключу key выдаем какое-то значение value. Эти значения вычисляются при помощи долгой функции longCalculations, поэтому было решено закэшировать все уже вычисленные значения в мапе. Так мы сможем обойти долгие вычисления и быстро дать ответ в случае, если уже искали это значение. Только вот в чем проблема. Поиск по мапе - логарифмическая по времени операция. И в этом примере мы всегда делаем 2 поиска: первый раз на contains(мы должны пройтись по контейнеру, чтобы понять, есть ли элемент) и второй раз на operator[](нужно пройтись по контейнеру, чтобы вставить в него элемент/получить к нему доступ). Долговато как-то. Может можно получше? В случае, если ключ есть в мапе, то мы можем делать всего 1 поиск! С помощью метода find и итератора на элемент.
std::string get_value(const std::string& key) {
  auto it = map.find(key);
  if (it == map.end()) {
    std::string value = longCalculations(key);
    map[key] = value;
    return value;
  } else {
    return it->second;
  }
}
Мы в начале попытались найти конкретный элемент мапы по ключу. И если его нет, то нам все-таки придется выполнить второй поиск, чтобы найти подходящее место для элемента. Но вот если ключ есть, тогда мы можем использовать сам итератор для возврата значения и второго поиска не будет! Методы count и contains нужно использовать только тогда, когда у вас нет надобности в получении доступа к элементам контейнера. Find в этом случае, по моему мнению, немного синтаксически избыточен. А вот говорящие методы - самая тема. Например, у вас есть множество, в котором хранятся какие-то поля джейсона. И вам нужно как-то трансформировать только те значения, ключи которых находятся во множестве.
std::set<std::string> tokens;
std::string json_token;
Json json;
if (tokens.contains(json_token)) {
  transformJson(json, json_token);
}
Все прекрасно читается и никакого двойного поиска! Don't do the same work twice. Stay cool. #cppcore #goodpractice
07 دسامبر 2024, 04:00

📶 С 1 декабря для граждан РФ открыт доступ к платным материалам по программированию Вот отсортированные базы с тонной матери
📶 С 1 декабря для граждан РФ открыт доступ к платным материалам по программированию Вот отсортированные базы с тонной материала(книги, курсы, ресурсы и гайды). Выбирай своё направление:: 👩‍💻 Frontend 👩‍💻 PHP ⚙️ Backend 👩‍💻 Моб. Dev 📱 GitHub 👩‍💻 GameDev 🤓 Всё айти 👩‍💻 DevOps 👩‍💻 Python 🖥 Data Science 👩‍💻 Java 🐞 Тестирование 👩‍💻 C# 🤔 Хакинг & ИБ 👩‍💻 С/С++ 📱 Маркетинг 🖥 SQL 🖥 Дизайн 👩‍💻 Golang 👣 Rust Скачивать ничего не нужно — все выложили в Telegram с доступом по ссылке
07 دسامبر 2024, 02:00
12 دسامبر 2024, ~15:12

Проверяем вхождение элемента в ассоциативный контейнер Нужно вот нам по ключу проверить вхождение элемента допустим в мапу. Обычно мы пишем:
if (map.count(key)) {
  // do something
}
Но для контейнеров без приставки "multi" это выглядит довольно странно. Действительно, если я знаю, что в мапе однозначное соответствие ключа и значения, зачем мне знать сколько вхождений элементов с этим ключом? Я хочу просто знать, есть ли он. Такие вот маленькие семантические несостыковочки. С ними вроде все смирились, но осадочек остался... И 20-е плюсы наконец нам подарили замечательный публичный метод для всех ассоциативных контейнеров contains. Он проверяет, если ли в контейнере элементы с данным ключом. Теперь код выглядит так:
if (map.contains(key)) {
  // do something
}
И вот уже стало чуть приятнее и понятнее читать код. Если есть доступ к 20-м плюсам, то переходите на использование этого метода. Make things clearer. Stay cool. #STL #cpp20
06 دسامبر 2024, 04:00