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 روز
آرشیو پست ها
Готовы к карьерному рывку? Станьте C++ Software Engineer в YADRO всего за 3 дня 🚀 Прямо сейчас российская технологическая ко
Готовы к карьерному рывку? Станьте C++ Software Engineer в YADRO всего за 3 дня 🚀 Прямо сейчас российская технологическая компания YADRO проводит SPRINT OFFER для C++ Software Engineer. 🔵 Чтобы присоединиться к команде Telecom: •‎ Оставьте заявку на сайте до 9 марта. •‎ Пройдите скрининг с рекрутером. А после — техническое и менеджерское интервью. YADRO ждёт кандидатов сразу в два направления: → Команда Telecom Platform разрабатывает полное платформенное решение для телекоммуникационных систем. На его основе строятся самые современные узлы сотовых сетей LTE- и GSM-стандартов — например, базовые станции и системы управления. → Инженеры разработки базовой станции LTE/GSM и 5G Core создают высоконагруженные системы, обеспечивающие связь как критически важных, так и новых поколений. А также разрабатывают надёжное и масштабируемое ПО для мобильных сетей. Присоединяйтесь к инженерному сообществу с опытными специалистами, чтобы напрямую влиять на продукт и реализовывать амбициозные проекты! Оставляйте заявку до 9 марта и станьте частью команды YADRO. Все подробности — по ссылке.
28 فوریه 2025, 02:01
05 مارس 2025, ~13:25

Почему так смешно?😂😂😂
Почему так смешно?😂😂😂
27 فوریه 2025, 04:00

​​new vs malloc Чем отличаются new и malloc? Один из популярных вопросов на собеседованиях, которые проверяет, насколько хорошо вы знакомы с тонкостями работы с памятью в С/С++. Поэтому давайте сегодня это обсудим. Не совсем корректно, наверное сравнивать фичи двух разных языков с разными доминантными парадигмами программирования. Но раз в стандарте есть std::malloc, а new тоже выделяет память, то можно попробовать. 👉🏿 new expression помимо аллокации памяти вызывает конструктор объекта. std::malloc только выделяет память. 👉🏿 std::malloc - совсем не типобезопасный. Он возвращает void * без какого-либо признака типа. Придется явно кастовать результат к нужному типу. new в свою очередь возвращает типизированный указатель. 👉🏿 При ошибке выделения памяти new бросает исключение std::bad_alloc, в то время как std::malloc возвращает NULL. Соответственно нужны разные способы обработки ошибочных ситуаций. 👉🏿 Поведение new может быть переопределено внутри кастомных классов, поведение std::malloc - неизменно. 👉🏿 Если вам не нужно конструирование объекта, то просто вызывайте operator new. Он делает то же самое, что и std::malloc(потенциально вызывает его внутри себя). 👉🏿 Для new не нужно вручную высчитывать количество нужных байт. То есть мы не лезем на низкий уровень. Мы заботимся только типе данных, количестве объектов и об аргументах конструктора. 👉🏿 new плохо работает с реаллокациями. Нужно выделить новый сторадж, скопировать туда данные и вызвать delete. В то время, как malloc имеет функцию-партнера realloc, которая может изменить размер существующего куска памяти более эффективно, чем последовательность new-memcpy-delete. Однако они имеют одну неочевидную схожесть. Нужно стараться по максимуму избегать их явного вызова. Давно придумали умные указатели и контейнеры, которые позволяют максимально освободить разработчика от обязанности ручного управления памятью. Мы все же современные плюсовики. Поэтому в большинстве случаев, вам не нужны будут прямые вызовы этих функций. В более редких случаях(например кастомные аллокаторы) можно явно использовать new. Ну и в совсем редких случаях(нужда в реаллокации памяти или работа с сишным кодом) можно использовать malloc. Control your memory. Stay cool. #cppcore #interview
26 فوریه 2025, 04:00

Все грани new #опытным Не каждый знает, что в плюсах new - это как медаль, только лучше. У медали 2 стороны, а у new целых 3! Сейчас со всем разберемся. То, что наиболее часто используется, называется new expression. Это выражение делает 2 вещи последовательно: пытается в начале выделить подходящий объем памяти, а потом пытается сконструировать либо один объект, либо массив объектов в уже аллоцированной памяти. Возвращает либо указатель на объект, либо указатель на начало массива. Выглядит оно так:
 // creates dynamic object of type int with value equal to 42
