uz
Feedback

Firibgarlarga uchmang! Telemetrio bunday kanallarni topadi va belgilaydi 👉 Belgini ko‘rmoqchi bo‘lsangiz, obuna bo‘ling

Грокаем C++

Грокаем C++

Kanalga Telegram’da o‘tish

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

Ko'proq ko'rsatish
9 357
Obunachilar
-124 soatlar
+147 kun
+1430 kun
Postlar arxiv
Порядок взятия замков. Ч1 #опытным В этом посте я намеренно совершил одну ошибку, как байт на комменты и следующие посты. Но вы как-то пропустили ее, хотя и разбирали ту же самую тему в комментариях.
Cтандартное решение этой проблемы дедлока из постов выше - лочить замки в одном и том же порядке во всех потоках.
На самом деле залочивание мьютексов в одном и том же порядке - не общепринятая концепция решения проблемы блокировки множества замков. Это лишь одна из стратегий. И она не используется в стандартной библиотеке! Когда-то у меня тоже была уверенность, что std::scoped_lock блочит мьютексы в порядоке их адресов. Условно, в начале лочим замок с меньшим адресом. Потом с большим и так далее. Но как я и написал в середине того же поста, что std::scoped_lock вообще не гарантирует никакого порядка залочивания. Гарантируется только что такой порядок не может привести к дедлоку. Давайте посмотрим на следующий пример:
std::mutex log_mutex;

struct MyLock {
  MyLock() = default;
  
  void lock() {
    mtx.lock();
    std::lock_guard lg{log_mutex};
    std::cout << "Lock at address " << &mtx << " is acquired." << std::endl;
  }

  bool try_lock() {
    auto result = mtx.try_lock();
    std::lock_guard lg{log_mutex};
    std::cout << std::this_thread::get_id() << " Try lock at address " << &mtx << ". " << (result ? "Success" : "Failed") << std::endl;
    return result;
  }
  
  void unlock() {
    mtx.unlock();
    std::lock_guard lg{log_mutex};
    std::cout << "Lock at address " << &mtx << " is released." << std::endl;
  }

private:
std::mutex mtx;
};

MyLock lock1;
MyLock lock2;
MyLock lock3;  

constexpr size_t iteration_count = 100;

void func_thread1() {
  size_t i = 0;
  while(i++ < iteration_count) {
    {
      std::lock_guard lg{log_mutex};
      std::cout << std::endl << std::this_thread::get_id() << " Start acquiring thread1" << std::endl << std::endl;
    }
    std::scoped_lock scl{lock1, lock2, lock3};
    std::lock_guard lg{log_mutex};
    std::cout << std::endl << std::this_thread::get_id() << " End acquiring thread1" << std::endl << std::endl;
  }
}

void func_thread2() {
  size_t i = 0;
  while(i++ < iteration_count) {  
    {
      std::lock_guard lg{log_mutex};
      std::cout << std::endl << std::this_thread::get_id() << " Start acquiring thread2" << std::endl << std::endl;
    }  
    std::scoped_lock scl{lock3, lock2, lock1};
    std::lock_guard lg{log_mutex};
    std::cout << std::endl << std::this_thread::get_id() << " End acquiring thread2" << std::endl << std::endl;
  }
}

int main() {
  std::jthread thr1{func_thread1};
  std::jthread thr2{func_thread2};
}
Все довольно просто. Определяем класс-обертку вокруг std::mutex, который позволит нам логировать все операции с ним, указывая идентификатор потока. Определяем все методы, включая try_lock, чтобы MyLock можно было использовать с std::scoped_lock. Также определяем 2 функции, которые будут запускаться в разных потоках и пытаться локнуть сразу 3 замка. И блокируют они их в разных порядках. Все это в циклах, чтобы какую-то статистику иметь. С потоками сложно детерминировано общаться. Запускаем это дело и смотрим на вывод консоли. Там будет огромное полотно текста, но вы сможете заметить в нем "несостыковочку" с теорией про блокировку по адресам. Возможный кусочек вывода:
129777453237824 Start acquiring thread1

129777453237824 Lock at address 0x595886d571e0 is acquired.
129777453237824 Try lock at address 0x595886d57220
129777453237824 Try lock at address 0x595886d57260
...
129777442752064 Start acquiring thread2

129777442752064 Lock at address 0x595886d57260 is acquired.
129777442752064 Try lock at address 0x595886d57220
129777442752064 Try lock at address 0x595886d571e0
Тут наглядно показано, что мьютексы лочатся в противоположном порядке в разных потоках. И в коде мьютексы передаются в скоупд лок в противоположном порядке. А значит дело тут не в адресах, а в чем-то другом. О этом в следующий раз. Don't get fooled. Stay cool. #concurrency #cpp17
21 Noy 2024, 04:00

