C++ geek

Что случится, если exception выйдет за пределы потока?

Если exception выходит за пределы потока, то оно не может быть обработано на текущем уровне, т. к. он уже завершен. В таком случае исключение будет зарегистрировано как неперехваченное и может привести к аварийному завершению программы.

Чтобы избежать данной ситуации, необходимо обернуть код, где может возникнуть исключение, в try-catch блок на том же уровне, что и поток, с которым он связан.

➡️ @channel_cpp_geek

Dependency Injection

Dependency Injection (DI) — это паттерн проектирования, который позволяет управлять зависимостями между объектами. Он помогает разделить создание объектов от их использования и обеспечить более гибкую и тестируемую архитектуру программы.

В DI объекты получают свои зависимости не напрямую, а через внешний источник, который их предоставляет. Этот источник называется контейнером внедрения зависимостей. Контейнер отвечает за создание и управление зависимостями, а объекты получают их через конструкторы, методы или свойства.

➡️ @channel_cpp_geek

Execution policy для параллельных алгоритмов

Execution policy в C++ — это новшество, введенное в стандарте языка C++17. Это механизм, который позволяет выбрать, как именно должны выполняться алгоритмы в стандартной библиотеке: последовательно или параллельно.

Существуют три варианта execution policy:

- seq: выполняет алгоритм последовательно.
- par: выполняет алгоритм параллельно, используя все доступные ядра процессора.
- par_unseq: выполняет алгоритм параллельно и может использовать неупорядоченное исполнение.

Execution policy может быть использован в комбинации с многими алгоритмами в стандартной библиотеке, такими как std::for_each, std::transform, std::reduce и другими. Например, код выше выполняет алгоритм std::for_each параллельно.

➡️ @channel_cpp_geek

В чем разница между git fetch и git pull?

Разница между этими командами заключается в том, что когда вы используете команду git fetch, Git извлекает последние изменения из удаленного репозитория в ваш локальный репозиторий, но оставляет эти изменения в отдельной ветке git origin.

А команда git pull извлекает и интегрирует (скачивает и сливает) последние изменения из удаленного репозитория в вашу текущую ветку работы.

➡️ @channel_cpp_geek

std::tie

std::tie — это функция, которая создает кортеж ссылок на lvalue из своих аргументов или экземпляров std::ignore.

Она может использоваться для распаковки кортежей или пары значений в отдельные переменные. Например, если у вас есть функция, которая возвращает std::pair или std::tuple, вы можете использовать std::tie, чтобы присвоить значения этого кортежа отдельным переменным.

В этом примере мы используем std::tie для распаковки результата вызова set_of_s.insert(value) в две переменные: итератор iter и логическую переменную inserted.
Это позволяет нам проверить, было ли значение успешно вставлено в набор.

➡️ @channel_cpp_geek

move constructor

Move-конструктор — это специальный конструктор, который позволяет эффективно перемещать ресурсы из одного объекта в другой, без необходимости копирования данных. Он используется для реализации семантики перемещения (move semantics) и оптимизации работы с временными объектами.

Move-конструктор принимает rvalue ссылку (&&) на объект, который будет перемещен, и выполняет простое копирование указателей на данные, а не их фактическое копирование.

Использование move-конструктора позволяет избежать лишних копирований данных и повысить производительность при работе с большими или ресурсоемкими объектами.

➡️ @channel_cpp_geek

Move-only объекты и почему std::unique_ptr нельзя копировать

Многие удивляются, когда компилятор ругается: «unique_ptr не имеет конструктора копирования». Это не баг, а фича: он move-only. Логика простая: владелец ресурса должен быть только один.

#include <memory>
#include <iostream>

int main() {
std::unique_ptr<int> p1 = std::make_unique<int>(42);

// std::unique_ptr<int> p2 = p1; // ❌ ошибка копирования

std::unique_ptr<int> p2 = std::move(p1); // ✅ перенос
std::cout << *p2 << "\n"; // 42
std::cout << (p1 ? "not null" : "null") << "\n"; // null
}

Ключевой момент: после std::move старый указатель «обнуляется», чтобы избежать двойного освобождения памяти.

Если нужен shareable ресурс – используйте std::shared_ptr. Но помните: это дороже (счётчик ссылок, атомики).

Частая ошибка на собеседованиях: «почему нельзя вернуть unique_ptr по значению?» - на самом деле можно! Он спокойно двигается:

std::unique_ptr<int> make_ptr() {
return std::make_unique<int>(99); // move происходит неявно
}

👉 Правило: если объект владеет чем-то уникально – делайте его move-only (удалите копирование). Это повышает безопасность кода и явно выражает семантику владения.

➡️ @channel_cpp_geek

Генерируем пароли с помощью C++

