Концепты вместо страшного SFINAE в C++ 20!

Раньше для ограничения шаблонов по типу приходилось писать SFINAE через std::enable_if и читать страшные сообщения компилятора. В C++20 появились concept и requires, которые позволяют описать те же ограничения гораздо проще и понятнее.

Сначала посмотрим на «старый» подход с std::enable_if, где функция должна работать только для целочисленных типов:

template<typename T>
std::enable_if_t<std::is_integral_v<T>, T>
sum(T a, T b) {
    return a + b;
}

int main() {
    auto x = sum(1, 2);       // ок
    auto y = sum(1.0, 2.0);   // ошибка компиляции с SFINAE
}

Здесь логика «только для целочисленных типов» зашита в возвращаемый тип, сигнатура читается тяжело, а сообщение компилятора при ошибке — длинное и мало что объясняет.

Теперь опишем концепт Integral, который явно говорит: тип должен быть целочисленным:

template<typename T>
concept Integral = std::is_integral_v<T>;

Используем этот концепт в сигнатуре функции через requires — ограничим шаблон только такими типами:

template<Integral T>
T sum(T a, T b) {
    return a + b;
}

И напишем простой main, где одна строка корректна, а другая ломает ограничение концепта:

int main() {
    auto x = sum(1, 2);       // ок, int — целочисленный тип
    auto y = sum(1.0, 2.0);   // ошибка: double не удовлетворяет Integral

    return 0;
}

🔥 Компилятор теперь выдаёт понятное сообщение: «ограничение Integral не выполняется для double», а сама сигнатура функции читается почти как обычный текст: шаблон sum работает только для целочисленных типов.

📣 C++ Ready | #практика

Как перестать писать first и second везде?

Классический код с std::pair и std::map обычно выглядит так:

for (const auto& p : scores) {
    std::cout << p.first << ": " << p.second << '\n';
}

first/second ничего не говорят о смысле данных, а при чтении кода приходится всё время держать в голове, где имя, а где значение.

С C++17 можно «распаковать» пару в говорящие имена с помощью structured bindings:

for (const auto& [name, score] : scores) {
    std::cout << name << ": " << score << '\n';
}

🔥 То же самое работает для std::pair, std::tuple и многих стандартных типов: можно аккуратно разобрать результат функции на несколько переменных с понятными именами.

📣 C++ Ready | #совет

Как перестать писать громоздкие циклы с индексами?

Классический вариант в C++ всё ещё часто выглядит так:

for (std::size_t i = 0; i < names.size(); ++i) {
    std::cout << names[i] << '\n';
}

Здесь куча лишнего шума: тип индекса, i < names.size(), доступ по names[i].
Легко ошибиться с границами (<= вместо <) или забыть обновить цикл, если контейнер поменялся.

С range-based for всё короче и безопаснее:

for (const auto& name : names) {
    std::cout << name << '\n';
}

Перебираем сразу элементы, а не индексы.
Тот же приём работает для std::vector, std::array, std::list, std::map и собственных контейнеров с begin()/end().

🔥 Используйте range-based for по умолчанию, а циклы с индексом оставляйте только там, где действительно нужен номер элемента.

📣 C++ Ready | #совет

Типобезопасные перечисления — enum class вместо старого enum!

Обычный enum неявно приводится к int и даёт сравнивать разные перечисления друг с другом — легко наделать странных багов.

Сначала посмотрим на «старый» enum и его проблемы:

enum Color { Red, Green, Blue };
enum Status { Ok, Error };

int main() {
    Color c = Red;

    if (c == Ok) { }   // компилируется, хотя Color и Status — разные enum'ы
}

Теперь перепишем на enum class, чтобы каждое перечисление стало отдельным типом с собственной областью имён:

enum class Color { Red, Green, Blue };
enum class Status { Ok, Error };

int main() {
    Color c = Color::Red;
    Status s = Status::Ok;

    // if (c == s) { }   // ошибка компиляции: разные типы
}

enum class не приводится к int по умолчанию, не пересекается по именам и сразу показывает, к какому именно набору значений относится переменная.

🔥 Переход на enum class — простой шаг к более безопасному и читаемому коду с перечислениями.

📣 C++ Ready | #практика