Цензура ЛЮБОЙ нейронки разлетается в щепки только от ОДНОГО промпта. После ввода — никаких запретов. Генерим хоть самый жестк
Цензура ЛЮБОЙ нейронки разлетается в щепки только от ОДНОГО промпта. После ввода — никаких запретов. Генерим хоть самый жесткий контент. Мегапромпт лежит здесь.
21 Noy 2024, 03:00
22 Noy 2024, ~03:00

Спасибо всем, кто поделился своими лав-стори в комментах. Такие разные истории, но в то же время одинаковые. И во всех них сквозит одна мысль: "Двигайся по зову своего внутреннего огня. Он приведет тебя к цели" Если что-то не нравится, никогда не поздно это поменять. Если что-то нравится, делай это и жизнь будет радостней. И это касается не только программирования естественно. Рад, что у нас здесь собрались такие разные люди под одной двойнопозитивной крышей. Просто решил поделиться с вами своими эмоциями. Всем продуктивного дня! Be passionate. Stay cool.
20 Noy 2024, 04:28

А как вы пришли к программированию на плюсах? Как это изменило вашу жизнь?
А как вы пришли к программированию на плюсах? Как это изменило вашу жизнь?
19 Noy 2024, 04:00

std::lock #опытным Сейчас уже более менее опытные разрабы знают про std::scoped_lock и как он решает проблему блокировки множества мьютексов. Однако и в более старом стандарте С++11 есть средство, позволяющее решать ту же самую проблему. Более того std::scoped_lock - это всего лишь более удобная обертка над этим средством. Итак, std::lock. Эта функция блокирует 2 и больше объектов, чьи типы удовлетворяют требованию Locable. То есть для них определены методы lock(), try_lock() и unlock() с соответствующей семантикой. Причем порядок, в котором блокируются объекты - не определен. В стандарте сказано, что объекты блокируются с помощью неопределенной серии вызовов методов lock(), try_lock и unlock(). Однако гарантируется, что эта серия вызовов не может привести к дедлоку. Собстна, для этого все и затевалось. Штука эта полезная, но не очень удобная. Сами посудите. Эта функция просто блокирует объекты, но не отпускает их. И это в эпоху RAII. Ай-ай-ай. Поэтому ее безопасное использование выглядит несколько вычурно:
struct SomeSharedResource {
  void swap(SomeSharedResource& obj) {
    {
      // !!!
          std::unique_lock<std::mutex> lk_c1(mtx, std::defer_lock);
          std::unique_lock<std::mutex> lk_c2(obj.mtx, std::defer_lock);
          std::lock(mtx, obj.mtx);
      // handle swap
    }
  }
  std::mutex mtx;
};

int main() {
  SomeSharedResource resource1;
  SomeSharedResource resource2;  
  std::mutex m2;
  std::thread t1([&resource1, &resource2] {
    resource1.swap(resource2);
    std::cout << "1 Do some work" << std::endl;
  });
  std::thread t2([&resource1, &resource2] {
    resource2.swap(resource1);
    std::cout << "2 Do some work" << std::endl;
  });

  t1.join();  
  t2.join();
}
Раз мы все-таки за безопасность и полезные практики, то нам приходится использовать std::unique_lock'и на мьютексах. Только нужно передать туда параметр std::defer_lock, который говорит, что не нужно локать замки при создании unique_lock'а, его залочит кто-то другой. Тем самым мы убиваем 2-х зайцев: и RAII используем для автоматического освобождения мьютексов, и перекладываем ответственность за блокировку замков на std::lock. Можно использовать и более простую обертку, типа std::lock_guard:
struct SomeSharedResource {
  void swap(SomeSharedResource& obj) {
    {
      // !!!
          std::lock(mtx, obj.mtx);
          std::lock_guard<std::mutex> lk_c1(mtx, std::adopt_lock);
          std::lock_guard<std::mutex> lk_c2(obj.mtx, std::adopt_lock);
      // handle swap
    }
  }
  std::mutex mtx;
};
Здесь мы тоже используем непопулярный конструктор std::lock_guard: передаем в него параметр std::adopt_lock, который говорит о том, что мьютекс уже захвачен и его не нужно локать в конструкторе lock_guard. Можно и ручками вызвать .unlock() у каждого замка, но это не по-православному. Использование unique_lock может быть оправдано соседством с условной переменной, но если вам доступен C++17, то естественно лучше использовать std::scoped_lock. Use modern things. Stay cool. #cpp11 #cpp17 #concurrency
18 Noy 2024, 04:00

