Краткий ответ

std::integral_constant представляет константное значение одновременно как тип и как объект этого типа. Благодаря этому результат вычисления на этапе компиляции можно использовать в специализациях, перегрузках, SFINAE, концепциях и других механизмах метапрограммирования.

У типа есть статический член value, неявное преобразование к базовому типу значения и вызов operator(), возвращающий это значение. Например, std::integral_constant<bool, true> является базовым классом для std::true_type.

Исторический контекст

Шаблонное метапрограммирование выполняет вычисления во время компиляции, но исходно основным инструментом для выбора реализации были типы: специализации шаблонов и перегрузки различают типовые аргументы.

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

Постановка проблемы

Одного constexpr-значения недостаточно, если результат нужно передать механизму, работающему с типами. Например, частичная специализация шаблона или перегрузка функции не может напрямую использовать произвольную переменную как типовой маркер.

Если результат оставить только числом или bool, придётся вручную писать отдельные типы-маркеры и поддерживать связь между маркером и значением. Ошибка в такой связи может привести к выбору неправильной специализации или к неочевидной диагностике.

Подробное решение

std::integral_constant<T, V> создаёт тип, где T — интегральный тип значения, а V — нетиповой шаблонный аргумент. Внутри этот тип предоставляет static constexpr T value = V и операции, позволяющие использовать его как значение.

Типовая идентичность включает оба параметра. Поэтому std::integral_constant<int, 1> и std::integral_constant<int, 2> — разные типы, хотя оба содержат значение типа int.

Признаки типов обычно наследуются от std::integral_constant<bool, результат>. Это даёт единый интерфейс: Trait<T>::value для значения и Trait<T> как типовой маркер. На его основе можно выбирать перегрузку через теговую диспетчеризацию.

#include <type_traits>
#include <iostream>

template<class T>
struct is_small : std::integral_constant<bool, (sizeof(T) <= 4)> {};

void process_impl(std::true_type) { std::cout << "small"; }
void process_impl(std::false_type) { std::cout << "large"; }

template<class T>
void process(T) { process_impl(is_small<T>{}); }

int main() { process(1); }

Для int is_small<int> наследуется от std::integral_constant<bool, true>, то есть совместим с std::true_type. Выбор перегрузки происходит на этапе компиляции, а вызов не требует выполнения условной проверки.

Компромисс состоит в том, что такой подход создаёт отдельные типовые маркеры и иногда усложняет интерфейс. В современном C++ для локального выбора ветки часто проще использовать if constexpr, а std::integral_constant особенно полезен, когда результат должен участвовать именно в типовой диспетчеризации или быть частью публичного метапрограммного протокола.

Ситуация из практики

В библиотечном алгоритме требовалось выбирать реализацию в зависимости от свойства типа. Рассматривались три варианта: обычная проверка во время выполнения, if constexpr и передача типового маркера.

Обычная проверка была отвергнута: обе ветки должны были быть корректны для всех типов, а ненужная ветка создавала лишние ограничения. if constexpr решил бы локальную задачу проще, но не подходил, поскольку разные реализации уже существовали как независимые перегрузки.

Был выбран признак, наследующийся от std::integral_constant, и теговая диспетчеризация. Свойство типа вычислялось компилятором, результат превращался в тип std::true_type или std::false_type, после чего выбиралась подходящая перегрузка без runtime-ветвления. Такой вариант оказался удобен для расширения: новые категории можно было добавлять отдельными типами-маркерами.

Что кандидаты часто упускают

Обязательно ли создавать объект std::integral_constant, чтобы получить его значение?

Нет. Значение обычно читают через Trait<T>::value, а не через объект. Объект Trait<T>{} нужен главным образом как типовой тег для передачи в перегрузку или для использования его преобразования к базовому значению.

Например, std::true_type::value — это compile-time-константа true, тогда как std::true_type{} — объект типового маркера. Эти формы связаны, но применяются в разных контекстах.

Чем std::bool_constant отличается от std::integral_constant<bool, B>?

std::bool_constant<B> — это псевдоним для std::integral_constant<bool, B>. Он не вводит новый механизм и не создаёт отдельную семантику.

Псевдоним делает код признаков понятнее: std::bool_constant<условие> явно показывает, что результатом является булево свойство. Для произвольных интегральных значений по-прежнему используют непосредственный std::integral_constant<T, V>.

Почему типовой маркер часто передают по значению, если его значение не нужно во время выполнения?

Объект такого типа обычно пуст и не хранит отдельное runtime-состояние. При оптимизации передача маркера по значению, как правило, не создаёт фактических затрат, а сам тип участвует в выборе перегрузки на этапе компиляции.

Передача по значению подчёркивает назначение аргумента как тега и позволяет компилятору различать перегрузки по типу. Если интерфейс должен быть исключительно compile-time-интерфейсом без фиктивного параметра функции, в современном C++ альтернативой может быть if constexpr или ограничение концептом.