Эта программа создает константы для допустимых символов в пароле и для длины пароля. Затем она инициализирует генератор случайных чисел и генерирует пять случайных паролей.

Каждый пароль формируется путем выбора случайного символа из всего набора символов. Этот процесс повторяется до достижения желаемой длины пароля.

Сейчас покажу вам простой, но мощный приём для ускорения компиляции - разделение объявления и реализации шаблонов с использованием explicit instantiation.

Все мы знаем, что шаблоны в C++ реализуются в заголовочных файлах. Это значит, что каждый .cpp файл, который включает такой заголовок, заново инстанцирует шаблон. Результат - долгое время компиляции и раздутый бинарник.

🔧 Что можно сделать?

Разделяем интерфейс и реализацию:

// MyTemplate.hpp
#pragma once

template<typename T>
class MyTemplate {
public:
void doSomething();
};
// MyTemplate.cpp
#include "MyTemplate.hpp"
#include <iostream>

template<typename T>
void MyTemplate<T>::doSomething() {
std::cout << "Doing something\n";
}

// Явная инстанциация
template class MyTemplate<int>;
Теперь в клиентском коде:

#include "MyTemplate.hpp"

int main() {
MyTemplate<int> obj;
obj.doSomething();
}

✅ Это даст:

- Сокращение времени компиляции
- Чище зависимости
- Потенциально меньший размер бинарника

Но помните: explicit instantiation работает, только если вы заранее знаете типы, с которыми будете использовать шаблон.

Что такое виртуальный деструктор и зачем он используется в C++?

В C++ виртуальный деструктор используется для правильного освобождения памяти при удалении объекта через указатель на базовый класс. Если базовый класс имеет виртуальный деструктор, то при удалении объекта через указатель на базовый класс будет вызван деструктор не только базового класса, но и всех его производных классов. Это позволяет избежать утечек памяти и неопределенного поведения при работе с полиморфными объектами.

Если виртуального деструктора не объявлено в базовом классе, то при удалении производного объекта через указатель на базовый класс будут вызваны только деструкторы базового класса, что может привести к утечкам памяти и неопределенному поведению.

🧵 Сегодня покажу вам, как удобно логгировать значения в отладке с помощью макроса, который реально упрощает жизнь.

Когда мы отлаживаем код, часто хочется быстро вывести значения переменных. Писать std::cout << "x: " << x << std::endl; каждый раз — боль. Давайте упростим:

#include <iostream>

#define LOG(var) std::cout << #var << " = " << (var) << std::endl;

int main() {
int x = 42;
double pi = 3.1415;

LOG(x); // x = 42
LOG(pi); // pi = 3.1415
}

Фишка в том, что #var превращает имя переменной в строку. А (var) - значение.

🔥 Такой макрос отлично заходит при написании алгоритмов, отладки функций, проверки значений — и при этом делает код аккуратнее.

Хочешь улучшить - можно сделать вывод в файл или добавить таймстемпы.

std::move vs std::forward: когда и что использовать

Сегодня покажу вам коротко, чем отличаются std::move и std::forward.

- std::move(obj) — безусловно превращает объект в rvalue. После этого объект считается "пустым" для повторного использования (в рамках контракта move). Используем, когда мы точно хотим "забрать" ресурсы.

- std::forward<T>(obj) — условно делает rvalue, если изначально пришёл rvalue. То есть это "perfect forwarding" для шаблонных функций.

Пример:

#include <utility>
#include <string>
#include <iostream>

template <typename T>
void wrapper(T&& arg) {
process(std::forward<T>(arg)); // сохраняет rvalue/lvalue-семантику
}

void process(const std::string& s) { std::cout << "Lvalue: " << s << '\n'; }
void process(std::string&& s) { std::cout << "Rvalue: " << s << '\n'; }

int main() {
std::string str = "Hello";
wrapper(str); // Lvalue
wrapper(std::move(str)); // Rvalue
}

Запомните:

- std::move - "забрать".
- std::forward - "передать как есть".

Как уменьшить время компиляции C++ проектов

Сегодня я хочу поговорить про боль, которую мы все знаем — долгую компиляцию больших C++ проектов.
Когда проект растёт, время сборки иногда становится просто катастрофическим. Вот несколько приёмов, которые реально помогают:

1. PCH (Precompiled Headers) — вынесите редко меняющийся код (например, <iostream>, <vector>, <string>) в precompiled header. Это может срезать время компиляции в разы.
2. Разделяйте код на интерфейсы и реализации — заголовки должны быть минимальными, только объявления. Всё, что можно, уносите в .cpp.
3. Используйте #pragma once вместо include guard — чуть быстрее и проще.
4. Минимизируйте include-цепочки — подключайте в заголовках только то, что реально нужно. Остальное — в .cpp.
5. Инкрементальная сборка — убедитесь, что сборочная система (CMake, Ninja, Make) не пересобирает лишнее.

