std::async

В C++ std::async — это шаблон функции, предоставляемый стандартной библиотекой. Он используется для асинхронного выполнения функции или вызываемого объекта и получения объекта future, представляющего результат вычислений.

Функция std::async создает новый поток или использует существующий поток из пула потоков реализации для выполнения поставленной задачи. Она возвращает объект std::future, который можно использовать для получения результата или статуса вычисления.

В этом примере функция AddNumbers выполняется асинхронно с использованием std::async. Она принимает два целых числа в качестве аргументов и возвращает их сумму. Функция std::async вызывается с помощью AddNumbers и аргументов 5 и 10.
Функция std::async возвращает объект std::future, который представляет собой результат вычисления. Вызывая функцию get() на объекте future, мы блокируем выполнение до завершения вычислений и получаем результат.

➡️ @cpp_geek

Есть ли преимущества одного фрагмента кода перед другим? Если да, то какие?

Хотя оба варианта выполняют одно и то же, второй вариант лучше с точки зрения производительности. Это связано с тем, что оператор постинкремента itr++ дороже, чем оператор предварительного инкремента ++itr. Базовая реализация оператора постинкремента создает копию элемента перед его увеличением, а затем возвращает копию.

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

➡️ @cpp_geek

PIMPL (Pointer to Implementation)

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

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

В данном примере пользователь класса MyObject не видит внутреннюю реализацию объекта, что позволяет добавлять/удалять поля без необходимости изменять интерфейс класса. Работа с внутренними данными осуществляется через методы класса Impl, которые вызываются в функциях-членах класса MyObject.

➡️ @cpp_geek

В чем проблема следующего фрагмента?

Из спецификации (C++11 §5.3.5/3):

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

➡️ @cpp_geek

Что за ошибка в приведенном ниже коде и как ее исправить?

Последним аргументом memset должен быть sizeof(*bar), а не sizeof(bar). sizeof(bar) вычисляет размер bar (то есть самого указателя), а не размер структуры, на которую указывает bar. Поэтому код можно исправить, используя sizeof(*bar) в качестве последнего аргумента вызова memset.

➡️ @cpp_geek

Сравниваем 2 строки на одинаковые буквы

Для сравнения двух строк на одинаковые буквы можно использовать стандартную функцию strcmp() из библиотеки.

В данном примере две строки "hello" и "holle" сравниваются на одинаковые буквы. Функция strcmp() возвращает 0, если строки совпадают, и любое другое число, если строки не совпадают. Если строки содержат одинаковые буквы, выводится сообщение "Строки содержат одинаковые буквы", иначе - "Строки содержат разные буквы".

➡️ @cpp_geek

Узнаем сколько лет человеку по дате его рождения

В этом коде мы запрашиваем у пользователя его дату рождения, а затем получаем текущую дату с помощью функции time. Затем мы используем структуру tm для извлечения года, месяца и дня из текущей даты и вычисляем количество полных лет с помощью формулы now->tm_year + 1900 - year. Если текущий месяц и день меньше, чем месяц и день рождения, мы уменьшаем возраст на 1. Наконец, мы выводим результат на экран.

➡️ @cpp_geek

Что такое rvalue, lvalue?

lvalue — это всё, что имеет имя, rvalue — это то, что имени не имеет. Исторически сложились такие названия, потому что lvalue всегда было то, что писалось с левой стороны присваивающего выражения, а rvalue — это то, что появлялось только справа от этого выражения.

➡️ @cpp_geek

std::sort

std::sort — это функция стандартной библиотеки для сортировки элементов в контейнерах, таких как вектор или список.
Чтобы использовать std::sort, нужно подключить заголовочный файл .

Метод принимает в качестве аргументов итераторы на начало и конец сортируемой последовательности и сортирует элементы в возрастающем порядке по умолчанию.

Для определения порядка сортировки можно указать свой компаратор.

➡️ @cpp_geek

Что такое std::sample?

std::sample — алгоритм который позволяет брать случайный элемент из диапазона. Был введён в C++ 17.

Описание его функциональности:

1. Выбирает n уникальных элементов случайным образом из входного диапазона
2. Копирует выбранные элементы в выходной диапазон
3. Сохраняет относительный порядок выбранных элементов

Синтаксис:

std::sample(input_begin, input_end, output_begin, n, generator);

- input_begin и input_end — итераторы входного диапазона
- output_begin — итератор выходного диапазона
- n — количество элементов для выборки
- generator — генератор случайных чисел

➡️ @cpp_geek

std::variant

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

Шаблонный класс std::variant похож на упрощенную версию union, но с дополнительной безопасностью типов и поддержкой различных операций.

Основными функциями std::variant являются index(), valueless_by_exception(), operator=, emplace.

