🥳 errno: привет из 1970-х

Прежде чем хвалить C++23, разберёмся с тем, что встречается в каждом проекте. errno — индикатор ошибки из мира C, и его всё ещё использует унаследованная C-часть стандартной библиотеки (<cmath>, семейство strto*, часть C-I/O).

❌ Главная ловушка: errno не сбрасывается при успехе. Проверять его «после» наугад бессмысленно — нужно обнулить до вызова.

#include <cerrno>
#include <cstdlib>

errno = 0;                            // 1. сбросить
char* end = nullptr;
long v = std::strtol(str, &end, 10);
if (errno == ERANGE) return overflow();  // 2. проверить переполнение
if (end == str)      return empty();     // 3. ничего не распарсилось
if (*end != '\0')    return trailing();   // 4. мусор в хвосте: "123abc"

🩹 Типичные ошибки:
• забыли errno = 0 перед вызовом
• смотрят только на результат, игнорируя ERANGE
• думают, что errno общий на все потоки (с C++11 он thread-local)


💡 Превратить код в текст: std::strerror(errno).

❗️ В работе с C API errno неизбежен, но в своём коде его стоит сразу заворачивать в std::error_code.


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

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

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

😮 Проекции и функции-члены

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


🥤 Указатель на метод как проекция

std::vector<std::string> words = {"hello", "WORLD", "cpp"};

// Сортируем по длине строки
std::ranges::sort(words, std::less{}, &std::string::size);
// "cpp"(3), "hello"(5), "WORLD"(5)

Механика та же, что и с полями: std::invoke разворачивает &std::string::size в вызов s.size() для каждого элемента. Алгоритму без разницы, поле перед ним или метод — лишь бы было что вызвать.

‼️ Заметьте: "hello" и "WORLD" оба длины 5, и после сортировки остались в исходном порядке относительно друг друга — std::ranges::sort в общем случае не гарантирует стабильность (в отличие от stable_sort), но для проекций это работает точно так же, как для обычного сравнения.


🥑 Метод как предикат

bool all_nonempty = std::ranges::all_of(words, &std::string::size);

Тут проекция подменяет собой ещё и предикат: all_of без явного предиката просто проверяет результат проекции на истинность. size() возвращает size_t, но он неявно приводится к bool — ноль означает пустую строку. Удобно, когда не хочется писать [](const auto& s){ return !s.empty(); }.


🍒 Лямбда — тоже проекция

Всё, что вызывается с одним аргументом и возвращает ключ для сравнения, годится в качестве проекции — в том числе лямбда:

struct Product {
    std::string name;
    double price;
    int stock;
};

std::vector<Product> products = { /* ... */ };

// Самый дешёвый товар в наличии
auto it = std::ranges::min_element(
    products | std::views::filter([](const Product& p) { return p.stock > 0; }),
    std::less{},
    &Product::price
);

Здесь лямбда стоит на своём привычном месте — предикатом для filter, а проекция по-прежнему &Product::price. Три инструмента, три роли: предикат отбирает элементы, проекция выбирает ключ, компаратор задаёт порядок сравнения этого ключа.

‼️ Если бы понадобилась проекция посложнее одного поля — скажем, «цена с учётом скидки» — туда точно так же встала бы лямбда: [](const Product& p) { return p.price * (1 - p.discount); }. Указатель на поле — просто частный случай вызываемого объекта, самый короткий из возможных.


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

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

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

🥤 constexpr добрался до виртуального наследования

C++26 снимает один из последних синтаксических запретов на constexpr — виртуальное наследование. Sandor Dargo разбирает пейпер P3533R2 Ханы Дусиковой.

• Раньше класс с виртуальными базами нельзя было даже сконструировать при константных вычислениях. Constexpr-конструкторы и деструкторы запрещались на уровне синтаксиса

• P3533R2 убирает запрет целиком. Ромбовидное наследование с виртуальной базой теперь работает на этапе компиляции: constexpr auto ch = Child{} компилируется, оба пути ведут к одному субобъекту

• Мотивация практическая: basic_ios виртуально наследует ios_base. Без этого невозможны constexpr-потоки, форматирование потоков и исключения chrono на этапе компиляции

• Понятие constexpr-suitable становится тавтологией и уходит из стандарта. Синтаксических ограничений не остаётся — только правила вычислимости из [expr.const]

• Реализовать в clang несложно: поиск самого внешнего объекта уже есть для виртуальных вызовов, остаётся расширить APValue


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

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

#свежак

🧋 Во что обходится безопасность памяти в Rust

Rust проверяет доступ к памяти на этапе выполнения. Исследование на Rust 1.87 показало реальную цену.