​​Локаем много мьютексов #опытным Cтандартное решение этой проблемы дедлока из постов выше - лочить замки в одном и том же порядке во всех потоках. Но как это сделать? Они не же на физре, "по порядку рассчитайсьььь" не делали. Можно конечно на ифах городить свой порядок на основе, например, адресов мьютексов. Но это какие-то костыли и так делать не надо. Так как проблема довольно стандартная, то и решение мы скорее всего найдем в том же стандарте. std::scoped_lock был введен в С++17 и представляет собой RAII обертку над локом множества мьютексов. Можно сказать, что это std::lock_guard на максималках. То есть буквально, это обертка, которая лочит любое количество мьютексов от 0 до "сами проверьте верхнюю границу". Но есть один важный нюанс. Никак не гарантируется порядок, в котором будут блокироваться замки. Гарантируется лишь то, что выбранный порядок не будет приводить к dead-lock'у. Пример из прошлого поста может выглядеть теперь вот так:
struct SomeSharedResource {
  void swap(SomeSharedResource& obj) {
    {
      std::scoped_lock lg{mtx, obj.mtx};
      // handle swap
    }
  }
  std::mutex mtx;
};

int main() {
  SomeSharedResource resource1;
  SomeSharedResource resource2;  
  std::mutex m2;
  std::thread t1([&resource1, &resource2] {
    resource1.swap(resource2);
    std::cout << "1 Do some work" << std::endl;
  });
  std::thread t2([&resource1, &resource2] {
    resource2.swap(resource1);
    std::cout << "2 Do some work" << std::endl;
  });

  t1.join();  
  t2.join();
}
И все. И никакого дедлока. Однако немногое лишь знают, что std::scoped_lock - это не только RAII-обертка. Это еще и более удобная обертка над "старой" функцией из С++11 std::lock. О ней мы поговорим в следующий раз. Ведь не всем доступны самые современные стандарты. Да и легаси код всегда есть. Be comfortable to work with. Stay cool. #cpp17 #cpp11 #concurrency
17 Noy 2024, 06:00

​​Зачем локать мьютексы в разном порядке #новичкам Можете подумать, что раз всем так известно, что мьютексы опасно лочить в разном порядке, то почему вообще кому-то в голову может прийти наступить на грабли и накалякать такое своими программисткими пальчиками снова? Просто не пишите хреновый код и будет вам счастье. Дело в том, что иногда это не совсем очевидно. Точнее почти всегда это не очевидно. Программисты хоть и разные бывают, но ревью никто не отменял и такую броскую ошибку бы явно заметили. Поэтому не все так просто, как на первый взгляд кажется. Разберем чуть более сложный пример:
struct SomeSharedResource {
  void swap(SomeSharedResource& obj) {
    {
      std::lock_guard lg{mtx};
      // just for results reproducing
      std::this_thread::sleep_for(std::chrono::milliseconds(10));
      std::lock_guard lg1{obj.mtx};
      // handle swap
    }
  }
  std::mutex mtx;
};

int main() {
  SomeSharedResource resource1;
  SomeSharedResource resource2;  
  std::mutex m2;
  std::thread t1([&resource1, &resource2] {
    resource1.swap(resource2);
    std::cout << "1 Do some work" << std::endl;
  });
  std::thread t2([&resource1, &resource2] {
    resource2.swap(resource1);
    std::cout << "2 Do some work" << std::endl;
  });

  t1.join();  
  t2.join();
}
Все просто. У нас есть пара объектов, которые используются в качестве разделяемых ресурсов (их могут изменять более 1 потока). Объекты могут обмениваться между собой данными. Ну и по всем канонам нам же надо защитить оба объекта при свопе. Поэтому после захода в функцию обмена сначала лочим свой мьютекс, а потом мьютекс объекта с которым собираемся свопаться. И вроде снаружи кажется, что мы всегда лочим в одном порядке. Пока мы не будем обменивать данные одних и тех же объектов в разных потоках в разном порядке. Тогда первый поток может залочить мьютекс первого объекта и, допустим, заснуть. А второй поток первым залочит мьютекс второго объекта. И все. Приплыли. И это все еще может показаться детским садом и очевидушкой. Только вот сам момент взятия замка уже не выглядит так подозрительно. А сами объекты могут лежать в каких-то страшных структурах данных и могут быть разбросаны по коду. В таком случае все не так очевидно становится. В следующий раз поговорим, как же не допускать такие ошибки. Don't be obvious. Stay cool. #concurrency
15 Noy 2024, 06:00

