- Telegram Web

C++ geek

Сегодня покажу вам полезную вещь, которую часто упускают даже опытные C++ разработчики - Альтернативные способы инициализации std::vector.

🔹 std::vector: Инициализация — больше, чем просто {}

Многие используют векторы так:


std::vector<int> v = {1, 2, 3};

Но есть и другие варианты, которые помогут сделать код выразительнее, а в некоторых случаях — эффективнее.

🔸 1. Инициализация с количеством элементов и значением


std::vector<int> v(5, 10); // 5 элементов по 10

🔥 Часто полезно, когда нужен предзаполненный буфер.

🔸 2. С использованием std::fill


std::vector<int> v(10);
std::fill(v.begin(), v.end(), 7);

✅ Удобно, когда вектор уже создан, но нужно всё заполнить определённым значением.

🔸 3. std::generate и std::iota


std::vector<int> v(10);
std::iota(v.begin(), v.end(), 1); // 1, 2, 3, ..., 10

🚀 Идеально подходит, когда нужно создать диапазон значений.

🔸 4. Из другой коллекции (через итераторы)


std::list<int> lst = {4, 5, 6};
std::vector<int> v(lst.begin(), lst.end());

🔄 Позволяет гибко конвертировать контейнеры.

🔸 5. Через reserve + emplace_back


std::vector<std::pair<int, int>> v;
v.reserve(3);
v.emplace_back(1, 2);
v.emplace_back(3, 4);
v.emplace_back(5, 6);

🔧 Отлично, когда важна производительность и хочется избежать лишнего копирования.

✅ Совет: Не забывайте про reserve, если знаете итоговый размер вектора — избежите лишних реаллокаций.

Надеюсь, вы узнали что-то новое. Поделитесь, какие приёмы чаще используете вы?

➡️ @cpp_geek

1.6K views05:30

C++ geek

💡 Сегодня покажу вам способ, как удобно логировать enum-значения в C++, не превращая код в кашу из switch и if.

📌 Проблема: у вас есть enum, и вы хотите красиво выводить его в лог или std::cout, но стандартно C++ этого не умеет.

Например:


enum class Status {
    Ok,
    Error,
    Timeout
};

Обычно вы пишете:


std::string to_string(Status s) {
    switch(s) {
        case Status::Ok: return "Ok";
        case Status::Error: return "Error";
        case Status::Timeout: return "Timeout";
    }
    return "Unknown";
}

Но есть способ проще и без switch — с помощью макроса и X-макросов:


#define STATUS_ENUM(XX) \
    XX(Ok)               \
    XX(Error)            \
    XX(Timeout)

enum class Status {
#define GENERATE_ENUM(name) name,
    STATUS_ENUM(GENERATE_ENUM)
#undef GENERATE_ENUM
};

inline const char* to_string(Status s) {
    switch(s) {
#define GENERATE_CASE(name) case Status::name: return #name;
        STATUS_ENUM(GENERATE_CASE)
#undef GENERATE_CASE
        default: return "Unknown";
    }
}

Теперь достаточно один раз задать список значений — и не нужно вручную синхронизировать enum и to_string().

✅ Такой подход легко масштабируется.
✅ Удобно для логирования, отладки и сериализации.

Пользуйтесь!

➡️ @cpp_geek

1.8K views05:39

C++ geek

🧠 Как static в C++ помогает бороться с неожиданностями

Сейчас покажу вам интересную особенность ключевого слова static в контексте функций — то, что часто забывают даже опытные разработчики.

Представим простую ситуацию:


void logCall() {
    int counter = 0;
    counter++;
    std::cout << "Called " << counter << " times\n";
}

Кажется, всё хорошо… Но функция всегда выводит Called 1 times, потому что переменная counter создаётся заново при каждом вызове.

Теперь добавим static:


void logCall() {
    static int counter = 0;
    counter++;
    std::cout << "Called " << counter << " times\n";
}