• Проверки индексов: 80% циклов не оптимизируются. Оверхед 1–11% в зависимости от кода
• Обязательная инициализация добавляет лишние store-операции. В некоторых случаях +10% накладных расходов. Для буферов есть MaybeUninit
• Правила алиасинга работают на оптимизацию: +1–2% производительности. В C это restrict, который редко используют
• Итераторы и реслайсинг эффективнее сложной индексной арифметики. Проверка происходит один раз вместо каждой итерации

🍕 Результат: Rust генерирует код эквивалентный C, но проверки добавляют оверхеда. Цена за отсутствие UB.


🚀 Доклад

Приемлемо ли это для исключения целого класса уязвимостей? ⤵️


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

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

#свежак

🧦 Итераторы: фундамент диапазонов

Прежде чем строить проекции и алгоритмы поверх диапазонов, стоит вспомнить, на чём диапазон стоит. А стоит он на итераторе — объекте, который умеет всего три вещи: разыменовываться (*it), двигаться вперёд (++it) и сравниваться с концом. Всё остальное — надстройки.


🍟 Итератор без контейнера

Итератору не обязательно указывать в память — он может генерировать значения на лету. Напишем итератор, выдающий числа Фибоначчи:

struct FibIterator {
    using value_type        = long long;
    using difference_type   = std::ptrdiff_t;
    using iterator_category = std::input_iterator_tag;

    long long a = 0, b = 1;
    int count = 0;
    int max_count;

    FibIterator(int n) : max_count(n) {}
    FibIterator() : max_count(-1) {} // sentinel (конец)

    long long operator*() const { return a; }

    FibIterator& operator++() {
        auto next = a + b;
        a = b;
        b = next;
        ++count;
        return *this;
    }

    FibIterator operator++(int) {
        auto tmp = *this;
        ++(*this);
        return tmp;
    }

    bool operator==(const FibIterator& other) const {
        if (other.max_count == -1) return count >= max_count;
        return count == other.count;
    }
};

Никакого массива за спиной нет: текущее состояние — пара a, b — живёт прямо в итераторе, а operator++ вычисляет следующее число. Разыменование лишь возвращает уже готовое значение, поэтому оно const и дешёвое.


🍔 Сентинел: конец, который не элемент

Обратите внимание на operator==: итератор, созданный по умолчанию, играет роль сентинела — маркера конца. Он не хранит «последнее число Фибоначчи» (его и не существует), а просто отвечает на вопрос «мы уже нагенерировали max_count элементов?».

Это ключевая идея ranges: end() не обязан быть «настоящим» итератором, указывающим за последний элемент. Ему достаточно уметь сравниваться с begin(). Здесь сентинел того же типа, что и итератор, — но в C++20 это может быть и отдельный тип (как std::unreachable_sentinel для бесконечных последовательностей).

‼️ Заметьте: operator!= мы не писали — начиная с C++20 компилятор сам выведет его из operator==. Одной перегрузкой меньше.


🍒 Диапазон — это просто begin() + end()

struct FibRange {
    int n;

    FibIterator begin() const { return FibIterator{n}; }
    FibIterator end()   const { return FibIterator{};  }
};

for (long long f : FibRange{10}) {
    std::cout << f << " "; // 0 1 1 2 3 5 8 13 21 34
}

Всё, что нужно range-based for и алгоритмам из std::ranges, — пара методов begin()/end(). Никакого наследования, никаких базовых классов: диапазон — это концепт, а не иерархия. Наш FibRange весит один int и генерирует значения лениво — ровно тот же принцип, на котором построены std::views::iota, filter и остальные адаптеры.

‼️ Тег input_iterator_tag здесь честный: пройти последовательность можно только один раз вперёд, ведь каждое разыменование опирается на накопленное состояние. Если бы мы хранили индекс и пересчитывали значение с нуля, можно было бы замахнуться и на forward_iterator — но для генератора это редко нужно.


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

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

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

🍙 Задача на выходные: бинарный поиск, который врал 20 лет

Этот баг жил в стандартной библиотеке Java почти десятилетие. Проверьте, найдёте ли вы его в C++-версии за 15 минут.

int binarySearch(const std::vector<int>& a, int key) {
    int low = 0;
    int high = static_cast<int>(a.size()) - 1;
    while (low <= high) {
        int mid = (low + high) / 2;
        if (a[mid] < key)      low = mid + 1;
        else if (a[mid] > key) high = mid - 1;
        else                   return mid;
    }
    return -1;
}

🚨 Задача: На каких входных данных функция сломается и почему? Как исправить одной строкой?


✏️ Кто вспомнит, в чём подвох, без гугла — тот настоящий сеньор. Ответы в комментариях ⤵️


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

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

#междусобойчик