В этом примере мы создаем объект var, который может содержать значения типов int, float или std::string. Мы присваиваем var различные значения и получаем их с помощью std::get.

Однако, если мы попытаемся получить значение, используя неправильный тип (например, std::get(var), когда вариант содержит std::string, это вызовет исключение std::bad_variant_access.

➡️ @cpp_geek

Использование выражений сгиба

С C++17 мы можем использовать складывать выражения для объединения последовательности std::arrays, это элегантное и эффективное решение продемонстрировано выше.

➡️ @cpp_geek

SIMD (Single Instruction Multiple Data)

Это технология, позволяющая одновременно выполнять одну и ту же операцию над несколькими наборами данных. В современных процессорах SIMD-инструкции реализованы для ускорения работы с векторными операциями. В C++ SIMD-инструкции доступны через библиотеку immintrin.h.

В данном примере функция addVectors принимает на вход указатели на три массива a, b и c, каждый из которых содержит 8 элементов типа float. С помощью функции _mm256_loadu_ps происходит загрузка первого и второго векторов в регистры, затем с помощью функции _mm256_add_ps происходит их покомпонентное сложение. Результат сохраняется в третий вектор с помощью функции _mm256_storeu_ps.

➡️ @cpp_geek

Напишите базовую реализацию std::shared_ptr

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

➡️ @cpp_geek

Бинарный поиск

Чаще всего бинарный поиск (бинпоиск) используют, чтобы найти элемент в отсортированном массиве. Мы начинаем искать с середины массива. Если находим то, что нужно, или если больше нечего рассматривать, мы останавливаемся.

В противном случае мы решаем, в каком направлении — вправо или влево от середины — мы должны продолжить поиск. Так как пространство поиска после каждой проверки делится на два, то время выполнения алгоритма — O(log n).

Код выводит следующее:

бинарный поиск: нашли по индексу 4

Если искомый элемент не найден, но мы хотим найти ближайший элемент меньше или больше запроса, то можно использовать функции STL lower_bound() и upper_bound().

➡️ @cpp_geek

📌 Оптимизация кода с std::optional в C++

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

💡 Зачем нужен std::optional?
Обычно, если функция не может вернуть корректное значение, приходится использовать:
✔ Возвращаемое значение с ошибочным кодом (неудобно, особенно если 0 или -1 могут быть валидными).
✔ Выброс исключения (дорого по ресурсам).
✔ Указатели (nullptr, но требует дополнительных проверок).

🔥 Альтернатива? Используем std::optional!

#include <iostream>
#include <optional>
#include <string>

std::optional<std::string> findUser(int id) {
    if (id == 42) return "John Doe";
    return std::nullopt;
}

int main() {
    auto user = findUser(42);
    
    if (user) {
        std::cout << "User found: " << *user << std::endl;
    } else {
        std::cout << "User not found!" << std::endl;
    }
}

✅ Код стал чище: нет лишних проверок nullptr, исключений или специальных значений.

🎯 Когда использовать?
🔹 Когда функция может вернуть "ничего", но исключения и специальные значения не подходят.
🔹 Для более понятного API (например, парсинг строки в число).
🔹 Когда важно избежать неопределенного состояния (например, с переменной внутри класса).

А ты уже используешь std::optional в своем коде? Делись опытом в комментариях! ⬇🔍

➡️ @cpp_geek

Какие есть особенности статических полей класса в языке С++?

Статические поля класса в C++ имеют несколько особенностей:
1. Общий доступ: статические поля являются общими для всех объектов этого класса. Это означает, что изменение значения статического поля в одном объекте, изменяет его для всех объектов этого класса.
2. Инициализация: статические поля инициализируются только один раз, когда программа запускается. Значения статических полей сохраняются на протяжении всего времени работы программы.
3. Доступ: доступ к статическим полям класса возможен без создания объекта этого класса, например, используя имя класса и оператор :: .
4. Память: статические поля класса хранятся не в куче или стеке, а в статической области памяти, что позволяет им занимать память только один раз, независимо от количества созданных объектов класса.


➡️ @cpp_geek

🚀 Оптимизация циклов в C++: маленькие хитрости для больших скоростей

Сегодня поговорим об оптимизации циклов в C++. Даже если ваш код работает, это не значит, что он работает быстро. Давайте разберём несколько трюков, которые помогут выжать максимум из циклов.



🔥 1. Избегайте ненужных вычислений внутри цикла
❌ Плохо:

for (int i = 0; i < vec.size(); i++) {  
    process(vec[i]);  
}

✅ Хорошо:

size_t size = vec.size();
for (size_t i = 0; i < size; i++) {  
    process(vec[i]);  
}

Почему? vec.size() может вызываться при каждой итерации, что может замедлить выполнение, особенно если это не std::vector, а другой контейнер.



⚡ 2. Используйте reserve() для вектора
Если вы заранее знаете, сколько элементов добавите в std::vector, вызовите reserve(). Это сократит количество реаллокаций памяти.

std::vector<int> vec;
vec.reserve(1000); // резервируем место для 1000 элементов
for (int i = 0; i < 1000; i++) {
    vec.push_back(i);
}

🏎️ 3. Предпочитайте range-based for
Классический цикл for:

for (size_t i = 0; i < vec.size(); i++) {  
    process(vec[i]);  
}

Современный range-based for:

for (const auto& elem : vec) {  
    process(elem);  
}

Плюсы:
✅ Улучшает читаемость
✅ Избегает ненужных индексаций
✅ Позволяет компилятору оптимизировать код



🔄 4. std::transform вместо for
Если вы преобразуете данные из одного контейнера в другой, используйте std::transform:

std::vector<int> src = {1, 2, 3, 4, 5};
std::vector<int> dst(src.size());

std::transform(src.begin(), src.end(), dst.begin(), [](int x) { return x * 2; });

Зачем?
✔️ Работает быстрее за счёт оптимизаций
✔️ Код становится короче и читабельнее


🎯 Вывод
Оптимизация циклов — это не магия, а грамотное использование возможностей C++. Убирайте лишние вычисления, используйте reserve(), применяйте range-based for и std::transform, и ваш код станет быстрее и элегантнее.

Используете ли вы std::transform в своём коде? Делитесь в комментариях! 👇

➡️ @cpp_geek

📌 Оптимизация работы со строками в C++: std::string_view vs std::string

Привет, друзья! Сегодня хочу обсудить одну из самых частых проблем в C++ – работу со строками. А именно, почему std::string_view – это мощный инструмент, который может значительно ускорить ваш код.

❌ Проблема: Копирование строк
Допустим, у вас есть функция, которая принимает строку:

void process(std::string s) {
    // работа со строкой
}

Каждый раз, когда вызывается эта функция, создаётся новая копия строки. Если строка длинная, это дорого по времени и памяти.

✅ Решение: Используем std::string_view
С std::string_view можно избежать лишнего копирования:

void process(std::string_view s) {
    // работа со строкой без копирования
}

Теперь s – это просто представление строки, а не её копия. Вы можете передавать как std::string, так и char*, что делает API более гибким.

🚀 Преимущества std::string_view:
✔ Не создает копий – работает быстрее.
✔ Поддерживает стандартные операции (substr, find и т. д.).
✔ Работает с std::string, char*, массивами символов.
✔ Идеально подходит для парсинга и работы с текстом.

🔥 Важно помнить:
- std::string_view не управляет памятью, так что будьте осторожны с временными строками.
- Если строка-источник уничтожена, std::string_view станет невалидным.

Пример неверного использования:

std::string_view bad() {
    std::string s = "Hello";
    return s; // ⚠ UB, строка уничтожена!
}

➡️ @cpp_geek

⚡ std::span — мощная альтернатива std::vector и std::array

Сегодня поговорим о std::span — контейнере, который делает работу с массивами и векторами в C++ более удобной и эффективной. 🚀

❌ Проблема: Лишние копии данных
Представьте, что у нас есть функция, принимающая массив чисел:

void processArray(const std::vector<int>& arr) {
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
}

С одной стороны, передача const std::vector<int>& предотвращает копирование, но что, если у нас массив std::array или сырой int[]?
Придётся перегружать функцию или копировать данные в std::vector.

✅ Решение: Используем std::span
std::span позволяет передавать любой диапазон (`std::vector`, std::array, сырые массивы) без копирования:

#include <iostream>
#include <span>
#include <vector>
#include <array>

void processArray(std::span<int> arr) {
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
}

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::array<int, 5> arr = {6, 7, 8, 9, 10};
    int rawArr[] = {11, 12, 13, 14, 15};

    processArray(vec);      // ✅ Работает
    processArray(arr);      // ✅ Работает
    processArray(rawArr);   // ✅ Работает
}

🚀 Преимущества std::span
✅ Не копирует данные — передаётся как ссылка
✅ Работает с любыми последовательностями
✅ Гибкость — можно создавать срезы без копий

Пример использования .subspan(), чтобы передавать часть массива:

std::vector<int> vec = {1, 2, 3, 4, 5};
std::span<int> sp = vec;
processArray(sp.subspan(2)); // Выведет: 3 4 5

⚠️ Важно
- std::span не владеет данными. Убедитесь, что исходные данные живут дольше span.
- Не поддерживает автоматическое изменение размера, как std::vector.

📌 Итог
Если ваша функция принимает std::vector<int>&, std::array<int, N>&, int[] или даже std::initializer_list<int>, замените их на std::span<int>! Это сделает код более гибким и эффективным. 🔥

➡️ @cpp_geek