Программирование C++

От чего зависит выбор между двумя шаблонными перегрузками, если обе подходят переданному типу, но одна ограничена более узким концептом?

В графе объектов с взаимными ссылками за счёт чего std::weak_ptr разрывает цикл владения?

При расширении std::vector как noexcept у перемещающего конструктора элемента влияет на выбор между копированием и перемещением?

Фоновая задача запускается через std::jthread. Как завершится вызов run() при выходе из функции?

#include <chrono>
#include <thread>

void work(std::stop_token token) {
    while (!token.stop_requested()) {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

void run() {
    std::jthread worker(work);
}

Как в современном C++ передать лямбде владение некопируемым объектом, чтобы ресурс жил не дольше самой лямбды?

Разберите, почему std::string_view может стать висячим представлением после возврата из функции.

При каких условиях фабрика может вернуть объект, у которого запрещены копирование и перемещение, начиная с C++17?

В практической обёртке над фабрикой параметр шаблона объявлен как forwarding-ссылка: что изменится, если передать его дальше без std::forward?

Чем принципиально отличается consteval от constexpr при вызове функции?

Какой статус имеет объект после успешного перемещения в современном C++ и какие операции над ним остаются корректными?

Ручной захват мьютекса прерван исключением до вызова unlock — как это скажется на следующем захвате?

Достаточно ли вызова notify_one на атомарной переменной, чтобы другой поток увидел обычные данные, записанные до уведомления?

В каких пределах std::latch синхронизирует данные между участниками после завершения ожидания?

Вызов std::async выполнен без указания политики запуска. Какую гарантию о параллельном выполнении даёт такой код?

#include <chrono>
#include <future>
#include <thread>

int work() {
    std::this_thread::sleep_for(std::chrono::milliseconds{10});
    return 42;
}

int main() {
    auto result = std::async(work);
    result.wait();
}

Определите последствие исключения, покинувшего функцию потока, и способ безопасно обработать его. Код должен завершиться без аварийного завершения процесса.

#include <stdexcept>
#include <thread>

void worker() {
    throw std::runtime_error("ошибка");
}

int main() {
    std::thread t(worker);
    t.join();
}

Как следует рассуждать о переходе от совместной блокировки std::shared_mutex к исключительной, если условие проверено под shared lock?

За счёт чего std::scoped_lock предотвращает взаимную блокировку при захвате нескольких мьютексов?

Какую роль играет один и тот же мьютекс при изменении предиката и ожидании на std::condition_variable?

В чём принципиальное различие между std::atomic_signal_fence и std::atomic_thread_fence при обмене данными между потоками?

Если std::mutex::try_lock завершился неудачей, можно ли считать, что поток получил актуальное состояние защищаемых данных?