C++ geek

Невидимый UB: возвращаем ссылку на локальную переменную Одна из самых коварных ошибок в C++ — возврат ссылки на переменную, срок жизни которой закончился. Казалось бы, всё компилируется, запускается... и даже иногда "работает". А под капотом — undefined behavior. Пример:

    
        
const std::string& getName() {
    std::string name = "John";
    return name;  // 💥 Возвращаем ссылку на локальный объект
}
{}
    

Функция возвращает ссылку на name, но как только getName() завершится, name уничтожается. Ссылка указывает в никуда. Использование этой ссылки:

    
        
std::cout << getName() << "\n";  // UB: может напечатать мусор, может упасть
{}
    

👀 Хитрость: такая ошибка часто прячется внутри более сложных функций, и ловится не сразу. Особенно в шаблонном коде или при рефакторинге. 🔒 Как безопасно? * Возвращайте по значению, если объект небольшой или RVO (return value optimization) работает:

    
        
std::string getName() {
    std::string name = "John";
    return name;  // ок, RVO устранит копирование
}
{}
    

* Или передавайте результат через параметр:

    
        
void getName(std::string& out) {
    out = "John";
}
{}
    

💡 Профит: избежите UB, багов-призраков и бессонных ночей. ➡️ @cpp_geek

🚀 Станьте C++ разработчиком и откройте для себя новые возможности в IT. Актуальное обучение от OTUS — это ваш старт в масштабную разработку на современном подмножестве C++! 👨‍💻 На курсе вы освоите все ключевые аспекты разработки на C++ — от основ синтаксиса до идиом и паттернов языка, продвинутой многопоточности и работы с базами данных Мы подготовим вас для работы с высоконагруженными приложениями, IoT-устройствами и сложными проектами. ⚡️ Изучите C++ с нуля и пройдите два этапа обучения: от Junior до Middle Developer. Реальные кейсы, лучшие практики и советы экспертов помогут вам освоить язык и уверенно претендовать на востребованные позиции. ❗️ Запись на курс закрывается! Оставьте заявку и получите скидку на обучение по промокоду CPPspec_6: https://vk.cc/cN4KR8 Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576, www.otus.ru

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` паттерн). Плюсы: - Одна строка вместо трёх. - Читаемость выше — сразу видно, что мы заменяем значение и берём старое. Помни: по умолчанию второе значение копируется/перемещается, так что это не нулевой по стоимости вызов. ➡️ @cpp_geek

Как уменьшить время компиляции 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. Это реально чувствуется. ➡️ @cpp_geek

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 - "передать как есть". ➡️ @cpp_geek

🧵 Сегодня покажу вам, как удобно логгировать значения в отладке с помощью макроса, который реально упрощает жизнь. Когда мы отлаживаем код, часто хочется быстро вывести значения переменных. Писать 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) - значение. 🔥 Такой макрос отлично заходит при написании алгоритмов, отладки функций, проверки значений — и при этом делает код аккуратнее. Хочешь улучшить - можно сделать вывод в файл или добавить таймстемпы. ➡️ @cpp_geek

🚀 YADRO приглашает C++ разработчиков в команду OpenBMC и встроенных систем! Если вы хотите создавать сложное программное обеспечение для серверов и систем хранения данных, работать с передовыми технологиями Linux и участвовать в проектах open source, то эта возможность для вас. 📌 Кого мы ищем: • Ведущего разработчика C++ (Linux/OpenBMC) • Ведущего разработчика интерфейсов встроенных систем • TeamLead разработки OpenBMC 🧰 Технологический стек и задачи: • C++ (стандарты 17, 20, 23), STL, Boost • Linux-среда, systemd, D-Bus, Yocto, bash, Python • Работа с ядром прошивки OpenBMC, взаимодействие с UEFI/BIOS • Разработка и поддержка сложных интерфейсов встроенных систем 💼 Условия работы: • Гибкий формат: удалённо или в офисах в Москве, Санкт-Петербурге, Екатеринбурге, Нижнем Новгороде и Минске • Работа с масштабными проектами в уникальной команде инженеров • Возможность горизонтального и вертикального карьерного роста 💙 Узнайте больше и откликайтесь на вакансии прямо на сайте!

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

Изменяемые лямбда-функции Ключевое слово mutable используется для сохранения состояния в лямбда-функциях. Обычно оператор вызова функции замыкания является константным. Другими словами — лямбда не может модифицировать переменные, захваченные по значению. Но ключевое слово mutable может быть применено ко всей лямбда-функции, что сделает все её переменные изменяемыми. Следует заметить, что в отличии от mutable-переменных в объявлении класса, мутабельные лямбда-функции должны использоваться относительно редко и очень аккуратно. Сохранение состояния между вызовами лямбда-функции может быть опасным и контринтуитивным. ➡️ @cpp_geek

Сейчас покажу вам простой, но мощный приём для ускорения компиляции - разделение объявления и реализации шаблонов с использованием 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 работает, только если вы заранее знаете типы, с которыми будете использовать шаблон. ➡️ @cpp_geek