Полезные новации С++17. constexpr if.

if времени компиляции для С++!

Свойство позволяет нам отбрасывать ветви утверждения if во время компиляции, основываясь на условии константного выражения.

if constexpr(cond) statement1; // Discarded if cond is false else statement2; // Discarded if cond is true

Например:

template <typename T> auto get_value(T t) { if constexpr (std::is_pointer_v<T>) return *t; else return t; }

#include <iostream>
#include <memory>

 template <typename T>
auto get_value(T t) {
    if constexpr (std::is_pointer_v<T>)
        return *t;
    else
        return t;
}

 int main()
{
     auto pi = std::make_unique<int>(9);
     int i = 9;
     
     std::cout << get_value(pi.get()) << "\n";
     std::cout << get_value(i) << "\n";
}

constexpr if может быть использована для замены уже существующих трюков:

  • техника SFINAE по удалению не подходящих функций при перегрузке,
  • std::enable_if, появившаяся в С++14, может быть легко заменена на constexpr if,
  • диспетчеризация тегов.
Простой пример - последовательность Фибоначчи:

template<int N> constexpr int fibonacci() {return fibonacci<N-1>() + fibonacci<N-2>(); } template<> constexpr int fibonacci<1>() { return 1; } template<> constexpr int fibonacci<0>() { return 0; }

Теперь нет необходимости в специализациях и код становится более понятным:

template<int N> constexpr int fibonacci() { if constexpr (N>=2) return fibonacci<N-1>() + fibonacci<N-2>(); else return N; }

Необходимо учитывать, что "логика короткого замыкания" не работает для  if constexpr и будет во время компиляции вычисляться всё выражение, например попытка инстанцировать do_thing(3) в следующем примере будет вызывать ошибку компиляции


#include <iostream>
#include <type_traits>

struct MyType
{
static const int i = 5;
};

template<typename T>
void do_thing(const T &t)
{
if constexpr (std::is_same_v<MyType, T> && T::i == 5) {
std::cout << "MyType::i == 5\n";
}
else {
std::cout << "don't know...\n";
}
}

int main()
{
do_thing(MyType());
do_thing(3); // fails to compile because of the T::i expression in the if-constexpr above
}


Ещё пример взятия элемента структуры по индексу:


#include <iostream>
#include <string>

struct S 
{
    int n;
    std::string s;
    float d;
};

template <std::size_t I>
auto& get(S& s)
{
    if constexpr (I == 0)
        return s.n;
    else if constexpr (I == 1)
        return s.s;
    else if constexpr (I == 2)
        return s.d;
}

int main()
{
S obj { 0, "hello", 10.0f };
    std::cout << get<0>(obj) << ", " << get<1>(obj) << "\n";
}


Подробности:

https://tech.io/playgrounds/2205/7-features-of-c17-that-will-simplify-your-code/constexpr-if






Комментарии

Отправить комментарий

Популярные сообщения из этого блога

Полезные новации С++17. Выражения свертки (Fold expressions)

Начиная с C++11, в языке появились пакеты параметров для шаблонов с переменным количеством аргументов. Такие пакеты позволяют реализовывать функции, принимающие переменное количество параметров. Иногда эти параметры объединяются в одно выражение, чтобы на его основе можно было получить результат работы функции. Решение этой задачи значительно упростилось с выходом C++17, где появились выражения свертки. Реализуем функцию, которая принимает переменное количество параметров арифметических типов и возвращает их сумму. template <typename ... Ts> auto sum(Ts ... ts) {    return (ts + ...); }     Следует обратить внимание на обязательность скобок в выражении  (ts + ...).  Функцию можно использовать так: int the_sum {sum(1, 2, 3, 4, 0.5)}; // Значение: 10.5    Общий смысл понятен. Поработаем над деталями. Первое наше упущение - отсутствие возможности работать с пустым списком параметров. Инстанцирование  sum() приводит к ошибке ...
Далее...

Перегрузка и специализация шаблонных функций.

Попалась на глаза не новая статья на Хабре , в которой автор (достаточно туманно - по моему мнению) разъясняет старую проблему. То, что проблема с бородой, показывает статья Герба Саттера. Ну что же, новое - хорошо забытое старое. Ниже мой вольный перевод статьи Саттера. Почему не специализируются шаблоны функций? В вопросе, поставленном в заголовке статьи одновременно содержится утверждение - когда и почему не стоит специализировать шаблоны. Большая разница: перегрузка против специализации. Краткий обзор того, что мы, возможно забыли. В С++ имеются шаблонные классы ( class templates ) и шаблонные функции( function templates ). Эти две вещи не работают совершенно одинаковыми путями, и наиболее очевидная разница это перегрузка: Старые не-шаблонные классы не перегружаются, как не перегружаются и шаблонные. С другой стороны, старые не-шаблонные функции, имеющие одинаковые имена перегружаются, и поэтому шаблонные функции перегружаются тоже. Всё это совеоршенно естественно. Вот ...
Далее...

Ещё о перегрузке шаблонных функций (Partial ordering)

[1]  16.2.2 Partial Ordering of Overloaded Function Templates Рассмотрим пример: #include <iostream> template<typename T> int f(T) {     return 1; } template<typename T> int f(T*) {     return 2; } int main() {     std::cout << f<int*>((int*)nullptr); // calls f<T>(T)     std::cout << f<int>((int*)nullptr); // calls f<T>(T*) } Программа имеет вывод : 12. Чтобы понять почему, давайте рассмотрим вызов  f<int*>((int*)nullptr) поподробнее. Синтаксис  f<int*>  указывает, что   мы хотим подставить в первый шаблонный параметр шаблона f() указатель int* не полагаясь на вывод шаблонного аргумента. В этом случае имеется более одного шаблона f(), и поэтому создаётся набор перегрузки, состоящий из двух функций, генерированных из шаблонов: f<int*>(int*) (генерированный из первого шаблона) и f<int*>(int**) (генерированный из втор...
Далее...