int* p_triv = new int(42);
 // created an array of 42 dynamic objects of type int with values equal to zero
int* p_triv_arr = new int[42];

struct String {std::string str};

 // creates dynamic object of custom type String using aggregate initialization
String* p_obj = new String{"qwerty"};
 // created an array of 5 dynamic objects of custom type String with default initialization
String* p_obj = new String[5];
Эта штука делает 2 дела одновременно. А что, если мне не нужно выполнять сразу 2 этапа? Что, если мне нужна только аллокация памяти? За это отвечает operator new. Это оператор делает примерно то же самое, что и malloc. То есть выделяет кусок памяти заданного размера. Выражение new именно этот оператор и вызывает, когда ему нужно выделить память. Но его можно вызвать и как обычную функцию, а также перегружать для конкретного класса:
// class-specific allocation functions
struct X
{
    static void* operator new(std::size_t count)
    {
        std::cout << "custom new for size " << count << '\n';
        // explicit call to operator new
        return ::operator new(count);
    }
 
    static void* operator new[](std::size_t count)
    {
        std::cout << "custom new[] for size " << count << '\n';
        return ::operator new;
    }
};
 
int main()
{
    X* p1 = new X;
    delete p1;
    X* p2 = new X[10];
    delete[] p2;
}
Но что, если у меня уже есть выделенная память и я хочу на ней создать объект? Допустим, я не хочу использовать кучу и у меня есть массивчик на стеке, который я хочу переиспользовать для хранения разных объектов, потенциально разных типов. Тогда мне нужен инструмент, который позволяет только вызывать конструктор на готовой памяти. Для этого есть placement new. Это тот же самый new expression, только для этого есть свой синтаксис. Сразу после new в скобках вы передаете указатель на область памяти, достаточной для создания объекта.
alignas(T) unsigned char buf[sizeof(T)];
// after new in parentheses we specified location of future object
T* tptr = new(buf) T; 
// You must manually call the object's destructor
tptr->~T(); 
В этом случае кстати вызывается специальная перегрузка operator new:
void* operator new  (std::size_t count, void* ptr);
Однако она не делает ничего полезного и просто возвращает второй аргумент наружу. Вот так по разному в С++ можно использовать new. Главное - не запутаться! Have a lot of sides. Stay cool. #cppcore #memory
25 فوریه 2025, 07:07

​​Неинициализированные переменные Все мы знаем, что это плохо, ужасно, это проделки Сатаны и заговор евреев. Но нет-нет да и используем их. Сегодня кратко приведу еще один довод в пользу того, чтобы выкинуть из своей картины мира неинициализированные переменные. Кейс из ревью. Вот у вас есть примерно такая функция и примерно так ее можно вызвать:
std::optional<SomeType> WaitForSomething(bool& success) {
  SomeType result;
  if (!SomeOperation()) {
    // error
    return std::nullopt;
  }
  if (condition) {
    //fill result
  }
  success = (condition == 1);
  return result;
}

bool success;
auto obj = WaitForSomething(success);
if (!obj) {
  // handle error
}
if (success) {
  // do something
}
Вроде нормальная функция, в случае ошибки не возвращает объекта, в случае успешного условия заполняет как-то объект, в случае неуспеха оставляет его дефолтным. И заполняется output параметр, сигнализирующий об наступлении условия. Здесь success заполняется всегда вне зависимости, наступит условие или нет. И вроде как очень безопасно туда передать неинициализированный bool. Какая же разница? success в любом случае инициализируется в функции. А вот приходит другой программист и изменяет эту функцию примерно так:
std::optional<SomeType> WaitForSomething(bool& success) {
  SomeType result;
  if (!SomeOperation()) {
    // error
    return std::nullopt;
  }
  while (condition1 && condition2) {
    //fill result
    if (condition3)
      success = true;
  }
  return result;
}
По логике реального кода было все четко. Кроме того, что теперь в ветке, где не выполняются одновременно condition1, condition2 и condition3 success остается тем же, что и передали в функцию. Так конечно не нужно делать. Это хоть чуть-чуть, но изменяет логику поведения функции. Но я хочу тут другой момент затронуть. Теперь при передаче неинициализированной success результат функции может быть дефолтовым, а success == true, так как в него изначально был записан true. В реальности привело к довольно долгому дебагу. Но если бы изначально мы создавали бы инициализированную в ложь переменную
bool success = false;
то этой боли можно было бы избежать. А изменение функциональности самой функции выявят тесты. Вывод: не используйте неинициализированные переменные! И включите уже соответствующую опцию компилятора, которая ругается на них ошибкой. Define your value. Stay cool. #cppcore #goodpractice
24 فوریه 2025, 05:00