🚀 Приглашаем на бесплатный вебинар по C++! 🚀 Дата: 19 ноября 2024 года Время: 20:00 Тема: Как протестировать C++ код и оцен
🚀 Приглашаем на бесплатный вебинар по C++! 🚀 Дата: 19 ноября 2024 года Время: 20:00 Тема: Как протестировать C++ код и оценить степень собственной лени На вебинаре поговорим о том, зачем разработчикам писать юнит-тесты, и какую пользу они несут. Посмотрим популярные фреймворки тестирования, такие как GTest и Boost, разберем несколько практических примеров. Затем попробуем оценить, достаточно ли тестов мы написали для своего кода. На занятии: 1. Научимся подключать фреймворки тестирования к своему проекту при помощи CMake. 2. Напишем готовые к запуску тесты. 3. Поговорим о том, как измерить покрытие тестами кода, какие инструменты для этого существуют. В результате: 1. Придем к тому, что вместе с кодом стоит сразу писать и юнит-тесты к нему. 2. В будущем с легкостью интегрируем любой фреймворк тестирования в свой проект. 3. Научимся не только писать тесты, но и мерить их покрытие. 👉🏻О курсе "Специализация C++ Developer" на Otus: Длительность курса: 10 месяцев. Формат: Онлайн. Программа курса: · Введение в язык C++: основы синтаксиса, структура программ, базовые конструкции. · Классы и структуры: ООП, наследование, полиморфизм, шаблоны. · Основы unit-тестирования: подключение фреймворков, написание тестов, измерение покрытия. · Стандартная библиотека и полезные алгоритмы: контейнеры, ввод-вывод, алгоритмы. 📌Скидка 15%: действует до 17 ноября! Не упустите шанс стать профессионалом в C++! Присоединяйтесь к вебинару и узнайте больше о курсе. 🔗 Регистрация на вебинар Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576, www.otus.ru
15 Noy 2024, 02:01
19 Noy 2024, ~04:37

Дедлокаем код #новичкам Частый вопрос на собесах или даже на скринингах - сколько минимум нужно мьютексов, чтобы гарантировано скрафтить дедлок. Прежде, чем приступим к разбору, небольшое введение. Deadlock - это ситуация, когда два или более потока оказываются заблокированными и не могут продолжить свою работу, так как каждый из них ожидает ресурс, который удерживает другой заблокированный поток. В результате, ни один из потоков не может завершиться, а система оказывается в застойном состоянии. Многопоточка - это мир магии и чудес. Ошибки, которые появляются по причине плохой организации доступа потоков к ресурсам - самые трудновоспроизводимые и сложные для отладки. И никогда не знаешь откуда выстрелит. Да и сами ошибки принимают причудливые облики. Поэтому дедлоки могут по разному быть проявлены в коде, но поведение программы всегда при этом стабильно убогое - потоки не могут дальше продолжать производить работу. В рамках текущего поста будем обсуждать так называемую циклическую блокировку. Ща поймете, о чем речь. Стандартный ответ на вопрос из начала - 2. В одном потоке блочим в начале первый мьютекс, потом второй, а в другом потоке наоборот. Таким образом может произойти ситуация, когда оба потока захватили в заложники каждый по одному мьютексу и бесконечно висят в ожидании освобождения второго. Этого никогда не произойдет, потому что каждому нужен замок, который уже захватил другой поток и он его отдавать не собирается, пока пройдет всю критическую секцию. А он ее никогда не пройдет. В общем, собака пытается укусить себя за чресла. Самый простой пример, который иллюстирует эту ситуацию:
std::mutex m1;
std::mutex m2;

std::thread t1([&m1, &m2] {
  std::cout << "Thread 1. Acquiring m1." << std::endl;
  m1.lock();
  std::this_thread::sleep_for(std::chrono::milliseconds(10));
  std::cout << "Thread 1. Acquiring m2." << std::endl;
  m2.lock();
  std::cout << "Thread 1 perform some work" << std::endl;
});

std::thread t2([&m1, &m2] {
  std::cout << "Thread 2. Acquiring m2." << std::endl;
  m2.lock();
  std::this_thread::sleep_for(std::chrono::milliseconds(10));
  std::cout << "Thread 2. Acquiring m1." << std::endl;
  m1.lock();
  std::cout << "Thread 2 perform some work" << std::endl;
});

