C ++单例延迟初始化实现和链接似乎冲突

Question

C++ Singleton design pattern I come across this question and learned that there are two ways to implement the singleton pattern in c++.

1) allocate the single instance in heap and return it in the instance() call

2) return a static instance in the instance() call, this is also known as the lazy initialization implementation.

But I think the second, that is the lazy initialization implementation, is wrong due to following reasons. Static object returned from the instance() call has internal linkage and will have unique copies in different translation unit. So if user modifies the singleton, it will not be reflected in any other translation unit.

But there are many statement that the second implementation is correct, am I missing something?

Answer 1

In the context of a method, the static keyword is not about linkage. It just affects the "storage class" of the defined variable. And for static local variables the standard explicitly states:

9.3.6 A static local variable in a member function always refers to the same object, whether or not the member function is inline.

So it doesn't matter at all whether you put the code in a header or cpp file.

Note that for free / non-member function it does indeed depend on the linkage of the function, as KerrekSB pointed out.

Answer 2

The linkage of the name of implementation object does not matter. What matters is the linkage of the name of the function you use to access the object, and that name has, of course, external linkage:

thing.h:

Thing & TheThing();   // external linkage

thing.cpp:

#include "thing.h"

Thing & TheThing() { static Thing impl; return impl; }

Every use of the name TheThing in the program refers to the same entity, namely the function defined (uniquely) in thing.cpp.

Remember, linkage is a property of names , not of objects.

Answer 3

You are wrong, because the singleton is defined in one single translation unit, the one that contains the definition of the function that returns it. That means that all translation units that wants to use the singleton ask it to the single one that actually defines it, and in the end all use the same object (as expected for a singleton pattern :-) ).