А вот теперь магия — переменная counter сохраняет своё значение между вызовами! Это отличный способ реализовать простой счётчик, кэш или ленивую инициализацию прямо в функции.

📌 Важно: static делает переменную локальной по области видимости, но глобальной по времени жизни.

А вы где применяли static неожиданным образом? Делитесь в комментариях! 👇

➡️ @cpp_geek

1.5K views21:25

C++ geek

🔥 Сегодня я расскажу про одно коварное поведение std::vector, которое часто становится причиной багов и утечек.

📌 Проблема: Удаление элементов в цикле

Многие делают так:


std::vector<int> v = {1, 2, 3, 4, 5};

for (size_t i = 0; i < v.size(); ++i) {
    if (v[i] % 2 == 0) {
        v.erase(v.begin() + i);
    }
}

Но это ошибка! После erase вектор сдвигает все элементы, и индекс i указывает уже не на тот элемент. В результате часть значений пропускается.

✅ Правильный способ — использовать итераторы:


auto it = v.begin();
while (it != v.end()) {
    if (*it % 2 == 0)
        it = v.erase(it);
    else
        ++it;
}

Так вы не теряете элементы и не получаете неопределённое поведение.

🧠 Советы:
- Всегда помните, что erase инвалидирует итераторы и индексы.
- Если хотите удалять по условию — лучше использовать std::remove_if + erase.


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

➡️ @cpp_geek

1.5K views15:41

C++ geek

🚀 Подборка Telegram каналов для программистов

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

https://www.tgoop.com/bash_srv Bash Советы
https://www.tgoop.com/win_sysadmin Системный Администратор Windows
https://www.tgoop.com/sysadmin_girl Девочка Сисадмин
https://www.tgoop.com/srv_admin_linux Админские угодья
https://www.tgoop.com/linux_srv Типичный Сисадмин
https://www.tgoop.com/devopslib Библиотека девопса | DevOps, SRE, Sysadmin
https://www.tgoop.com/linux_odmin Linux: Системный администратор
https://www.tgoop.com/devops_star DevOps Star (Звезда Девопса)
https://www.tgoop.com/i_linux Системный администратор
https://www.tgoop.com/linuxchmod Linux
https://www.tgoop.com/sys_adminos Системный Администратор
https://www.tgoop.com/tipsysdmin Типичный Сисадмин (фото железа, было/стало)
https://www.tgoop.com/sysadminof Книги для админов, полезные материалы
https://www.tgoop.com/i_odmin Все для системного администратора
https://www.tgoop.com/i_odmin_book Библиотека Системного Администратора
https://www.tgoop.com/i_odmin_chat Чат системных администраторов
https://www.tgoop.com/i_DevOps DevOps: Пишем о Docker, Kubernetes и др.
https://www.tgoop.com/sysadminoff Новости Линукс Linux

1C разработка 📌
https://www.tgoop.com/odin1C_rus Cтатьи, курсы, советы, шаблоны кода 1С
https://www.tgoop.com/DevLab1C 1С:Предприятие 8
https://www.tgoop.com/razrab_1C 1C Разработчик
https://www.tgoop.com/buh1C_prog 1C Программист | Бухгалтерия и Учёт
https://www.tgoop.com/rabota1C_rus Вакансии для программистов 1С

Программирование C++📌
https://www.tgoop.com/cpp_lib Библиотека C/C++ разработчика
https://www.tgoop.com/cpp_knigi Книги для программистов C/C++
https://www.tgoop.com/cpp_geek Учим C/C++ на примерах

Программирование Python 📌
https://www.tgoop.com/pythonofff Python академия.
https://www.tgoop.com/BookPython Библиотека Python разработчика
https://www.tgoop.com/python_real Python подборки на русском и английском
https://www.tgoop.com/python_360 Книги по Python