t1.join();
t2.join();
Все канонично. В двух разных потоках пытаемся залочить замки в разном порядке. В итоге вывод будет такой:
Thread 1. Acquiring m1.
Thread 2. Acquiring m2.
Thread 2. Acquiring m1.
Thread 1. Acquiring m2.
И дальше программа будет бесконечно простаивать без дела, как тостер на вашей кухне. Do useful work. Stay cool. #concurrency
13 Noy 2024, 06:00

Получите оффер Software Engineer всего за 3 дня! 🚀 Вендор и производитель IT-инфраструктуры YADRO приглашает Software Engine
Получите оффер Software Engineer всего за 3 дня! 🚀 Вендор и производитель IT-инфраструктуры YADRO приглашает Software Engineer на SPRINT OFFER. Команда KVADRA OS ждёт кандидатов сразу на два направления: Linux-based (от уровня junior) и Android (уровня middle и senior). В YADRO под брендом KVADRA ребята создают персональные устройства, а также разрабатывают собственную операционную систему kvadraOS, которая поддерживает облачное хранилище и включает множество компонентов собственной разработки — от системного ядра до приложений и сервисов. 🔵 Присоединившись к YADRO, вы станете частью большого инженерного сообщества и получите возможность влиять на продукт, работая в уникальной команде специалистов. Читайте подробности на сайте, оставляйте заявку до 24 ноября и присоединяйтесь к команде KVADRA OS → по ссылке.
13 Noy 2024, 03:00
18 Noy 2024, ~02:33

Возвращаем ссылку в std::optional #новичкам В прошлом посте я упоминал, что методы front и back последовательных контейнеров играют в ящик, если их пытаться вызвать на пустом контейнере. Это приводит к UB. Один из довольно известных приемов для обработки таких ситуаций - возвращать не ссылку на объект, а std::optional. Это такая фича С++17 и класс, который может хранить или не хранить объект. Теперь, если контейнер пустой - можно возвращать std::nullopt, который создает std::optional без объекта внутри. Если в нем есть элементы, то возвращать ссылку. Только вот проблема: std::optional нельзя создавать с ссылочным типом. А копировать объект ну вот никак не хочется. А если он очень тяжелый? Мы программисты и тяжести поднимать не любим. И вроде бы ситуация безвыходная. Но нет! Решение есть! Можно возвращать std::optional<std::reference_wrapper<T>>. std::reference_wrapper - это такая обертка над ссылками, чтобы они вели себя как кошерные объекты со своими блэкджеком, конструкторами, деструкторами и прочими прелестями. Это абсолютно легально и теперь у вас никакого копирования нет!
std::optional<std::reference_wrapper<T>> Container::front() {
  if (data_.empty()) {
    return std::nullopt;
  }
  return std::ref(data_[0]);
}
И в добавок есть нормальная безопасная проверка. Пользуйтесь. Stay safe. Stay cool. #cpp17 #STL #goodpractice
12 Noy 2024, 07:04

А что вы думаете по поводу вектора и скорости развития С++? И почему у нас до сих пор нет стандартного тредпула??
А что вы думаете по поводу вектора и скорости развития С++? И почему у нас до сих пор нет стандартного тредпула??
11 Noy 2024, 04:00

​​Виртуальная дружественная функция #новичкам Вчера мы поговорили о том, что таких функций не бывает, но очень хочется получить альтернативу. Хочется изменять работу функции в зависимости от динамического типа, который в нее передается. Ну и на самом деле ничего сложного здесь нет. Можно ведь сделать полиморфный метод, который будет вызываться в этой функции. И вот его поведение мы можем изменять примерно как нашей душеньке захочется. Рассмотрим банальный пример - сериализация объекта в поток. Обычно для такой задачи используют дружественный оператор <<. Но вот хотелось бы сериализовать в зависимости от динамического типа. Фигня вопрос.
struct Person {
  Person(const std::string &first_name,
       const std::string &last_name) : first_name_{first_name},
                      last_name_{last_name} {}
  
  friend std::ostream& operator<<(std::ostream& o, const Person& b) {
    return o << b.to_str();
  }
protected:
  virtual std::string to_str() const{
    return first_name_ + " " + last_name_;
  }
private:
  std::string first_name_;
  std::string last_name_;
};

struct TaxPayer : Person {
  TaxPayer(const std::string first_name,
       const std::string last_name,
       const std::string itn) : Person{first_name, last_name}, itn_{itn} {}
protected:
  virtual std::string to_str() const{
    return Person::to_str() + " " + itn_;
  }
private:
  std::string itn_;
};

