As software developer C++11 I would like to understand what is the difference between static const std::string TAG = "tag "; and const static std::string TAG = "tag "; inside of the function

First example

In C++11, static const std::string TAG = "tag"; and const static std::string TAG = "tag"; both define a constant string variable named TAG with the value "tag". However, there is a difference in the order of the keywords static and const, which affects the linkage and storage duration of the variable. The following examples illustrate these differences:

void foo() {
    static const std::string TAG1 = "tag1";
    const static std::string TAG2 = "tag2";
    std::cout << TAG1 << " " << TAG2 << std::endl;
}

int main() {
    foo(); // prints "tag1 tag2"
    foo(); // prints "tag1 tag2" again
    return 0;
}

In this example, TAG1 is declared as static const, meaning that it is initialized only once, at program startup, and its value is preserved across multiple function calls. On the other hand, TAG2 is declared as const static, meaning that it has external linkage and static storage duration, and its value is preserved across multiple translation units.

// file1.cpp
const static std::string TAG = "tag";

// file2.cpp
extern const std::string TAG;

void bar() {
    std::cout << TAG << std::endl;
}

int main() {
    bar(); // prints "tag"
    return 0;
}

In this example, TAG is declared as const static, meaning that it has external linkage and static storage duration, and its value is preserved across multiple translation units. The extern keyword in file2.cpp indicates that TAG is declared in another translation unit and its definition should be found at link-time.

Overall, the choice between static const std::string and const static std::string depends on the specific use case and linkage requirements. If the string value is constant across multiple function calls and needs to be shared across multiple translation units, using a const static std::string can be more appropriate. If the string value is constant within a single function and does not need to be shared across translation units, using a static const std::string is sufficient.

Another example

In C++, the order of the const and static keywords can affect the meaning of a variable declaration.

const static std::string ADDRESS{ "local" }; and static const std::string ADDRESS{ "local" }; both define a constant string variable named ADDRESS with the value "local". However, there are some differences between them:

Initialization order: When a variable is declared as const static, it is initialized only once, at program startup, in the order of their definition in the source file. On the other hand, when a variable is declared as static const, it is also initialized only once, but the order of initialization is not guaranteed.

Visibility: A const static variable has internal linkage, meaning that it is only visible within the translation unit where it is defined. In contrast, a static const variable has external linkage, meaning that it can be accessed from other translation units that include its declaration.

Thread safety: A const static variable is thread-safe because it is initialized only once, at program startup. In contrast, a static const variable is not thread-safe because the order of initialization is not guaranteed, and it may be accessed concurrently by multiple threads.

Overall, the choice between const static and static const depends on the specific use case and whether thread safety or visibility is a concern. If the variable should be initialized only once, and its visibility should be limited to the translation unit where it is defined, const static is more appropriate. If the variable should be accessible from other translation units, and thread safety is not a concern, static const is more appropriate.