​​Пингвинячимся На плюсах писать и линукс не знать - вы в своем уме?. Современная backend С++ разработка жестко привязана к этой системе. Отсутствие навыков работы с linux - гарантия ограниченных карьерных возможностей и технической экспертизы. Но ладно, так и быть, вам я расскажу одно средство, которое поможет вам прокачаться в пингвине. Это канал LinuxCamp. Его ведет реальный системный разработчик, который поможет тебе освоить Linux и программирование на профессиональном уровне! А еще он плюсовик, как и все мы тут. У него вы найдете уникальные гайды по администрированию Linux и подробные статьи о внутреннем устройстве операционных систем. А также крутые техники сочетания С++ и linux в разработке Не первый и точно не последний раз рекомендую этот канал. Так что подписывайтесь на LinuxCamp и становитесь частью сообщества истинных пингвинячих гуру!
24 فوریه 2025, 02:00
03 مارس 2025, ~14:21

Как думаете, кто и когда отправит С++ на покой? Или он будет жить вечно?
Как думаете, кто и когда отправит С++ на покой? Или он будет жить вечно?
22 فوریه 2025, 06:00

​​Почему приватные методы находятся в описании класса? Публичные, защищенные методы - понятно, они нужны либо для пользователей класса, либо для наследников. Поля - понятно, они влияют на размер объекта, а клиенты должны уметь правильно аллоцировать нужное количество памяти под объект. Ну а приватные-то методы зачем раскрывать? Зачем их помещать внутрь класса и делать видимыми для клиентского кода? Ну во-первых. Представим, что этого ограничения нет. Тогда все приватные методы объявлялись и определялись бы в файле реализации, который никто не видит. Но если я могу в файле реализации определить приватный метод, то кто угодно может это сделать. Это будет давать рандомным людям прямой доступ к закрытым полям класса. Если мы завершили определение класса, то у нас нет способов как-то пометить именно наши файлы, как "благословленные владельцем". Есть всего лишь юниты трансляции и они равнозначны. Получается, что единственный способ сказать, что вот этот набор методов официально одобрен создателем - это объявить его в описании класса. В С++ мы имеем прямой доступ к памяти, а значит, мы легко можем поменять байтики для приватных полей и все. Или даже создать тип, с таким же описанием, только с дополнительным методом. Кастануть недоступный тип к своему и вуаля, вы можете как хотите вертеть объектом во всех удобных вам позах. Но это уже хаки, мы такого не одобряем. Не используя манипуляции с памятью, мы не сможем добавлять рандомную функциональность в рандомный класс. А во-вторых, оказывается в С++ приватные методы участвуют в разрешении перегрузок(внезапно). В целом, так оно и должно быть. Никто не мешает вам определить публичный метод и перегрузить его приватным методом. Проблема(или фича) в том, что этап разрешения перегрузок стоит перед проверкой модификатора доступа. То есть даже если метод приватный и его никто не должен увидеть, он все равно участвует в разрешении перегрузок наряду со всеми остальными методами. Поэтому каждый клиент должен видеть полный набор приватных методов. Об этом мы уже говорили в контексте pimpl идиомы. В чем прикол того, что приватные методы участвуют в разрешении перегрузок? Давайте снова представим, что такого правила нет. И вот у нас есть две перегрузки, одна приватная для double, другая публичная для int. И перегрузка с double всегда отбрасывалась бы только лишь по причине того, что она приватная. Тогда мы легко можем вызвать публичную функцию с дробным числом 1.5 и нам ничего не будет. Оно просто неявно приведется к int и все на этом. А теперь посмотрим, что будет, если мы поменяем модификатор приватной перегрузки на публичный? Ничего не упадет, НО! наш вызов метода с аргументом 1.5 теперь пойдет в другую функцию! То есть изменится поведение объекта. Комитет хотел избежать таких ситуаций, поэтому ввели такое вот ограничение. Наверное, причина не одна. Но им этой одной было достаточно. Однако, такой протокол поведения влечет за собой различные сайд-эффекты.
struct DumbClass {
    void DumbFunction(int param) {
        // i do nothing because i’m dumb
    }
private:
    void DumbFunction(double param) = delete;
};