int main() {
  auto prs1 = std::make_unique<Person>("Ter", "Minator");
  auto prs2 = std::make_unique<TaxPayer>("Ace", "Ventura", "0000");
  std::cout << *prs1 << std::endl;
  std::cout << *prs2 << std::endl;
}
// OUTPUT:
// Ter Minator
// Ace Ventura 0000
Есть у нас класс человека с его именем и фамилией. Есть класс налогоплательщика, который наследуется от человека и добавляет к полям ИНН. Допустим, мы хотим как-то выводить на консоль содержимое этих людей(в смысле поля; расчленением мы не занимаемся, не в Питере живем все-таки). Можно конечно в каждом классе определять свой оператор или выводить на консоль результат работы метода to_str, но это лишний апи и лишний код. Мы просто в базовом классе определяем другана и говорим, чтобы он вызывал виртуальный метод. И все. Да, это очень просто. Но подход скрытия деталей реализации за закрытым виртуальным методом используется, например в идиоме невиртуального интерфейса и еще невесть где. Поэтому о даже о таком приеме надо знать и применять его в подходящих ситуациях. Have a real friends. Stay cool. #cppcore
09 Noy 2024, 07:01

​​Может ли дружественная функция быть виртуальной? #опытным Еще один вопрос из серии "а могут ли рыбы быть рыжими?" - "Да вроде как по цвету могут, но рыжие это обычно про волосы, а волос у рыб нет. Да и вообще, кому это знание нужно?!". Что-то типа такого. Но раз такие вопросы задают, то пора в ваше кунг-фу добавить и этот приемчик. Давайте начнем с начала. Дружественная функция - обычная функция, которая имеет доступ к полям класса-друга. И все. Никаких других особенностей у нее нет. И ограничений тоже никаких нет. Ее сигнатура может быть любой. Объект класса-друга может в ней вообще не фигурировать. А для виртуальности необходим экземпляр класса, в котором укромно затаился vptr, который и отвечает за диспатчинг вызовов в рантайме. Вот и получается, что виртуальных дружественных функций не бывает. Конечно вопрос о виртуальных friend-функциях может заходить только тогда, когда в параметрах есть ссылка или указатель на объект полиморфного класса. Но в общем случае на это не накладываются ограничения. Поэтому и в общем случае виртуальных подруг у класса не бывает. Теперь сможете смело парировать интервьюеров четким ударом в глазницу быстрым точным ответом Но осадочек-то остался. Хочется менять работу дружественной функции в зависимости от того, какой конкретный объект ей передается. Такое мероприятие можно организовать достаточно просто, но это в следующем посте. Have a real friends. Stay cool. #interview #cppcore
08 Noy 2024, 04:00

Приглашаем на митап для бэкенд-разработчиков от Еком-сервисов Яндекса В Минск приехал Яндекс Foodtech Tour — серия митапов в
Приглашаем на митап для бэкенд-разработчиков от Еком-сервисов Яндекса В Минск приехал Яндекс Foodtech Tour — серия митапов в столицах, на которых эксперты Еды, Лавки и Маркета рассказывают о внутренней кухне разработки сервисов. В Минске спикеры расскажут о core-технологиях, которые лежат в основе работы продуктов. Митап пройдет 7 декабря.  Программа насыщенная:  👉Доклады о BDUI и ускорении разработки. Никита Шумский из Еды расскажет об особенной инфраструктуры Еды, различиях классического и мобильного бэкенда и преимуществах BDUI. Ваня Ходор из Лавки поделится кейсом ускорения разработки, причем не скорости работы кода, а его написания. 👉CaseLab о мультизаказе в Еде. Это интерактивный формат, в котором участники разбирают реальный кейс из работы сервиса, предлагают решение и получают фидбек от экспертов Яндекса. 👉Нетворкинг и afterparty Будет интересно — зовите друзей и регистрируйтесь!  Количество мест ограничено. Дождитесь подтверждения заявки.
08 Noy 2024, 03:00
09 Noy 2024, ~03:00

