The relevant section 6.7:

&gt; 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 control enters the declaration concurrently while the variable is being initialized, the concurrent execution shall wait for completion of the initialization.

Then there&#39;s a footnote:

&gt; The implementation must not introduce any deadlock around execution of the initializer.

So yes, you&#39;re safe.

(This says nothing of course about the subsequent access to the variable through the reference.)

--fno-threadsafe-statics also worth mentioning. In gcc:

&gt; Do not emit the extra code to use the routines specified in the C++ ABI for thread-safe initialization of local statics. You can use this option to reduce code size slightly in code that doesn&#39;t need to be thread-safe. 

Also, have a look at the old thread [Are function static variables thread-safe in GCC?][1]


  [1]: https://stackoverflow.com/questions/1270927/are-function-static-variables-thread-safe-in-gcc

    #include &lt;iostream&gt;
    
    struct a {
      enum LOCAL_A { A1, A2 };
    };
    enum class b { B1, B2 };
    
    int foo(int input) { return input; }
    
    int main(void) {
      std::cout &lt;&lt; foo(a::A1) &lt;&lt; std::endl;
      std::cout &lt;&lt; foo(static_cast&lt;int&gt;(b::B2)) &lt;&lt; std::endl;
    }

The `a::LOCAL_A` is what the strongly typed enum is trying to achieve, but there is a small difference : normal enums can be converted into integer type, while strongly typed enums can not do it without a cast.

So, is there a way to convert a strongly typed enum value into an integer type without a cast? If yes, how?


How to automatically convert strongly typed enum into int?

I want to create a hash of `I love cupcakes` (signed with the key `abcdeg`)

How can I create that hash, using Node.js Crypto?

How do I use Node.js Crypto to create a HMAC-SHA1 hash?

I know this is an often asked question, but as there are so many variants, I&#39;d like to re-state it, and hopefully have an answer reflecting the current state. Something like

    Logger&amp; g_logger() {
        static Logger lg;
        return lg;
    }

Is the constructor of variable lg guaranteed to run only once?

I know from previous answers that in C++03, this is not; in C++0x draft, this is enforced. But I&#39;d like a clearer answer to

1. In C++11 standard (not draft), is the thread-safe initialization behavior finalized?
2. If the above is yes, in current latest releases of popular compilers, namely gcc 4.7, vc 2011 and clang 3.0, are they properly implemented?

Is local static variable initialization thread-safe in C++11?

I know this is an often asked question, but as there are so many variants, I'd like to re-state it, and hopefully have an answer reflecting the current state. Something like
<pre><code class="hljs language-javascript">Logger&#x26; g_logger() {
 static Logger lg;
 return lg;
}
</code></pre>
Is the constructor of variable lg guaranteed to run only once?
I know from previous answers that in C++03, this is not; in C++0x draft, this is enforced. But I'd like a clearer answer to
<ol>
<li>In C++11 standard (not draft), is the thread-safe initialization behavior finalized?</li>
<li>If the above is yes, in current latest releases of popular compilers, namely gcc 4.7, vc 2011 and clang 3.0, are they properly implemented?</li>
</ol>

I&#39;ve been looking into learning Erlang/OTP, and as a result, have been reading (okay, skimming) about the actor model.

From what I understand, the actor model is simply a set of functions (run within lightweight threads called &quot;processes&quot; in Erlang/OTP), which communicate with each other only via _message passing_.

This seems fairly trivial to implement in C++, or any other language:

    class BaseActor {
    	std::queue&lt;BaseMessage*&gt; messages;
    	CriticalSection messagecs;
    	BaseMessage* Pop();
    public:
    	void Push(BaseMessage* message)
    	{
    		auto scopedlock = messagecs.AquireScopedLock();
    		messagecs.push(message);
    	}
    	virtual void ActorFn() = 0;
    	virtual ~BaseActor() {} = 0;
    }

With each of your processes being an instance of a derived BaseActor. Actors communicate with each other only via message-passing. (namely, pushing). Actors register themselves with a central map on initialization which allows other actors to find them, and allows a central function to run through them.

Now, I understand I&#39;m missing, or rather, glossing over one important issue here, namely:
lack of yielding means a single Actor can unfairly consume excessive time. But are cross-platform coroutines the primary thing that makes this hard in C++? (Windows for instance has fibers.)

Is there anything else I&#39;m missing, though, or is the model really this obvious?

The actor model: Why is Erlang/OTP special? Could you use another language?

