{"id":3534,"date":"2019-09-10T20:30:40","date_gmt":"2019-09-10T18:30:40","guid":{"rendered":"https:\/\/mariusbancila.ro\/blog\/?p=3534"},"modified":"2020-05-08T11:46:43","modified_gmt":"2020-05-08T09:46:43","slug":"let-there-be-constants","status":"publish","type":"post","link":"https:\/\/mariusbancila.ro\/blog\/2019\/09\/10\/let-there-be-constants\/","title":{"rendered":"Let there be constants!"},"content":{"rendered":"

In the beginning, there was const<\/tt>. And people saw that const<\/tt> was good. And then the people said: let there be constexpr<\/tt>, and consteval<\/tt>, and constinit<\/tt>. And thus, starts this article about constant functions and variables in C++20, which I will try to keep short and concise. <\/p>\n

<\/p>\n

const<\/h1>\n

const<\/tt> is a specifier that indicates that a global, local, or member variable or a function parameter cannot be modified after it is initialized. It can also be used to qualify a non-static member function; such a constant member function cannot modify the object state (unless the fields are declared mutable<\/tt>) and can only invoke other constant member functions. Such a function, however, is still evaluated at runtime.<\/p>\n

class foo\r\n{\r\n   int value;\r\npublic:\r\n   foo(int const v) : value(v) {}\r\n\r\n   int get() const { return value; }\r\n};\r\n\r\nint main()\r\n{\r\n   int const fortyTwo = 42;\r\n   foo f(fortyTwo);\r\n   int n = f.get();\r\n}<\/pre>\n
The term const correctness<\/em> refers to using constants whereever is possible. However, the exact placement of the const<\/tt> specifier has generated a great debate within the C++ community between those that advocate the use of it on the left or right side of the type. These alternatives are called East const<\/em> and West const<\/em>.<\/p>\n
int const a = 42;  \/\/ East const\r\nconst int a = 42;  \/\/ West const<\/pre>\n
I have been using East const for many years and I believe it’s the better alternative. I will not get into the details here, but you can read more about it here: Join the East const revolution!<\/a><\/p>\n
As of C++17, constants (and variables in general) can be declared inline<\/tt>. This makes it possible to define global constants in a header file, or initializing static<\/tt> const<\/tt> members of a class in a header, without risking to generate multiple definitions for the same symbol when the header is included in more than one translation unit.<\/p>\n
\/\/ foo.h header\r\n\r\nstruct foo\r\n{\r\n   static const int alpha;\r\n};\r\n\r\ninline const int foo::alpha = 42;\r\n\r\ninline const int beta = 44;\r\n\r\nstruct bar\r\n{\r\n   inline static const int gamma = 42;\r\n};\r\n<\/pre>\n
constexpr<\/h1>\n
The constexpr<\/tt> specifier was introduced in C++11 to indicate that a variable or function can appear in a constant expression, which is an expression that can be evaluated at compile time. <\/p>\n
constexpr int maximum(int const a, int const b)\r\n{\r\n   return a >= b ? a : b;\r\n}\r\n\r\nint main()\r\n{\r\n   int const Size = 64;\r\n   int arr[maximum(42, Size)]{ 0 };\r\n}<\/pre>\n
Specifying constexpr<\/tt> for a function does not mean that the function is always evaluated at compile-time. This is done only when it’s possible. If invoked with arguments that are not constant expressions, the evaluation will only happen at runtime, as shown in the following example.<\/p>\n
\r\nconstexpr int m1 = maximum(42, 66);  \/\/ compile-time evaluation\r\nint a = 42, b = 66;\r\nconst int m2 = maximum(a, b);        \/\/ run-time evaluation<\/pre>\n
A constexpr<\/tt> specifier used in an object declaration implies const<\/tt>. A constexpr<\/tt> specifier used in a function or static member variable declaration implies inline<\/tt>.  If any declaration of a function or function template has a constexpr<\/tt> specifier, then every declaration must contain the specifier. <\/p>\n
constexpr<\/tt> can be used not only with variables and functions, but also member functions, constructors, and as of C++20 with virtual functions. There are various other changes in C++20 related to constexpr<\/tt>:<\/p>\n