​​BUG Еще одно слово, которое мы постоянно используем, вроде как знаем его значение, но понятие не имеем о его ориджине. Даже те, кто знает английский, не сразу доходят до скрытых взаимосвязей. Дело в том, что на инглише "bug" - это жук и иногда какое-то обобщенное название рандомного насекомого. И как жуки связаны с программными ошибками? Словом "баг" еще в позапрошлом столетии нарекали какие-то неполадки с электротехникой. В те времена эти технологии были "новинкой" и страдали от всяких детских проблем. Поэтому скорее всего эти проблемы сравнивали с жуками из-за их схожести с маленькими, надоедливыми насекомыми, мешающими работать. Они постоянно где-то прячутся, неожиданно появляются и непонятно откуда вылезают. Томас Эдисон писал:
Так было со всеми моими изобретениями. Первый шаг — интуиция, которая приходит как вспышка, затем возникают трудности — устройство отказывается работать, и именно тогда проявляются „жучки“ — как называют эти мелкие ошибки и трудности — и требуются месяцы пристального наблюдения, исследований и усилий, прежде чем дело дойдёт до коммерческого успеха или неудачи.
Поэтому такое значение слова было в принципе всегда известно. Но по отношению к программной ошибке термин стал употребляться после одного знаменитого случая(по одной из версий).  В 1946 году в работе компьютера Марк-2 ( Harvard Mark-II) обнаружили ошибку. Тогда ЭВМ были размером с баттхертом либералов после победы Трампа. Все работало на больших элементах, лампах и реле и время от времени какой-то из элементов выходил из строя. Это вполне нормальная тема для тех лет. И в этот раз научный сотрудник Грейс Хоппер отследила проблему и была удивлена, обнаружив сгоревшего мотылька, попавшего на контакты. Бездыханный трупик мотылька был извлечен и приклеен к отчету липкой лентой с комментарием «First actual case of bug being found.» («Первый реальный случай нахождения жучка»). Press F. После этого случая термин разлетелся из уст в уста. Тогда программисты занимались не только софтиной, но и плотно работали с железками и, в принципе, с электроникой. Им уже было знакомо называть багами проблемы в технике. Теперь к значению добавились и программные ошибки. Так этот жук стал самым знаменитым жуком в мире и увековечил память о себе в умах программистов и не только.   Можно кстати сделать один небольшой шажок вперед и понять, что примерно оттуда же растут ноги у слова «дебаггер» (debugger) – буквально «избавитель от жучков». Так что у нас есть что-то общее с дезинсекторами... Dig to the origin. Stay cool. #fun
07 Noy 2024, 04:00

​​Различаем преинкремент и постинкремент #новичкам Новичкам всегда не просто даются перегрузки операторов. Не то, чтобы кому-то часто приходится перегружать операторы. Но уж эти *нкременты точно редко. Из-за этого особенности постоянно забываются. Давайте же во всем разберемся. Есть операторы инкремента и декремента. Первые увеличивают значение на какую-то условную единицк, вторые - уменьшаю. Они подразделяются на 2 формы: пре- и пост-. Далее будем все разбирать на примере операторов инкремента, для декремента все аналогично, только меняете плюс на минус. Преинкремент - увеличивает значение на единицу и возвращает ссылку на уже увеличенное значение. Синтаксис использования такой: ++value. Постинкремент - делает копию исходного числа, увеличивает на единицу оригинал, и возвращает копию по значению. Синтаксис использования такой: value++. Обычно внешний вид перегрузки операторов внутри описания класса такой: возвращаемое_значение operator{символы_вызова_оператора}(аргументы). Например, оператор копирования вызывается с помощью оператора присваивания(=). Поэтому подставляем в шаблон на место возвращаемое_значение ссылку на объект, на место символы_вызова_оператора подставляем =, на место аргументов - const Type&. Получается так:
Type& operator=(const Type&);
Но теперь возникает вопрос. С++ не различает функции, у которых то же имя, то же те же аргументы, но разные возвращаемые значения. У нас как раз такая ситуация: названия одинаковые(operator++), возвращаемые значения разные(в одном случае возвращаем по ссылке, во втором - по значению) и одинаково отсутствуют аргументы. Если бы мы определили операторы так:
Type& operator++() {
  value_ += 1;
  return *this;
}

Type operator++() {
  auto tmp_value = *this;
  value_ += 1;
  return tmp_value;
}
То была бы примерно такая ошибка компиляции: functions that differ only in their return type cannot be overloaded. Что же делать? Примерно таким же вопросом задался Страуструп и сделал ход конем(правда конь ходил на костылях). Он связал префиксный оператор с человеческой формой объявления, а постфиксный - с вот такой:
Type operator++(int) {
  auto tmp_value = *this;
  value_ += 1;
  return tmp_value;
}
Он ввел безымянный интовый параметр функции. Теперь чисто технически, компилятор сможет различить 2 вызова этих операторов и правильно заметчить эти вызовы на нужные определения. Если видит префикс - выбирает оператор без аргумента, видит постфикс - выбирает с аргументом. Вопрос, почему тип аргумента именно int - остается открытым. Наверное так было проще. Итого, так перегружаются операторы инкремента:
struct Type {
  Type& operator++() {
    value_ += 1;
    return *this;
  }
  