What&#39;s the notation for declaring a lambda variable, or function parameter, without the use of `auto` or templates? Is there any way to do so? Or does the compiler define a unique class object for each lambda whose name is unknown to the programmer before compile time? If so, why? Can&#39;t they just be passed as some sort of function pointer? It would be a major disappointment if that were not possible.

Lambda as function parameter

What are some good explanations on what argument dependent lookup is? Many people also call it Koenig Lookup as well.

Preferably I&#39;d like to know:

- Why is it a good thing?
- Why is it a bad thing?
- How does it work?

What is &quot;Argument-Dependent Lookup&quot; (aka ADL, or &quot;Koenig Lookup&quot;)?

&lt;!-- language-all: lang-cpp --&gt;

I&#39;m new to move semantics in C++11 and I don&#39;t know very well how to handle `unique_ptr` parameters in constructors or functions. Consider this class referencing itself:

    #include &lt;memory&gt;

    class Base
    {
      public:
    
        typedef unique_ptr&lt;Base&gt; UPtr;
    
        Base(){}
        Base(Base::UPtr n):next(std::move(n)){}
    
        virtual ~Base(){}
    
        void setNext(Base::UPtr n)
        {
          next = std::move(n);
        }
    
      protected :
    
        Base::UPtr next;
    
    };

Is this how I should write functions taking `unique_ptr` arguments?

And do I need to use `std::move` in the calling code?

    Base::UPtr b1;
    Base::UPtr b2(new Base());
    
    b1-&gt;setNext(b2); //should I write b1-&gt;setNext(std::move(b2)); instead?


How do I pass a unique_ptr argument to a constructor or a function?

I&#39;m developing the native application that works with Android via the NDK.
I need to call the `backtrace()` function when there is a crash. The problem is that there is no  `&lt;execinfo.h&gt;` for the NDK. 

Is there any other way to get that back trace?

Android NDK: getting the backtrace

What are some recommended approaches to achieving ***thread-safe*** lazy initialization? For instance,

    // Not thread-safe
    public Foo getInstance(){
        if(INSTANCE == null){
            INSTANCE = new Foo();
        }
    
        return INSTANCE;
    }

How to implement thread-safe lazy initialization?

I want to know which is the best way to stop a thread in Android. I know I can use `AsyncTask` instead of it and that there is a `cancel()` method. I have to use `Thread`s in my situation. Here is how I&#39;m using `Thread`:

    Runnable runnable = new Runnable() {
			@Override
			public void run() {
				//doing some work
			}
		};
    new Thread(runnable).start();

So, does anyone have any idea of which is the best way to stop a thread?

Android - Best and safe way to stop thread

Performing writes/reads on class variables in Ruby is not thread safe. Performing writes/reads on instance variables appears to be thread safe. That said, is it thread safe to perform write/reads on instance variables of a class or metaclass object?

What are the differences between these three (contrived) examples in terms of thread safety?

**EXAMPLE 1:** *MUTUAL EXCLUSION*

    class BestUser # (singleton class)
      @@instance_lock = Mutex.new
  
      # Memoize instance
      def self.instance
        @@instance_lock.synchronize do
          @@instance ||= best
        end
      end
    end

**EXAMPLE 2:** *INSTANCE VARIABLE STORAGE*
    
    class BestUser # (singleton class)
      # Memoize instance
      def self.instance
        @instance ||= best
      end
    end

**EXAMPLE 3:** *INSTANCE VARIABLE STORAGE ON METACLASS*

    class BestUser # (singleton class)
      # Memoize instance
      class &lt;&lt; self
        def instance
          @instance ||= best
        end
      end
    end
    


Thread Safety: Class Variables in Ruby

Can anyone out there help me understand what **Linearizability** is?  I need an explanation that is simple and easy to understand.  I&#39;m reading *The Art of Multiprocessor Programming* by Maruice Herilihy and Nir Shavit and am trying to understand Chapter 3 about Concurrent Objects.

I understand that a method is Linearizable if it has a point where it seems to &quot;take effect&quot; instantaneously from the point of view of the other threads.  That makes sense, but it is also said that Linearizability is actually a property of the execution history.  What does it mean for an execution history to be Linearizable, why do I care, and how does it relate to a method or object being Linearizable?

Thank you!

What is &quot;Linearizability&quot;?

Are there overall rules/guidelines for what makes a method thread-safe? I understand that there are probably a million one-off situations, but what about in general? Is it this simple?

1. If a method only accesses local variables, it&#39;s thread safe.

Is that it? Does that apply for static methods as well?

One answer, provided by @Cybis, was: 
&gt;Local variables cannot be shared among threads because each thread gets its own stack.

Is that the case for static methods as well?

