static const vs const in a function that repeatedly called

Question

I'm just wondering how

void test()
{
   const static int ABC = 12;
   cout << ABC;
}

is different from

void test()
{
   const int ABC = 12;
   cout << ABC;
}

if this function is repeatedly called while the program is executing? What I mean is, is there any performance difference? Or is there a reason why you should prefer one over the other?

Answer 1

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).

Answer 2

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.

Answer 3

I would go with the second one - it is more readable. why unnecesarily add a keyword (static) that does not really add any value to someone reading the code.

Answer 4

For a basic type, such as an integer value, then I would pigeon hole the use of static as a "premature optimisation" unless you have done some benchmarking and taken into account the various trade offs (for example initialising a static to a non-zero value often requires an entry in a table to specify the position, size and initial value to be set when the code is loaded).

Unless you are taking a pointer to the int and it is dereferenced after your function returns then you don't need the static - let the compiler do the optimisation.

If a pointer to the value is dereferenced after your function has exited then I would class it as a persistent state variable and it would be good practice to define it at at the class or module level to make that clear.

Answer 5

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.

Answer 6

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.