Static constant versus constant in a function that is called repeatedly

Question

There are a couple of things that affect the answer:

• First, as long as the value is const it will almost certainly be optimized out in any case. That means that the resulting code will most likely be the same.
• Second, static members are stored elsewhere which means less locality and probably a cache miss.
• Third, the cost of initialization depends on the type. In your case, for an int, the cost of initialization is basically nonexistent. For more complex user-defined types, it may be huge.

So the answer is, in cases simple enough for the compiler to figure them out and optimize, it makes zero difference. In your example that would almost certainly be the case.

As long as the variable has a type that is easy and cheap to construct, prefer non-static to avoid the cache miss.

If the type is expensive to construct, you might want to use static.

And of course, last, and most importantly of all:

Don't trust our guesswork. If you are concerned about performance, there is only one correct course of action:

• Measure it, to verify that it is actually a problem
• Measure the performance of each possible solution
• Pick the solution that results in the best performance.

well theoretically the former method is a tiny bit better as it only insantiates the variable once.

However the compiler will simply remove either "const" line and substitute "cout << 12;" into the function (When compiled with optimisations on, obviously).

In first cast ABC will be initialized only once, on first function call. In second case ABC will be initialized every time. You'll feel the difference if ABC is complex type with constructor. It could allocate memory or initialize some mutex. For int there is no difference in practice.

According to C++03 Standard 3.7.1/2:

If an object of static storage duration has initialization or a destructor with side effects, it shall not be eliminated even if it appears to be unused, except that a class object or its copy may be eliminated as specified in 12.8.

It depends on the compiler.

In embedded software, a static const will typically be stored in flash (i.e. code memory), and will be accessed directly, like a normal variable, without any need for initialisation.

In contrast, a non-static const may have its value stored in flash, but the const itself will be created on the stack like a variable, and be initialised just like a variable.

If this is how your compiler handles these scenarios, then the static const is more efficient, as it requires neither stack allocation nor initialisation.

Obviously, these scenarios may be handled different by non-embedded compilers.