🍿 Что скрывает auto(x): новый синтаксис C++23

В C++23 появился синтаксис auto(x) и auto{x}. Это не очередной сахар для объявления переменных. На самом деле — это именованная операция, у которой есть точная семантика.


🥳 Что происходит под капотом:

auto(x) — это decay-copy: создаётся prvalue того же типа, что и x, но после применения std::decay. То есть:

• Ссылки снимаются
• Cv-квалификаторы (const/volatile) удаляются
• Массивы → указатели
• Функции → указатели на функции

const int& r = 42;
auto copy = auto(r); // int, не const int&

⚡️ До C++23 для того же результата писали:

auto copy = std::decay_t<decltype(r)>(r);

❓ Зачем нужна явность?

В простых случаях auto copy = r тоже даст int — auto и так делает decay. Но в обобщённом коде важно явно сигнализировать намерение: "я хочу копию, а не прокси или view".

Главное применение — защита от UB при модификации контейнера. Классический пример — реализация pop_front:

void pop_front(auto& container) {
    std::erase(container, auto(container.front()));
    // Без auto() — UB: front() может инвалидироваться
    // в процессе удаления элементов
}

Без auto() мы передаём ссылку на элемент, который erase может разрушить до сравнения. С auto() — сначала создаётся копия значения, потом происходит удаление. Безопасно и читаемо.

❗️ auto(x) закрывает целый класс subtle-багов в шаблонном коде — там, где случайная ссылка вместо копии приводит к UB или неожиданному поведению.


📍Навигация: Вакансии • Задачи • Собесы

Библиотека C/C++ разработчика

#константная_правильность

🔪 Разбиение диапазонов: views::split, chunk, chunk_by

Ranges-библиотека умеет не только фильтровать и трансформировать, но и разбивать диапазоны на части. Разберём три инструмента — каждый для своей задачи.


🍴 views::split — разбивка по разделителю

std::string csv = "один,два,три,четыре";

// Разбиваем по запятой
for (auto part : csv | views::split(',')) {
    // part — под-диапазон символов, не строка
    // В C++20 явно конструируем string:
    std::cout << std::string(part.begin(), part.end()) << "\n";
}
// один
// два
// три
// четыре

В C++23 появился std::ranges::to, и конвертация стала лаконичнее:

for (auto part : csv | split(',')) {
    std::cout << std::ranges::to<std::string>(part) << "\n";
}

❗️views::split возвращает под-диапазоны, а не строки — явное преобразование обязательно в обоих стандартах.


🥨 views::chunk(n) — разбивка на блоки фиксированного размера (C++23)

std::vector<int> data = {1, 2, 3, 4, 5, 6, 7};
for (auto chunk : data | views::chunk(3)) {
    for (int x : chunk) std::cout << x << " ";
    std::cout << "\n";
} /
/ 1 2 3
// 4 5 6
// 7

❗️ Если размер диапазона не делится на n нацело — последний блок содержит оставшиеся элементы.



🍪 views::chunk_by — разбивка по условию (C++23)

Группирует соседние элементы, пока выполняется предикат между двумя соседями.

std::vector<int> v = {1, 1, 2, 3, 3, 3, 4, 4};
// Группируем подряд идущие равные элементы
for (auto group : v | views::chunk_by(std::equal_to{})) {
    for (int x : group) std::cout << x << " ";
    std::cout << "| ";
} /
/ 1 1 | 2 | 3 3 3 | 4 4 |

// Вариант с std::equal_to<>{} — лаконичнее:
for (auto group : v | chunk_by(std::equal_to<>{})) { ... }

❗️ Предикат принимает два соседних элемента — новая группа начинается там, где он вернул false.


📍Навигация: Вакансии • Задачи • Собесы

Библиотека C/C++ разработчика

#константная_правильность

🍋 Just My Code в Visual Studio

По умолчанию, когда вы нажимаете F11 (Step Into) в Visual Studio, отладчик проваливается в каждую функцию — включая стандартную библиотеку, runtime и сторонний код?

Функция Just My Code решает эту проблему. При включении отладчик автоматически перешагивает через код, который не принадлежит вашему проекту — будь то STL, CRT или любые внешние библиотеки.


🍀 Включить просто:

Tools → Options → Debugging → General → Enable Just My Code

🍬 Пример:

#include <vector>
#include <algorithm>
#include <iostream>

int doubleValue(int x) {
    return x * 2;  // ← ВАШ код
}

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

    // F11 здесь без JMC → провалится в std::sort
    std::sort(v.begin(), v.end());

    // F11 здесь без JMC → провалится в std::transform
    std::transform(v.begin(), v.end(), v.begin(), doubleValue);

    return 0;
}

Без JMC: F11 на std::sort уводит вас в дебри introsort внутри STL.
С JMC: отладчик перепрыгивает sort и останавливается на следующей вашей строке.


📍Навигация: Вакансии • Задачи • Собесы

Библиотека C/C++ разработчика

#буст

🥳 Генераторы: views::iota и views::repeat

Ranges умеют генерировать их на лету — без выделения памяти под вектор. Разберём два главных генератора.


🍕 views::iota — числовой диапазон

Генерирует последовательность чисел в полуоткрытом интервале [start, end):

// Числа от 0 до 9
for (int i : views::iota(0, 10)) {
    std::cout << i << " "; // 0 1 2 3 4 5 6 7 8 9
} 

Можно передать только одно значение — получится бесконечная последовательность:

auto naturals = views::iota(1); // 1, 2, 3, 4, ...
auto first_10 = naturals | views::take(10);

❗️ Бесконечный диапазон обязательно нужно ограничить — например, через views::take.


🌳 Индексированный обход (zip + iota)

До появления views::enumerate пару (индекс, значение) получали через views::zip с iota:

std::vector<std::string> fruits = {"яблоко", "банан", "вишня"};

for (auto [i, fruit] : views::zip(views::iota(0), fruits)) {
    std::cout << i << ": " << fruit << "\n";
}
// 0: яблоко
// 1: банан
// 2: вишня

В C++23 для этого есть views::enumerate — но zip + iota по-прежнему работает и даёт понять, как устроена индексация изнутри.


🍙 views::repeat — повторение значения (C++23)

Генерирует бесконечный поток из одного и того же значения:

for (int x : views::repeat(0) | views::take(5)) {
    std::cout << x << " "; // 0 0 0 0 0
}

Или сразу с ограничением — передаём второй аргумент:

for (auto s : views::repeat("hello", 3)) {
    std::cout << s << " "; // hello hello hello
}

❗️ Форма с двумя аргументами появилась в C++23 и возвращает конечный диапазон — views::take не нужен.


📍Навигация: Вакансии • Задачи • Собесы

Библиотека C/C++ разработчика

#константная_правильность