Will consteval allow using static_assert on function arguments?

by

Will consteval allow to use static_assert on function arguments?

No. Function arguments have never been, and will continue to not be, usable as constant expressions.

There is a difference between something being constant evaluated and being usable as a constant-expression. consteval ensures that we’re in a constant evaluation context, but it does not also cause everything to become constant-expressions.

In order to allow function arguments to be usable as constant expressions, you would need to make everything implicitly a template:

template <int> struct X { };

consteval auto foo(int i) {
    static_assert(i > 10); // in order to allow this...
    return X<i>{};         // ... you'd have to allow this too
}

And now foo(20) and foo(30) return different types. That’s a template.

Important background reading for understanding why this is a fundamental and inherent limitation can be found in Andrew Sutton’s Translation and evaluation: A mental model for compile-time metaprogramming:

Having a mental model of compile-time evaluation that physically separates it from the process of
translation has been extremely helpful for me. In particular, it has helped me understand what is not
possible (e.g., instantiating a template during evaluation). This helps prune the design space for
otherwise large and complex language features. Hopefully, others will find this note helpful as well.

With static_assert specifically though, you can add a workaround just to cause a compilation failure. That’s just adding anything at all that can’t be used during constant evaluation. Like:

#define CONSTEVAL_STATIC_ASSERT(c, msg) do { if (!(c)) throw msg; } while(false)

as in:

consteval char operator""_bchar(const char text[], const size_t length)
{
    CONSTEVAL_STATIC_ASSERT(length == 8, "Binary char has to have 8 digits!");
    // ...
}

More Related Contents:

  1. What is a “span” and when should I use one?
  2. Can I take the address of a function defined in standard library?
  3. static_assert fails compilation even though template function is called nowhere
  4. C++11 – static_assert within constexpr function?
  5. What is the (“spaceship”, three-way comparison) operator in C++?
  6. Why does same_as concept check type equality twice?
  7. Will specialization of function templates in std for program-defined types no longer be allowed in C++20?
  8. Can class template constructors have a redundant template parameter list in c++20
  9. Class type non-type template parameter initialization does not compile
  10. Designated initializers in C++20
  11. Why do we require requires requires?
  12. BOOST_STATIC_ASSERT without boost
  13. How to use c++20 modules with CMake?
  14. Which headers in the C++ standard library are guaranteed to include another header?
  15. What is `constinit` in C++20?
  16. Will consteval functions allow template parameters dependent on function arguments?
  17. How to use std::views::transform on a vector?
  18. Familiar template syntax for generic lambdas
  19. Why is volatile deprecated in C++20?
  20. ‘auto’ as a template argument placeholder for a function parameter
  21. In which access control context are concepts evaluated?
  22. Why default three-way operator (spaceship ) generates equality operator (==) and user define three-way operator not?
  23. What does static_assert do, and what would you use it for?
  24. What is the purpose of C++20 std::common_reference?
  25. Contiguous iterator detection
  26. Is lambdification of a concept an improvement or bad practice?
  27. Why is operator!= removed in C++20 for many standard library types?
  28. C++ check if statement can be evaluated constexpr
  29. Why must a std::ranges::filter_view object be non-const for querying its elements?
  30. Why don’t I need to specify “typename” before a dependent type in C++20?

Leave a Comment