int main() {
    DumbClass{}.DumbFunction(1.0);
}
// error: use of deleted function ‘void DumbClass::DumbFunction(double)’
Я могу удалить приватную перегрузку публичного метода, например какую мы обсуждали выше. И вызвать публичный метод опять с дробным числом. Но компилятор на меня наругается, потому что я попытался вызвать удаленную перегрузку метода. Хотя она вообще-то объявлена, как приватная! А то, что я ее удалил - это детали реализации. Получается раскрытие деталей реализации. Не знаю, как оценивать все перечисленные причины. Напишите свое мнение в комментариях. Stay aware. Stay cool. #design #howitworks #cppcore #hardcore
20 فوریه 2025, 06:00

Ваш код тормозит под нагрузкой? Не справляется с задачами параллельного вычисления? 💡 Приходите на открытый урок по многопот
Ваш код тормозит под нагрузкой? Не справляется с задачами параллельного вычисления? 💡 Приходите на открытый урок по многопоточному программированию C++! ▫️Вместе напишем многопоточную реализацию задачи подсчёта суммы чисел. ▫️Разберём примитивы синхронизации. ▫️Ускорим код с помощью стандартной библиотеки. 🎯 Вы начнёте осваивать многопоточное программирование и сделаете первый шаг к позициям middle+ в C++! А ещё получите скидку на большое обучение «C++ Developer». 📅 Успейте записаться на открытый вебинар 25 февраля в 20:00 (мск)! 🔗 Регистрируйтесь прямо сейчас и узнайте, как эффективно управлять потоками в C++: https://otus.pw/Gf9B0/ Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576
20 فوریه 2025, 03:00
25 فوریه 2025, ~02:54

​​Как вызвать методы класса напрямую через vtable? #опытным Всем нам как С++ разработчикам интересно, как все устроено внутри всего. Вызвано это профессиональной деформацией или врожденным позывом, но у нас у всех это есть. Поэтому сейчас заглянем немного под капот... Полиморфизм - там штука, которая сделала ООП и ОО дизайн такими мощными и широкоиспользуемыми инструментами. За счет чего он реализован в С++? Наиболее распространенное решение - vtable. Таблица виртуальных методов. Не буду сильно погружаться, но в сущности, это массив, который хранит указатели на методы класса. И сейчас мы попробуем вызвать метод класса напрямую через этот массив используя низкоуровневые преобразования.
struct Base {
    virtual void func1() {
        std::cout << i+1<< std::endl;
    }
    virtual void func2() {
        std::cout << i+2 << std::endl;
    }
};

struct Derived: Base {
    void func1() override {
        std::cout << i+3 << std::endl;
    }
    void func2() override {
        std::cout << i+4 << std::endl;
    }
};