If a method is passed a reference object, does that break thread safety? I have done some research, and there is a lot out there about certain cases, but I was hoping to be able to define, by using just a few rules, guidelines to follow to make sure a method is thread safe.

So, I guess my ultimate question is: &quot;Is there a short list of rules that define a thread-safe method? If so, what are they?&quot;

**EDIT**&lt;br/&gt;
A lot of good points have been made here. I think the real answer to this question is: &quot;There are no simple rules to ensure thread safety.&quot; Cool. Fine. But *in general* I think the accepted answer provides a good, short summary. There are always exceptions. So be it. I can live with that.

What Makes a Method Thread-safe? What are the rules?

## Figure 1: _function templates_

TemplHeader.h

    template&lt;typename T&gt;
    void f();


TemplCpp.cpp

    template&lt;typename T&gt;
    void f(){
       //...
    }    
    //explicit instantation
    template void f&lt;T&gt;();

Main.cpp

    #include &quot;TemplHeader.h&quot;
    extern template void f&lt;T&gt;(); //is this correct?
    int main() {
        f&lt;char&gt;();
        return 0;
    }

Is this the correct way to use `extern template`, or do I use this keyword only for class templates as in Figure 2?

## Figure 2: _class templates_

TemplHeader.h

    template&lt;typename T&gt;
    class foo {
        T f();
    };

TemplCpp.cpp

    template&lt;typename T&gt;
    void foo&lt;T&gt;::f() {
        //...
    }
    //explicit instantation
    template class foo&lt;int&gt;;

Main.cpp

    #include &quot;TemplHeader.h&quot;
    extern template class foo&lt;int&gt;();
    int main() {
        foo&lt;int&gt; test;
        return 0;
    }

I know it is good to put all of this in one header file, but if we instantiate templates with the same parameters in multiple files, then we got multiple same definitions and the compiler will remove them all (except one) to avoid errors. How do I use `extern template`? Can we use it only for classes, or can we use it for functions too?

Also, Figure 1 and Figure 2 may be expanded to a solution where templates are in a single header file . In that case, we need to use the `extern template` keyword to avoid multiple same instantations. Is this only for classes or functions too?

using extern template (C++11)

I have this code that doesn&#39;t work, but I think the intent is clear:

_testmakeshared.cpp_

    #include &lt;memory&gt;

    class A {
     public:
       static ::std::shared_ptr&lt;A&gt; create() {
          return ::std::make_shared&lt;A&gt;();
       }

     protected:
       A() {}
       A(const A &amp;) = delete;
       const A &amp;operator =(const A &amp;) = delete;
    };

    ::std::shared_ptr&lt;A&gt; foo()
    {
       return A::create();
    }

But I get this error when I compile it:

    g++ -std=c++0x -march=native -mtune=native -O3 -Wall testmakeshared.cpp
    In file included from /usr/lib/gcc/x86_64-redhat-linux/4.6.1/../../../../include/c++/4.6.1/bits/shared_ptr.h:52:0,
                     from /usr/lib/gcc/x86_64-redhat-linux/4.6.1/../../../../include/c++/4.6.1/memory:86,
                     from testmakeshared.cpp:1:
    testmakeshared.cpp: In constructor ‘std::_Sp_counted_ptr_inplace&lt;_Tp, _Alloc, _Lp&gt;::_Sp_counted_ptr_inplace(_Alloc) [with _Tp = A, _Alloc = std::allocator&lt;A&gt;, __gnu_cxx::_Lock_policy _Lp = (__gnu_cxx::_Lock_policy)2u]’:
    /usr/lib/gcc/x86_64-redhat-linux/4.6.1/../../../../include/c++/4.6.1/bits/shared_ptr_base.h:518:8:   instantiated from ‘std::__shared_count&lt;_Lp&gt;::__shared_count(std::_Sp_make_shared_tag, _Tp*, const _Alloc&amp;, _Args&amp;&amp; ...) [with _Tp = A, _Alloc = std::allocator&lt;A&gt;, _Args = {}, __gnu_cxx::_Lock_policy _Lp = (__gnu_cxx::_Lock_policy)2u]’
    /usr/lib/gcc/x86_64-redhat-linux/4.6.1/../../../../include/c++/4.6.1/bits/shared_ptr_base.h:986:35:   instantiated from ‘std::__shared_ptr&lt;_Tp, _Lp&gt;::__shared_ptr(std::_Sp_make_shared_tag, const _Alloc&amp;, _Args&amp;&amp; ...) [with _Alloc = std::allocator&lt;A&gt;, _Args = {}, _Tp = A, __gnu_cxx::_Lock_policy _Lp = (__gnu_cxx::_Lock_policy)2u]’
    /usr/lib/gcc/x86_64-redhat-linux/4.6.1/../../../../include/c++/4.6.1/bits/shared_ptr.h:313:64:   instantiated from ‘std::shared_ptr&lt;_Tp&gt;::shared_ptr(std::_Sp_make_shared_tag, const _Alloc&amp;, _Args&amp;&amp; ...) [with _Alloc = std::allocator&lt;A&gt;, _Args = {}, _Tp = A]’
    /usr/lib/gcc/x86_64-redhat-linux/4.6.1/../../../../include/c++/4.6.1/bits/shared_ptr.h:531:39:   instantiated from ‘std::shared_ptr&lt;_Tp&gt; std::allocate_shared(const _Alloc&amp;, _Args&amp;&amp; ...) [with _Tp = A, _Alloc = std::allocator&lt;A&gt;, _Args = {}]’
    /usr/lib/gcc/x86_64-redhat-linux/4.6.1/../../../../include/c++/4.6.1/bits/shared_ptr.h:547:42:   instantiated from ‘std::shared_ptr&lt;_Tp1&gt; std::make_shared(_Args&amp;&amp; ...) [with _Tp = A, _Args = {}]’
    testmakeshared.cpp:6:40:   instantiated from here
    testmakeshared.cpp:10:8: error: ‘A::A()’ is protected
    /usr/lib/gcc/x86_64-redhat-linux/4.6.1/../../../../include/c++/4.6.1/bits/shared_ptr_base.h:400:2: error: within this context
    
    Compilation exited abnormally with code 1 at Tue Nov 15 07:32:58