Java разработка 📌
https://www.tgoop.com/BookJava Библиотека Java разработчика
https://www.tgoop.com/java_360 Книги по Java Rus
https://www.tgoop.com/java_geek Учим Java на примерах

GitHub Сообщество 📌
https://www.tgoop.com/Githublib Интересное из GitHub

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

Мобильная разработка: iOS, Android 📌
https://www.tgoop.com/developer_mobila Мобильная разработка
https://www.tgoop.com/kotlin_lib Подборки полезного материала по Kotlin

Фронтенд разработка 📌
https://www.tgoop.com/frontend_1 Подборки для frontend разработчиков
https://www.tgoop.com/frontend_sovet Frontend советы, примеры и практика!
https://www.tgoop.com/React_lib Подборки по React js и все что с ним связано

Разработка игр 📌
https://www.tgoop.com/game_devv Все о разработке игр

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

БигДата, машинное обучение 📌
https://www.tgoop.com/bigdata_1 Big Data, Machine Learning

Программирование 📌
https://www.tgoop.com/bookflow Лекции, видеоуроки, доклады с IT конференций
https://www.tgoop.com/rust_lib Полезный контент по программированию на Rust
https://www.tgoop.com/golang_lib Библиотека Go (Golang) разработчика
https://www.tgoop.com/itmozg Программисты, дизайнеры, новости из мира IT
https://www.tgoop.com/php_lib Библиотека PHP программиста 👨🏼‍💻👩‍💻
https://www.tgoop.com/nodejs_lib Подборки по Node js и все что с ним связано
https://www.tgoop.com/ruby_lib Библиотека Ruby программиста
https://www.tgoop.com/lifeproger Жизнь программиста. Авторский канал.

QA, тестирование 📌
https://www.tgoop.com/testlab_qa Библиотека тестировщика

Шутки программистов 📌
https://www.tgoop.com/itumor Шутки программистов

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

Книги, статьи для дизайнеров 📌
https://www.tgoop.com/ux_web Статьи, книги для дизайнеров

Математика 📌
https://www.tgoop.com/Pomatematike Канал по математике
https://www.tgoop.com/phis_mat Обучающие видео, книги по Физике и Математике
https://www.tgoop.com/matgeoru Математика | Геометрия | Логика

Excel лайфхак📌
https://www.tgoop.com/Excel_lifehack

https://www.tgoop.com/mir_teh Мир технологий (Technology World)

Вакансии 📌
https://www.tgoop.com/sysadmin_rabota Системный Администратор
https://www.tgoop.com/progjob Вакансии в IT

Bash Советы

🚀 Секреты и советы по Bash

🔹 Полезные трюки, хитрые однострочники и лайфхаки для работы в терминале.
🔹 Автоматизация, скрипты и оптимизация работы в Linux.
🔹 Стать мастером Bash легко – просто подпишись!

💻 Прокачивай терминал вместе с нами! 👇

1.6K views06:06

C++ geek

Сегодня хочу показать вам один из приёмов, который часто выручает в реальной разработке на C++ — оборачивание C API в безопасные RAII-объекты.

Многие библиотеки на C (например, OpenSSL, SQLite, libpng) требуют вручную управлять ресурсами — открывать, закрывать, аллоцировать и освобождать. Это источник ошибок: забыли free(), упустили close(), получили утечку памяти или файлового дескриптора.

В C++ мы можем обернуть такие ресурсы в класс с аккуратным деструктором:


class FileHandle {
public:
    explicit FileHandle(FILE* file) : file_(file) {}
    ~FileHandle() {
        if (file_) {
            fclose(file_);
        }
    }

    FILE* get() const { return file_; }

private:
    FILE* file_;
};

Теперь, даже если функция выбросит исключение или произойдет выход из области видимости, файл закроется автоматически!

Такие классы легко комбинировать с std::unique_ptr через кастомные делетеры для ещё большей безопасности.

