Why use constexpr

Question

Let's take a simple SFINAE templating example

#include <iostream>

template <typename T>
struct has_typedef_foobar {
    // Types "yes" and "no" are guaranteed to have different sizes,
    // specifically sizeof(yes) == 1 and sizeof(no) == 2.
    typedef char yes[1];
    typedef char no[2];

    template <typename C>
    static yes& test(typename C::foobar*);

    template <typename>
    static no& test(...);

    // If the "sizeof" of the result of calling test<T>(0) would be equal to sizeof(yes),
    // the first overload worked and T has a nested type named foobar.
    static const bool value = sizeof(test<T>(0)) == sizeof(yes);
};

struct foo {    
    typedef float foobar;
};

int main() {
    std::cout << std::boolalpha;
    std::cout << has_typedef_foobar<int>::value << std::endl;
    std::cout << has_typedef_foobar<foo>::value << std::endl;
}

The bool value has not been declared constexpr but it still gets its value on compile time. What then is the use of constexpr and why do simple static variables get their values at compile time? How can I tell which static variables get their value at compile time?

Also how can I tell which values will get evaluated at compile time and which will not? Will using constexpr guarantee compile time evaluation? If not how can I know which will happen (compile time or run time)?

Answer 1

One of the key things that constexpr gives you that was not really possible to achieve before is the ability to call a function in a context that requires a compile time constant. The simplest example of this is an array size:

#include <iostream>

using namespace std;

constexpr auto square(int x) { return x * x; }

int main()
{
    int arr[square(2)] = { 0, 1, 2, 3 };
    cout << arr[square(1)] << endl;
}

Without the constexpr on function square() it could not be called in the definition of arr since an array size is required to be a compile time constant.

While you could write a template that would give you a compile time square prior to constexpr, you could not use that template with a non compile time constant argument so you would end up with code duplication for compile time and non compile time versions. The syntax for a template is more complicated and less familiar to most programmers than a simple function definition as well.

In fact constexpr makes very few guarantees about when a compiler will actually choose to evaluate something at compile time. In contexts where a value is required to be a compile time constant (such as an array size) it will be of course. In other contexts it's largely up to the compiler - in the call to square() when accessing arr[square(1)] for example the compiler is free to evaluate at runtime, although in practice I would expect most compilers to evaluate this at compile time, at least in an optimized build.

Answer 2

This is not a great question because constexpr is a huge feature and it has many "points" to it.

The main one is, you can do compile-time computation using (more) normal C++ syntax than the template metaprogramming language.

For instance if you ever tried to do string manipulations at compile time using templates, you might contrast that experience with some of the techniques described here: Conveniently Declaring Compile-Time Strings in C++

constexpr is basically a new compile-time metaprogramming language which exists in parallel to the template language, and some things like constexpr constructors allow you to instantiate structs at compile time which simply isn't possible with only templates.

Another big "point" of it is that you don't have to write different code for compile-time vs. run-time. Code that is marked constexpr can run at compile-time and can also run just as easily at run-time. Template code... has to run entirely at compile time and generally looks very different from equivalent run-time code. So in some cases using constexpr code is more DRY.