int main() {
    auto basePtr = std::unique_ptr<Base>(new Derived);
    uint64_t ** pVtable = (uint64_t **)basePtr.get();
    printf("Vtable: %p\n", pVtable);
    printf("First Entry of VTable: %p\n", (void*)pVtable[0][0]);
    printf("Second Entry of VTable: %p\n", (void*)pVtable[0][1]);

    using VoidFunc = void (*) (void*);
    VoidFunc firstMethod = (VoidFunc) pVtable[0][0];
    firstMethod(basePtr.get());
    VoidFunc secondMethod = (VoidFunc) pVtable[0][1];
    secondMethod(basePtr.get());
}
Для начала нам нужна иерархия объектов. У родителя и ребенка по 2 метода, каждый выводит определенный инкремент целочисленного поля класса. Теперь создаем умный указатель родительского класса, который содержит объект ребенка. Далее нужно найти указатель на vtable. Обычно он всегда лежит в первых 8 байтах объектов полиморфных классов. Так как у нас двухуровневая косвенность (указатель на объект, а в нем указатель на таблицу), мы объявляем двойной указатель на 8-мибайтный инт и он и будет нашим vtable_ptr. Почему uint64_t? Да на самом деле косвенность трехуровненая, потому что в ячейках vtable лежат указатели на методы, а указатель легко представить в виде 8-байтного числа. Самое сложное позади, мы нашли все, что нужно. Осталось только кастануть инты, лежащие в ячейках vtable к указателям на функцию правильного типа. И вуаля. Готово. Возможный вывод:
Vtable: 0x5a7841237eb0
First Entry of VTable: 0x5a781fd28ae2
Second Entry of VTable: 0x5a781fd28b22
3
4
Где это знание нужно? Ну вообще в принципе неплохо разбираться в том, как работает полиморфизм в С++. У всего есть свои особенности и в какой-то необычной ситуации эти знания вам могут помочь пофиксить багу. Знание внутреннего устройства инструмента позволить вам понимать его преимущества и недостатки. Возможно в проектах с высокими требованиями к производительности(слабое железо как в embedded или супер-ультра-гипер low latency как в hft), вам предстоит выбирать между динамическим полиморфизмом и статическим полиморфизмом aka шаблонами. Чтобы сделать выбор качественно и аргументировать его, нужно знание базы. А как говорится, пока сам не потрогаешь ручками - не поймешь. Только не нужно так писать в продовом коде! А то будет, как на картинке внизу. Stay hardwared. Stay cool.
19 فوریه 2025, 04:00

​​No new line Оказывается, чтобы получить неопределенное поведение даже необязательно писать какой-то плохой код. Достаточно просто не добавить перенос строки в конце подключаемого файла! Небольшой пример:
Файлик foo.hpp:

// I love code
// I love C++<no newline>

Файлик bar.cpp:

#include "foo.hpp"
#include "baz.hpp"
А теперь вспоминаем, что препроцессор вставляет все содержимое хэдера на место инклюда И(!) не вставляет после него символ конца строки. То есть спокойно может получится следующее:
// I love code
// I love C++#include "baz.hpp"
То есть включение baz.hpp может быть полностью заэкранировано. Учитывая, сколько всего препроцессор может делать с кодом, комбинации вариантов развития событий могут быть абсолютно разными. Стандарт нам говорит:
... If a source file that is not empty does not end in a new-line character,
 or ends in a new-line character immediately preceded by a backslash
 character before any such splicing takes place, the behavior is undefined.
Так что ub без кода - вполне существующая вещь. Или уже нет? На самом деле приведенная цитата была из стандарта 2003 года. С++11 пофиксил эту проблему и обязал препроцессоры вставлять new line в конце подключаемых файлов:
A source file that is not empty and that does not end in a new-line character, 
or that ends in a new-line character immediately preceded by a backslash 
character before any such splicing takes place, shall be processed 
as if an additional new-line character were appended to the file.
Так что теперь проблемы нет. Решил написать об этом, просто потому что очень весело, что в плюсах можно было такими неочевидными способами отстрелить себе конечность. Ну и хорошо, что стандарт все-таки не только новую функциональность вводит, а фиксит вот такие вот недоразумения. Fix your flaws. Stay cool. #compiler
18 فوریه 2025, 07:00

С++ Книги - канал для скачивания книг по C++ Что в нашем канале: 1. Книги по C++ 2. Много книг на русском языке 3. Описания к
С++ Книги - канал для скачивания книг по C++ Что в нашем канале: 1. Книги по C++ 2. Много книг на русском языке 3. Описания книг, автор, год выпуска 4. Все книги можно скачать в 2 клика. 5. Всё, никакой другой воды. Подписывайтесь на нас: @download_c_books
18 فوریه 2025, 06:00
19 فوریه 2025, ~07:23

