const vs constexpr vs consteval vs constinit in C++20

As of C++20, we’ve 4 key phrases starting with const. What do all of them imply? Are they largely the identical? Let’s evaluate them on this article.

const vs constexpr

 

const, our good previous fried from the early days of C++ (and likewise C), might be utilized to things to point immutability. This key phrase can be added to non-static member features, so these features might be known as on const cases of a given kind.

const doesn’t suggest any “compile-time” analysis. The compiler can optimize the code and achieve this, however on the whole, const objects are initialized at runtime:

// is perhaps optimized to compile-time if compiled decides...
const int importantNum = 42;

// will probably be inited at runtime
std::map<std::string, double> buildMap() { /*...*/ }
const std::map<std::string, double> countryToPopulation = buildMap();

const can typically be utilized in “fixed expressions”, for instance:

const int depend = 3;
std::array<double, depend> doubles {1.1, 2.2, 3.3};

// however not double:
const double dCount = 3.3;
std::array<double, static_cast<int>(dCount)> moreDoubles {1.1, 2.2, 3.3};
// error: the worth of 'dCount' just isn't usable in a relentless expression

See at Compiler Explorer

Let’s see the complete definition from cppreference:

Defines an expression that may be evaluated at compile time. Such expressions can be utilized as non-type template arguments, array sizes, and in different contexts that require fixed expressions.

You probably have a relentless integral variable that’s const initialized, or enumeration worth, then it may be used at fixed expression.

Since C++11, we’ve a brand new key phrase – constexpr – which pushed additional the management over variables and features that can be utilized in fixed expressions. Now it’s not a C++ trick or a particular case, however a whole, easier-to-understand resolution.

// tremendous now:
constexpr double dCount = 3.3;
std::array<double, static_cast<int>(dCount)> doubles2 {1.1, 2.2, 3.3};

Above, the code makes use of double, which is allowed in fixed expressions.

We are able to additionally create and use easy constructions:

#embrace <array>
#embrace <cstdlib>

struct Level {
    int x { 0 };
    int y { 0 };

    constexpr int distX(const Level& different) const { return abs(x - different.x); }
};

int major() {
    constexpr Level a { 0, 1 };
    constexpr Level b { 10, 11 };
    static_assert(a.distX(b) == 10);
    
    // but additionally at runtime:
    Level c { 100, 1 };
    Level d { 10, 11 };
    return c.distX(d);
}

Run @Compiler Explorer

In abstract:

• const might be utilized to every kind of objects to point their immutability
• const integral kind with fixed initialization can be utilized in fixed expression
• constexpr object, by definition, can be utilized in fixed expressions
• constexpr might be utilized to features to point out that they are often known as to supply fixed expressions (they can be known as at runtime)
• const might be utilized to member features to point {that a} operate doesn’t change knowledge members (except mutable),

constexpr vs consteval

 

Quick ahead to C++20, we’ve one other key phrase: consteval. This time it may be utilized solely to features and forces all calls to occur at compile time.

For instance:

consteval int sum(int a, int b) {
  return a + b;
}

constexpr int sum_c(int a, int b) {
    return a + b;
}

int major() {
    constexpr auto c = sum(100, 100);
    static_assert(c == 200);

    constexpr auto val = 10;
    static_assert(sum(val, val) == 2*val);

    int a = 10;
    int b = sum_c(a, 10); // tremendous with constexpr operate

    // int d = sum(a, 10); // error! the worth of 'a' is 
                           // not usable in a relentless expression
}

See @Compiler Explorer.

Speedy features might be seen as an alternative choice to function-style macros. They may not be seen within the debugger (inlined)

Moreover, whereas we are able to declare a constexpr variable, there’s no choice to declare a consteval variable.

// consteval int some_important_constant = 42; // error

In abstract:

• consteval can solely be utilized to features
• constexpr might be utilized to features and likewise variables
• consteval forces compile time operate analysis; the constexpr operate might be executed at compile time but additionally at runtime (as a daily operate).

constexpr vs constinit

 

And now the final key phrase: constinit.

constinit forces fixed initialization of static or thread-local variables. It will probably assist to restrict static order initialization fiasco through the use of precompiled values and well-defined order relatively than dynamic initialization and linking order…

#embrace <array>

// init at compile time
constexpr int compute(int v) { return v*v*v; }
constinit int world = compute(10);

// will not work:
// constinit int one other = world;

int major() {
    // however permit to vary later...
    world = 100;

    // world just isn't fixed!
    // std::array<int, world> arr;
}

See at Compiler Explorer

Opposite to const or constexpr, it doesn’t imply that the thing is immutable. What’s extra constinit variable can’t be utilized in fixed expressions! That’s why you can not init one other with world or use world as an array measurement.

In abstract:

• constexpr variables are fixed and usable in fixed expressions
• constinit variables will not be fixed and can’t be utilized in fixed expressions
• constexpr might be utilized on native automated variables; this isn’t attainable with constinit, which might solely work on static or thread_local objects
• you possibly can have a constexpr operate, nevertheless it’s not attainable to have a constinit operate declaration

Mixing

 

Can we’ve mixes of these key phrases?

// attainable and compiles... however why not use constexpr?
constinit const int i = 0;

// would not compile:
constexpr constinit int i = 0;

// compiles:
const constexpr int i = 0;

And we are able to have const and constexpr member features:

struct Level {
    int x { 0 };
    int y { 0 };

    constexpr int distX(const Level& different) const { return abs(x - different.x); }
    constexpr void mul(int v) { x *= v; y *= v; }
};

Within the above state of affairs, constexpr implies that the operate might be evaluated for fixed expressions, however const implies that the operate gained’t change its knowledge members. There’s no subject in having solely a constexpr operate like mul:

constexpr int take a look at(int begin) {
    Level p { begin, begin };
    p.mul(10); // modifications p!
    return p.x;
}

int major() {
    static_assert(take a look at(1) == 10);
}

Run at Compiler Explorer

Abstract

 

After seeing some examples, we are able to construct the next abstract desk:

You may also discover one other cool article from Marius Bancila the place he additionally in contrast these key phrases (again in 2019): Let there be constants!.

As of C++23 there’s no new const key phrase added, so the checklist I confirmed on this article must be legitimate for a few years at the least 🙂

Again to you

• Do you utilize constexpr?
• Have you ever tried constinit?

Share your suggestions in feedback beneath.