Когда я внедрял эти подходы в одном проекте, время компиляции сократилось с 18 минут до 6. Это реально чувствуется.

std::exchange — простой способ менять значения и возвращать старые

Вместо того чтобы писать руками:

auto old = value;
value = new_value;
return old;

В modern C++ есть готовый инструмент - std::exchange (C++14+).

#include <utility>
#include <string>
#include <iostream>

int main() {
std::string s = "Hello";
auto old = std::exchange(s, "World");

std::cout << "old = " << old << ", s = " << s << '\n';
}

Вывод:

old = Hello, s = World

Когда полезно:

- Реализация move-конструкторов/операторов:


MyType(MyType&& other)
: data_(std::exchange(other.data_, nullptr)) {}
- Сброс состояния объектов и возвращение старого значения.
- Реализация одноразовых флагов (`once_flag` паттерн).

Плюсы:

- Одна строка вместо трёх.
- Читаемость выше — сразу видно, что мы заменяем значение и берём старое.

Помни: по умолчанию второе значение копируется/перемещается, так что это не нулевой по стоимости вызов.

Зачем `nodiscard` и когда он реально спасает?

Сколько раз вы видели: функция возвращает значение, а кто-то его тупо игнорирует. А потом баги из ниоткуда. В C++17 завезли `nodiscard`, и это реально полезная штука.

`nodiscard` int compute() {
return 42;
}

int main() {
compute(); // warning: ignoring return value
}

Компилятор предупреждает: "эй, ты вызвал, но не используешь результат".
Где это особенно важно:

- Функции, которые возвращают ошибки (std::error_code, std::optional, bool успеха операции);
- Функции, где пропуск результата ломает логику (например, RAII-объекты, токены отмены, хендлы).

Можно навесить `nodiscard` и на типы (C++20):

struct `nodiscard` Result {
bool ok;
};

Result foo();
foo(); // warning!

Вместо неочевидных багов — раннее предупреждение компилятора.

⚡ Лайфхак: Если компилятор слишком шумит — можно сделать [[nodiscard("объяснение")]] (C++20), чтобы явно подсказать, зачем это.

Вывод: ставьте `nodiscard` на всё, что нельзя безнаказанно проигнорировать. Это дешёвая страховка от глупых багов.

RAII — твой лучший друг (и почему не стоит бояться умных указателей)

Старый добрый new / delete — это классика, но и источник утечек, крашей и боли. В современном C++ ручное управление памятью почти всегда антипаттерн.

Решение — RAII (Resource Acquisition Is Initialization): ресурсы живут ровно столько, сколько объект, который ими владеет. Ушёл объект из области видимости — ресурс освободился.

Пример с умными указателями:

#include <memory>
#include <iostream>

struct Foo {
Foo() { std::cout << "Init\n"; }
~Foo() { std::cout << "Destroy\n"; }
};

void bar() {
std::unique_ptr<Foo> p = std::make_unique<Foo>(); // RAII
// делаем что-то
} // тут автоматически вызовется ~Foo()

Что важно знать:

* std::unique_ptr — владение в единственном числе, идеально для большинства случаев.
* std::shared_ptr — разделённое владение (но дороже по производительности).
* Никогда не делай new без обёртки — почти всегда лучше std::make_unique или std::make_shared.

RAII работает не только для памяти: файлы, мьютексы, сокеты — всё. Достаточно обернуть ресурс в класс с деструктором.

Профит: меньше багов, меньше утечек, чище код.

Зачем std::move от std::string в emplace_back?

Кажется, emplace_back(std::move(str)) — избыточно: ведь emplace_back сам конструирует объект на месте. Но с std::string и другими перемещаемыми типами всё не так просто.

Пример:

std::vector<std::string> vec;
std::string str = "hello";

vec.emplace_back(str); // копия
vec.emplace_back(std::move(str)); // перемещение

Почему? Потому что:

> emplace_back вызывает конструктор std::string(const std::string&), если аргумент — const std::string&,
> и std::string(std::string&&), если аргумент — std::string&&.

А str — это lvalue. Даже внутри emplace_back. Без std::move, ты просишь вектор скопировать строку. С std::move — переместить.

Это относится ко всем emplace_*, когда ты передаёшь существующий объект. emplace_back("hello") — другое дело: тут создаётся временный const char*, и он уже используется для конструктора string.

👉 Правило: если аргумент — перемещаемый объект (например, std::string, std::vector), и ты передаёшь его в emplace_*, не забывай std::move. Иначе будет лишняя копия.

Что такое ADL и как она может вас подставить

Argument-Dependent Lookup (ADL) — это фича, которая может как упростить код, так и привести к сюрпризам.