Не забывайте: RAII (Resource Acquisition Is Initialization) — один из важнейших паттернов для профессионального C++.

➡️ @cpp_geek

1.7K views09:40

C++ geek

🧵 Сегодня покажу вам простой, но полезный приём для оптимизации копирования std::vector.

Часто вижу такую конструкцию:


std::vector<int> result;
result = getVector();

Если getVector() возвращает временный объект, то копирование можно избежать, используя std::move или Return Value Optimization (RVO).

Но вот интересное: если вы точно знаете, что копия не нужна, используйте std::vector::swap с временным объектом:


std::vector<int> result;
std::vector<int> tmp = getVector();
result.swap(tmp);

Почему это может быть лучше?
🔸 Быстрая реализация через указатели.
🔸 Не вызывает лишние аллокаторы.
🔸 Не зависит от move конструктора.
🔸 Гарантированно не бросает исключений, если swap noexcept (что обычно так).

В новых компиляторах result = std::move(tmp) даст тот же эффект, но swap — это старый добрый способ, который работает предсказуемо.

🧠 Подумайте, где можно применить это у себя — особенно если работаете с большими контейнерами.

➡️ @cpp_geek

1.4K views13:10

C++ geek

📌 Сегодня расскажу вам о проблеме, которую часто упускают: небезопасный доступ к 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

1.4K views05:11

C++ geek

Bash Советы

1.3K views10:17

C++ 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

1.4K views15:23

C++ geek

Почему std::move может не сработать, как ты ожидал

Всё просто? Хочешь передать объект по move — вызываешь std::move(obj) и думаешь, что теперь точно будет перемещение. Но не всё так однозначно.


void foo(std::string s) {
    std::string local = std::move(s);
}

Выглядит, будто s перемещается в local. Но на практике — нет. Здесь копирование. Почему?

s — это lvalue, несмотря на std::move в правой части. А значит, выбирается std::string конструктор копирования, если только он не удалён.

Чтобы реально переместить, нужно явно вызвать std::move:


std::string local = std::move(s); // ОК — move-конструктор

Но будь осторожен:


std::string getStr() {
    std::string tmp = "hello";
    return std::move(tmp); // ❌ Не всегда нужно!
}

Здесь std::move ломает RVO (Return Value Optimization). Компилятор мог бы вернуть tmp без перемещения, вообще без копий. А std::move мешает, заставляя делать move-конструктор.

Выводы:
– std::move не двигает, он обещает, что ты больше не тронешь объект
– Будь осторожен с std::move в return
– Не забудь, что lvalue остаётся lvalue, даже если ты его "обернул" std::move

➡️ @cpp_geek

1.2K views09:46

C++ 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

1.1K views06:12

C++ 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

1.0K views21:50

C++ geek

✅ Чек-лист: Линейные структуры данных в 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

919 views05:49

C++ 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

745 views08:56

C++ 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

546 viewsedited 06:13

C++ geek

Please open Telegram to view this post

VIEW IN TELEGRAM

455 views08:04

C++ 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

525 views10:05

C++ geek

🚀 Открой для себя идеальный путь к лидерству с карьерным тестом от ОЭЗ «Алабуга»! 🌟

Мечтаете о карьере в крупной компании, где ваш потенциал раскроется на полную? Наш тест поможет вам определить вашу уникальную лидерскую роль. Может быть, именно вы станете тем лидером, который выведет команду на новый уровень?

После прохождения теста вы можете заполнить заявку и получить приглашение на эксклюзивную лидерскую программу. Участие в программе открывает реальные перспективы трудоустройства в ОЭЗ «Алабуга», предоставляя шанс начать путь к профессиональному признанию.

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

450 views07:02

C++ geek

Тема: 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

437 views09:04

2025/05/31 02:27:46
Back to Top

HTML Embed Code:

<iframe width="100%" src="https://www.tgoop.com/buyppe/web?embed=1" title="Telegram Web" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>