“constexpr if” vs “if” with optimizations – why is “constexpr” needed?

by

This is easy to explain through an example. Consider

struct Cat { void meow() { } };
struct Dog { void bark() { } };

and

template <typename T>
void pet(T x)
{
    if(std::is_same<T, Cat>{}){ x.meow(); }
    else if(std::is_same<T, Dog>{}){ x.bark(); }
}

Invoking

pet(Cat{});
pet(Dog{});

will trigger a compilation error (wandbox example), because both branches of the if statement have to be well-formed.

prog.cc:10:40: error: no member named 'bark' in 'Cat'
    else if(std::is_same<T, Dog>{}){ x.bark(); }
                                     ~ ^
prog.cc:15:5: note: in instantiation of function template specialization 'pet<Cat>' requested here
    pet(Cat{});
    ^
prog.cc:9:35: error: no member named 'meow' in 'Dog'
    if(std::is_same<T, Cat>{}){ x.meow(); }
                                ~ ^
prog.cc:16:5: note: in instantiation of function template specialization 'pet<Dog>' requested here
    pet(Dog{});
    ^

Changing pet to use if constexpr

template <typename T>
void pet(T x)
{
    if constexpr(std::is_same<T, Cat>{}){ x.meow(); }
    else if constexpr(std::is_same<T, Dog>{}){ x.bark(); }
}

only requires the branches to be parseable – only the branch that matches the condition needs to be well-formed (wandbox example).

The snippet

pet(Cat{});
pet(Dog{});

will compile and work as expected.

More Related Contents:

  1. Why doesn’t an if constexpr make this core constant expression error disappear?
  2. Difference between “if constexpr()” Vs “if()”
  3. constexpr if and static_assert
  4. constexpr static member before/after C++17
  5. “If constexpr” in C++17 does not work in a non-templated function
  6. Self-initialization of a static constexpr variable, is it well-formed?
  7. Static member access in constant expressions
  8. Compile-time or runtime detection within a constexpr function
  9. Do I need to put constexpr after else-if?
  10. Undefined reference error for static constexpr member
  11. C++ check if statement can be evaluated constexpr
  12. what is the concept of evaluation of expression z = (y = 30) + (y = 10) + (y = 20); [closed]
  13. What are Aggregates and PODs and how/why are they special?
  14. Undefined reference to static constexpr char[]
  15. Why do constant expressions have an exclusion for undefined behavior?
  16. Is is_constexpr possible in C++11?
  17. experimental::filesystem linker error
  18. Is stateful metaprogramming ill-formed (yet)?
  19. Does constexpr imply inline?
  20. Is a pointer with the right address and type still always a valid pointer since C++17?
  21. C++11 constexpr function pass parameter
  22. Lambda implicit capture fails with variable declared from structured binding
  23. Constexpr pointer value
  24. polymorphic_allocator: when and why should I use it?
  25. constexpr function parameters as template arguments
  26. Will consteval functions allow template parameters dependent on function arguments?
  27. constexpr const vs constexpr variables?
  28. What are use cases for structured bindings?
  29. How to ensure constexpr function never called at runtime?
  30. Directly write into char* buffer of std::string

Leave a Comment