Представьте:

namespace math {
struct Vec {};

void print(const Vec&) {
std::cout << "Vec\n";
}
}

void foo() {
math::Vec v;
print(v); // компилятор найдёт math::print через ADL!
}

Хотя print не в текущем скоупе, компилятор ищет её в namespace аргумента v, т.е. math. Это и есть ADL.

Звучит удобно. Но...

⚠️ Опасность:

namespace lib {
struct Widget {};
void process(const Widget&) {
std::cout << "lib::process\n";
}
}

void process(int) {
std::cout << "global::process\n";
}

void bar() {
lib::Widget w;
process(w); // вызовет lib::process, а не global::process!
}

Такой вызов может внезапно потянуть неожиданные функции, особенно в generic-коде (например, в шаблонах), где ADL может найти «лишнее».

✅ Best practices:

* Не полагайся на ADL без крайней нужды.
* Используй ::qualified::names для ясности.
* В шаблонах — лучше явно передавать функции (через policy, traits, или параметры шаблона).

std::thread

std::thread является частью стандартной библиотеки C++ и предоставляет возможность создания и управления потоками выполнения. Он позволяет запускать функции в отдельных потоках, обеспечивая параллельное выполнение кода.

Обратите внимание, что после создания потока std::thread, вы должны вызвать join() или detach() для корректной обработки завершения потока.

В приведенном примере мы использовали join(), чтобы основной поток дождался завершения потока t1. Если вы вызываете join() после завершения потока, программа может выдать исключение или вызвать неопределенное поведение.

Полезные функции, которые будут полезны продвинутым C++ разработчикам.

1. void assert_or_throw(bool cond, const std::string& msg)

Универсальная замена assert в runtime-среде:

void assert_or_throw(bool cond, const std::string& msg) {
if (!cond) throw std::runtime_error(msg);
}

2. template<typename T> std::string to_string_precise(const T& val, int precision = 6)

Преобразование чисел с точностью:

template<typename T>
std::string to_string_precise(const T& val, int precision = 6) {
std::ostringstream out;
out << std::fixed << std::setprecision(precision) << val;
return out.str();
}

3. template<typename F> auto scope_exit(F&& f)

RAII-функция для отложенного вызова:

template<typename F>
class ScopeExit {
F func;
bool active = true;
public:
ScopeExit(F&& f) : func(std::forward<F>(f)) {}
~ScopeExit() { if (active) func(); }
void dismiss() { active = false; }
};

template<typename F>
ScopeExit<F> scope_exit(F&& f) {
return ScopeExit<F>(std::forward<F>(f));
}

4. template<typename T> constexpr bool is_power_of_two(T x)

Компилируемая проверка степени двойки:

template<typename T>
constexpr bool is_power_of_two(T x) {
return x > 0 && (x & (x - 1)) == 0;
}

5. template<typename T> void hash_combine(std::size_t& seed, const T& val)

Для реализации собственного std::hash:

template<typename T>
void hash_combine(std::size_t& seed, const T& val) {
seed ^= std::hash<T>()(val) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}

6. std::vector<std::string> split(const std::string& str, char delimiter)

Полезна для парсинга CSV, логов и т.д.:

std::vector<std::string> split(const std::string& str, char delimiter) {
std::vector<std::string> out;
std::istringstream ss(str);
std::string token;
while (std::getline(ss, token, delimiter)) {
out.push_back(token);
}
return out;
}

7. template<typename T> T clamp(T val, T min_val, T max_val)

Ручной аналог std::clamp (если нужна совместимость со старым C++):

template<typename T>
T clamp(T val, T min_val, T max_val) {
return std::max(min_val, std::min(val, max_val));
}

8. template<typename Container, typename Predicate> bool any_of(const Container& c, Predicate pred)

Упрощённая обёртка над std::any_of:

template<typename Container, typename Predicate>
bool any_of(const Container& c, Predicate pred) {
return std::any_of(c.begin(), c.end(), pred);
}

9. template<typename... Args> std::string format(const std::string& fmt, Args&&... args)

Интерфейс к std::format (C++20+):

template<typename... Args>
std::string format(const std::string& fmt, Args&&... args) {
return std::vformat(fmt, std::make_format_args(args...));
}

10. template<typename T> std::string type_name()

Получение имени типа на этапе компиляции:

template<typename T>
std::string type_name() {
#ifdef __clang__
std::string name = __PRETTY_FUNCTION__;
return name.substr(31, name.length() - 32);
#elif defined(__GNUC__)
std::string name = __PRETTY_FUNCTION__;
return name.substr(49, name.length() - 50);
#elif defined(_MSC_VER)
std::string name = __FUNCSIG__;
return name.substr(38, name.length() - 45);
#else
return "unknown";
#endif
}