  Type operator++(int) {
    auto tmp_value = *this;
    value_ += 1;
    return tmp_value;
  }
private:
  IntegerLikeType value_;
};
Think of your decisions twice. Stay cool. #cppcore
05 Noy 2024, 04:00

Яндекс Foodtech Tour теперь в Казани! Эксперты Еком-сервисов Яндекс продолжают тур по городам с митапами для бэкенд-разработч
Яндекс Foodtech Tour теперь в Казани! Эксперты Еком-сервисов Яндекс продолжают тур по городам с митапами для бэкенд-разработчиков. Ближайший пройдет в Казани уже 14 ноября. В программе три доклада:  👉 Никита Сидоров, руководитель службы инфраструктуры пользовательской скорости в Яндекс маркете, расскажет про подходы к работе над перформансом приложения 👉 Гадель Закиров и Назар Старанцов, руководители групп в Яндекс Еде, объяснят, как можно ускорять старт приложения и загрузку главной страницы  👉 Гоша Пономарев и Костя Захматов, разработчики в Яндекс Лавке, поделятся историей ускорения работы в дарксторах  После докладов гостей ждет открытый микрофон со спикерами и афтепати. Зовите друзей и регистрируйтесь!  Обратите внимание, количество мест ограничено. После регистрации обязательно дождитесь подтверждения заявки.
05 Noy 2024, 03:00
06 Noy 2024, ~03:00

Принтуем уникальный указатель #новичкам Умные указатели делают нашу жизнь намного проще. Они не только такие умные, что нам не стоит беспокоиться о менеджменте памяти. Они еще и очень удобные с точки зрения использования. Мы пользуемся умным указателем почти также, как мы бы пользовались обычным указателем. Все операторы перегружены так, чтобы мы вообще не видели разницу. И мы понимаем, что это обертка, когда нам нужно достать сам сырой указатель и вызвать метод get(). Один из таких случаев - вывод указателя в поток. Если мы захотим вывести на консоль адрес объекта, то нам нужно будет вызывать метод get.
auto u_ptr = std::make_unique<Type>();
std::cout << u_ptr.get() << std::endl;
Но это же странно! Да, это скорее нужно в каких-то отладочно-логировачных целях и ничего более. Но нужно же! Че им стоило перегрузить оператор<<, чтобы мы могли непосредственно сам объект уникального указателя сериализовывать? Видимо больших затрат. Но ребята поднатужились и справились. В С++20 мы можем выводить сам объект без метода get()!
auto u_ptr = std::make_unique<Type>();
std::cout << u_ptr << std::endl;
Ну и конечно в этом случае на консоли появится адрес объекта. Смысл вывода умного указателя на поток всегда был понятен, поэтому хорошо, что комитет включил такое небольшое изменение в стандарт. Теперь уникальный указатель стал еще более тонкой оберткой. Make small changes. Stay cool. #cpp20 #cppcore
04 Noy 2024, 04:00

​​Вызываем функцию в глобальном скоупе В отличие от С в С++ можно вызывать код до входа в main. В С нельзя вызывать функции в глобальном скоупе, и глобальные переменные там должны быть инициализированы константным выражение. Однако для С++ пришлось ослабить правила. Это было нужно для возможности создания объектов кастомных классов, как глобальных переменных. Для создания объектов нужны конструкторы. А это обычные функции. Поэтому в плюсах можно выполнять пользовательский код до main. Но этот код должен содержаться внутри конструкторов и вызываемых ими функциях. Но просто так вызвать рандомную функция я не могу. Это запрещено. "Ну блин. Мне очень надо. Может как-то договоримся?" Со стандартом не договоришься. Но обходные пути все же можно найти. Например так:
static int dummy = (some_function(), 0);

int main() {}
Здесь мы пользуемся уникальными свойствами оператора запятая: результат первого операнда вычисляется до вычисления второго и после просто отбрасывается. А значение всего выражения задается вторым операндом. Получается, что здесь мы создаем статическую переменную-пустышку, чтобы получить возможность оперировать в глобальном скоупе. Инициализаторы глобальных переменных в С++ могут быть вычисляемыми. Поэтому мы используем свойство оператора запятой, чтобы беспоследственно вычислить some_function, а инициализировать dummy нулем. Вероятнее всего, вам никогда не понадобиться так вызывать функцию. Однако оператор запятая - уникальный инструмент и может выручить даже в таких непростых ситуациях. Have unique tools in your arsenal. Stay cool. #cppcore #goodoldc
03 Noy 2024, 04:00