This message is basically saying that some random method way down in the template instantiation stack from `::std::make_shared` can&#39;t access the constructor because it&#39;s protected.

But I really want to use both `::std::make_shared` and prevent anybody from making an object of this class that isn&#39;t pointed at by a `::std::shared_ptr`. Is there any way to accomplish this?

How do I call ::std::make_shared on a class with only protected or private constructors?

To support user-defined key types in `std::unordered_set&lt;Key&gt;` and `std::unordered_map&lt;Key, Value&gt;`
one has to provide `operator==(Key, Key)` and a hash functor:

    struct X { int id; /* ... */ };
    bool operator==(X a, X b) { return a.id == b.id; }

    struct MyHash {
      size_t operator()(const X&amp; x) const { return std::hash&lt;int&gt;()(x.id); }
    };
 
    std::unordered_set&lt;X, MyHash&gt; s;

It would be more convenient to write just `std::unordered_set&lt;X&gt;`
with a *default hash* for type `X`, 
like for types coming along with the compiler and library.
After consulting 

 * C++ Standard [Draft N3242][1] &#167;20.8.12 [unord.hash] and &#167;17.6.3.4 [hash.requirements],  
 * [Boost.Unordered][2]
 * g++ `include\c++\4.7.0\bits\functional_hash.h` 
 * VC10 `include\xfunctional`
 * various [related question][3]s in Stack Overflow

it seems possible to specialize `std::hash&lt;X&gt;::operator()`:

    namespace std { // argh!
      template &lt;&gt;
      inline size_t 
      hash&lt;X&gt;::operator()(const X&amp; x) const { return hash&lt;int&gt;()(x.id); } // works for MS VC10, but not for g++
      // or
      // hash&lt;X&gt;::operator()(X x) const { return hash&lt;int&gt;()(x.id); }     // works for g++ 4.7, but not for VC10 
    }                                                                             

Given compiler support for C++11 is yet experimental---I did not try Clang---, these are my questions:		

1. Is it legal to add such a specialization to namespace `std`? I have mixed feelings about that. 

2. Which of the `std::hash&lt;X&gt;::operator()` versions, if any, is compliant with C++11 standard?

3. Is there a portable way to do it?

  [1]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3242.pdf
  [2]: http://www.boost.org/doc/libs/1_48_0/doc/html/unordered.html
  [3]: https://stackoverflow.com/questions/647967/how-to-extend-stdtr1hash-for-custom-types

Content Type	Original Author	Original Content on Stackoverflow
Question	Ralph Zhang	View Question on Stackoverflow
Solution 1 - C++	Kerrek SB	View Answer on Stackoverflow
Solution 2 - C++	Denis Glotov	View Answer on Stackoverflow

Is local static variable initialization thread-safe in C++11?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

How do I use Node.js Crypto to create a HMAC-SHA1 hash?

How to automatically convert strongly typed enum into int?

Attributions