С++ Книги - канал для скачивания книг по C++ Что в нашем канале: 1. Книги по C++ 2. Много книг на русском языке 3. Описания к
С++ Книги - канал для скачивания книг по C++ Что в нашем канале: 1. Книги по C++ 2. Много книг на русском языке 3. Описания книг, автор, год выпуска 4. Все книги можно скачать в 2 клика. 5. Всё, никакой другой воды. Подписывайтесь на нас: @download_c_books
18 فوریه 2025, 04:00
18 فوریه 2025, ~04:00

​​Дедлокаем один поток #опытным Мы привыкли, что для дедлоков нужно несколько потоков. Не удивительно. Давайте прочитаем определение дедлока по Коффману. Там речь про процессы, но если поменять слово "процесс" на "поток" ничего не изменится. Ну и перевод будет вольный. Дедлок - это ситуация в коде, когда одновременно выполняются все следующие условия: А ну, мальчики, играем поочереди. Только один поток может получить доступ к ресурсу в один момент времени. У меня уже есть красный паровозик, но я хочу синий!. Поток в настоящее время хранит по крайней мере один ресурс и запрашивает дополнительные ресурсы, которые хранятся в других потоках. Я тебя захватил, я тебя и отпущу. Ресурс может быть освобожден только добровольно потоком, удерживающим его. Все: Я хочу твой паровозик! Каждый поток должен ждать ресурс, который удерживается другим потоков, который, в свою очередь, ожидает, когда первый поток освободит ресурс. В общем случае ждунов может быть больше двух. Важно круговое ожидание. Судя по этому определению, минимальное количество потоков, чтобы накодить дедлок - 2. Но это такая общая теория работы с многозадачностью в программах. Определение оперирует общим термином ресурс. И не учитывает поведение конкретного ресурса и деталей его реализации. А они важны! Возьмем пресловутый мьютекс. Что произойдет, если я попытаюсь его залочить дважды в одном потоке?
std::mutex mtx;
mtx.lock();
mtx.lock();
Стандарт говорит, что будет UB. То есть поведение программы неопределено, возможно она заставит Ким Чен Ира спеть гангам стайл. Возможно, но обычно этого не происходит. Программа в большинстве случаев ведет себя по одному из нескольких сценариев. 1️⃣ Компилятор имплементировал умный мьютекс, который может задетектить double lock и, например, кинуть в этом случае исключение. 2️⃣ Мьютекс у нас обычный, подтуповатый и он делает ровно то, что ему говорят. А именно пытается залочить мьютекс. Конечно у него ничего не получится и он вечно будет ждать его освобождения. Результат такого сценария - дедлок одного потока одним мьютексом! Результат не гарантирован стандартом, но мой код под гццшкой именно так себя и повел. Поэтому теперь у вас есть еще один факт, которым можно понтануться перед коллегами или на собесах. Be self-sufficient. Stay cool. #concurrency #cppcore #compiler
16 فوریه 2025, 04:00

Ответ #опытным Правильный ответ на квиз из предыдущего поста- 0. Вообще ни одного мьютекса не нужно. Много можно вариантов придумать. И даже в комментах написали несколько рабочих способов. Вообще говоря, в определении дедлока не звучит слово "мьютекс". Потоки должны ждать освобождения ресурсов. А этими ресурсами может быть что угодно. Для организации дедлока достаточно просто, чтобы 2 потока запустились в попытке присоединить друг друга. Естественно, что они будут бесконечно ждать окончания работы своего визави. Однако не совсем очевидно, как это организовать. Вот мы определяем первый объект потока и его надо запустить с функцией, которая ждем еще не существующего потока. Заметьте, что мы пытаемся сделать грязь. Так давайте же применим самые опасные вещи из плюсов и у нас все получится! Надо лишь добавить 50 грамм указателей и чайную ложку глобальных переменных. Получается вот такая каша:
std::thread * t_ptr = nullptr;

void func1() {
  std::this_thread::sleep_for(std::chrono::seconds(1));
  t_ptr->join();
  std::cout << "Never reached this point1" << std::endl;
}

