static-initialization

The following two functions produce different assemblies, which tells me they're different. Can someone tell me in what way they are different? And is the function local static variable initialization in func2 thread-safe or not? If the answer depends on the compiler, I'd like to know how would the most common compilers behave with func2. int func1(int val) { const auto impl = [](int v) { return v * 10; }; return impl(val); } int func2(int val) { static const auto impl = [](int v) { return v * 10; }; return impl(val); } "The most common compilers" probably differ on this, as they have not all

I'd like to initialize a static std::map where the value is not copyable. I'll call my class ValueClass . ValueClass has an std::unique_ptr as private member and I even ensure that ValueClass is not copyable by extending non_copyable that looks like the following: class non_copyable { public: non_copyable() = default; protected: virtual ~non_copyable() = default; private: non_copyable(const non_copyable&) = delete; non_copyable& operator=(const non_copyable&) = delete; }; Now I'm trying to define a std::map using my class as value: static std::map<int, ValueClass> value_classes = { {0,

I'm building my program (tests actually) using some static library. This library contains one file inside which I have functions like that: string& GetString() { static string strFilename; return strFilename; } void PrintToScreen() { printf("String: %s\n", GetString().c_str()) } Then in my main.cpp (outside the library) I'm doing: GetString() = "abc"; printf("String: %s\n", GetString().c_str()); PrintToScreen(); And I get this output: String: abc String: So looks like second call to the function (but done from different file, which is inside the library) somehow clear previous value,

I have two function-local static objects, One and Two. One's constructor and destructor both access Two through GetTwo(): #include <iostream> struct One; struct Two; const One& GetOne(); const Two& GetTwo(); struct Two { const char* value = "It's two!"; Two() { std::cout << "Two construct" << std::endl; } ~Two() { std::cout << "Two destruct" << std::endl; } }; struct One { One() { std::cout << "One construct" << std::endl; const char* twoval = GetTwo().value; std::cout << "twoval is: " << twoval << std::endl; } ~One() { std::cout << "One destruct" << std::endl; const char* twoval = GetTwo()

After answering this question and not finding a satisfying answer in the standard paper, I started wondering. The standard states the following w.r.t. initialization of mentioned variables: §6.7 [stmt.dcl] p4 [...] Otherwise such a variable is initialized the first time control passes through its declaration; such a variable is considered initialized upon the completion of its initialization . If the initialization exits by throwing an exception, the initialization is not complete, so it will be tried again the next time control enters the declaration. There is no mentioning of what might