Inline static const vs static const variable

Question

I cant figure out what solution is better as I don't clearly understand the difference. I want to have a file that includes some variables that can be freely used throughout the program. My first attempt was the following:

Header file (Hosts.h)

#pragma once

#include <string>

namespace Some::Namespace {

using std::string;

class Hosts {
public:
    static const unsigned int SOME_DEVICE_PORT;
    static const string SOME_DEVICE_IP;
};
}

Implementation file (Hosts.cpp)

#include <Network/Hosts.h>

namespace Some::Namespace {
    const unsigned int Hosts::SOME_DEVICE_PORT = 10100;
    const string Hosts::SOME_DEVICE_IP = "192.168.1.1";
}

Then I became aware of the inline keyword which would make the implementation file redundant and you will be able to define the variables within the header file alone - just like this:

Header file with inline (Hosts.h)

#pragma once

#include <string>

namespace Some::Namespace {

using std::string;

class Hosts {
public:
    static const unsigned int SOME_DEVICE_PORT = 10100;
    inline static const string SOME_DEVICE_IP = "192.168.1.1";
};
}

Now my question is: How does these implementations differs in the matter of number of variable instances? Preferable I would like there to only be one instance of every variable. But will either of these solutions do this and are there other pitfalls regarding optimisation?

Thanks

LoPiTaL · Accepted Answer · 2022-10-06T21:27:08.953

Expanding Mayur's answer, both methods are pretty similar. The main difference between both occurs when using inline static variables in libraries (.dlls and so forth).

With the inline variable, during the compile phase you will have an instance per each translation unit where it is used, and then the linker will remove all instances but one, referencing all translation units to the only instance not removed.

With the non-inline variable, there will be only one instance of the variable, then all the translation units will reference this variable.

In a single module (.exe, .dll...) this two use cases behave exactly the same.

But when linking together several .dlls with the .exe, with the inline variable, each module will have one instance, thus each module will reference its own instance. This may (or may not) be a problem. Since you are declaring them const, you will have no problems with the value of the variable, but you may have problems if you are taking its address for some comparison or something, which for different modules would be different addresses.

This would not occur with the non-inline variable, since you should export the variable from one shared module, and reference it from all the other modules, having exactly one instance for the whole program.

score 4 · Answer 2 · answered Feb 12 '19 at 07:57

4

A variable declared inline has the same semantics as a function declared inline, it can be defined, identically, in multiple translation units, must be defined in every translation unit in which it is used, and the behavior of the program is as if there was exactly one variable.

struct MyClass
{
    static const int sValue;
};
inline int const MyClass::sValue = 777;

Or even:

struct MyClass
{
    inline static const int sValue = 777;
};

Also, note that constexpr variables are inline implicitly, so there's no need to use constexpr inline myVar = 10;.

(ref.)

answered Feb 12 '19 at 07:57

Mayur

2,583
16
28

"...and the behavior of the program is as if there was exactly one variable" But are there exactly one variable or not? – 7heViking Feb 12 '19 at 08:08
Depends where. Each object file will have its own variable, in a sense. But at link-time, they'll all be merged into a single one. Which is why it's important all definitions are strictly the same, and the reason for the _Once Definition Rule_, otherwise you'd have an ODR-violation (e.g. when different Translation Units (TUs) are compiled with different #define, resulting in different definitions for that variable), which results in _Undefined Behavior_. – ddevienne Mar 15 '21 at 10:15

Inline static const vs static const variable

2 Answers2

Linked