void func2(std::thread& t) {
  t.join();
  std::cout << "Never reached this point2" << std::endl;
}

int main() {
  std::thread t1{func1};
  t_ptr = new std::thread(func2, std::ref(t1));
  while(true) {
    std::this_thread::sleep_for(std::chrono::seconds(1));
  }
}
Все просто. Вводим глобальный указатель на поток. В функции первого потока мы даем время инициализировать указатель и присоединяем поток по указателю. А тем временем в main создаем динамический объект потока и записываем его по указателю t_ptr. Таким образом первый поток получает доступ ко второму. В функцию второго потока передаем объект первого потока по ссылке и присоединяем его. Обе функции после инструкции join выводят на консоль запись. Чтобы это все дело работало, нужно продлить существование основных потоков. В обратном случае, вызовутся деструкторы неприсоединенных потоков, а эта ситуация в свою очередь стриггерит вызов std::terminate. Поэтому делаем бесконечный цикл, чтобы иметь возможность посмотреть на этот самый дедлок. И действительно. При запуске программы ничего не выводится. Более того, пока писался этот пост, программа работала и ничего так и не вывела. Учитывая, что потоки особо ничего не делают, то логично предположить, что ситуация и не поменяется. Естественно, что потоков может быть больше и кольцо из ожидающих потоков может быть больше. Но это такой минимальный пример. Если вы думаете, что это какая-то сова в вакууме, то подумайте еще раз. Владение потоками можно передавать в функции. Могут быть довольно сложные схемы организации взаимодействия потоков. И если вы присоединяете поток не в его родителе, то возникает благоприятные условия для возникновения такого безлокового дедлока. Поэтому лучше избегать такого присоединения, или быть супервнимательным, если вы уж решились вступить на эту дорожку. Stay surprised. Stay cool. #concurrency #cppcore
14 فوریه 2025, 04:00

🔥 Самые нужные каналы для C/C++ разработчика, чтобы расти в доходе 💸 • C/C++ | Вопросы собесов • C/C++ | Вакансии с удаленкой • C/C++ | LeetCode • C/C++ | Тесты Подпишись, чтобы не потерять ☝️
14 فوریه 2025, 02:00
16 فوریه 2025, ~01:57

Сколько минимально нужно мьютексов, чтобы вызвать дедлок?
Anonymous voting
13 فوریه 2025, 04:00

Сколько минимально нужно мьютексов, чтобы вызвать дедлок? #опытным Мы уже рассматривали похожий вопрос и на собесах правильными ответом будет 2. 2 потока локают по одному мьютексу и пытаются захватить тот замок, который уже находится во владении другого потока. Они будут пытаться бесконечно исполнение в них перестанет двигаться вперед. Но это скорее для всех ЯП некий универсальный ответ. У всех языков немного разные подходы к многопоточности и немного отличающиеся инструменты для работы с ней. А что если мы не будем ориентироваться на общую универсальную для всех языков теорию многопоточного программирования и сфокусируется чисто на С++ и средствах, которые он предоставляет? Какой тогда будет ответ? #quiz
13 فوریه 2025, 04:00

​​Бросаем число #новичкам Мы привыкли, что исключения имеют какую-то свою иерархию и каждый класс имеет свое конкретное назначение в контексте отображения ошибки. А что если мы попытаемся бросить что-то совсем несвязанное с иcключениями? Например, какой-нибудь тривиальный тип вроде int. Это вообще законно? Абсолютно законно. В С++ можно бросать все, что угодно, кроме объектов неполных типов, абстрактных классов и указателей на неполный тип. Даже указатель на void можно. Как и число. Поймать число примерно также просто, как его бросить:
void foo() {
  throw 1;
}

int main() {
  try {
    foo();
  }
  catch(int i) {
    std::cout << i << std::endl;
  }
}

// OUTPUT: 1
Это кстати один из любимых вопросов у интервьюеров. "А можно ли кидать число вместо исключения?" Теперь вы с полной уверенностью ответите "можно". Но вот зачем это может быть нужно? Оставьте ваши мысли в комментариях Make sense. Stay cool. #interview #cppcore
11 فوریه 2025, 04:00