inline constexpr have external linkage?

Question

I know global constexpr variables have internal linkage. so how is it that inline constexpr are introduced with having external linkage? does adding inline just converts internal linakges to external linkages in all cases?

Answer 1

There seems to be a little bit of confusion about what "linkage" and "inline" actually means. They are independent (orthogonal) properties of a variable, but nevertheless coupled together.

To inline a variable one declares it inline. Declaring a constexpr variable at namescope does not imply inline [1]. To declare a variable to have internal linkage one declares it static or more preferrable puts it into an anonymous namespace [2],[3]. For const and constexpr (which implies const) variables there is a special rule, which gives them internal linkage as long as they are non-inline [4].

Because constexpr variables require an immediate definition [5], you typically want them to be be inline which allows multiple (equivalent) definitions in multiple translation units:

\\ c.hpp
inline constexpr int c = 0;       // define it in header

\\ a.cpp
#include "c.hpp"                  // c is defined in a.cpp
int a = c;                        // use it

\\ b.cpp
#include "c.hpp"                  // c is re-defined in b.cpp
int b = c;                        // use it

The linkage of c in that example above is external, because the special rule for const variables only applies to non-inline variables.

Note that when ommiting the inline specifier in the example makes each source file get an independent non-inline definition of c with internal linkage. It will still compile but you have to be careful to not use c in any inline functions [6].

You can put inline constexpr variables into an anonymous namespace or declare it static to make its linkage internal. If we changed the example above into

\\ c.hpp
namespace {
    inline constexpr int c = 0;
};

\\ a.cpp
...

the effects would be almost the same as if ommitin the inline in the original example. Each translation unit gets its own version of the (now inlined) variable and you have to make sure that you don't use c in an inline function.

Answer 2

inline variable or function make compiler merge* multiple definition into one.

for the same reason, multiple inline constexpr with same name would has only one instance after link.

then you're accessing the variable in other TU, it's effectively has external linkage.

---

* it's undefined behavior if the definition are not the same though.

** you cannot declare extern constexpr, btw

Answer 3

I know global constexpr variables have internal linkage

You are missing a few qualifiers (emphasis mine):

internal linkage

Any of the following names declared at namespace scope have internal linkage:

• ...

• non-volatile non-template (since C++14) non-inline (since C++17) non-exported (since C++20) const-qualified variables (including constexpr) (since C++11) that aren't declared extern and aren't previously declared to have external linkage;

• ...