Storage durations

void foo()
{
    A * p = new A(10); // Объект типа A инициализированный числом 10 имеет dynamic storage duration: та самая куча. 
    // деструктор ~A() вызовется при выполнении delete
    // Указатель p на объект типа А имеет automatic storage duration: тот самый стек
}

void foo()
{
    A a(10); // Объект типа A инициализированный числом 10 имеет automatic storage duration, 
    // деструктор вызовется в конце области видимости автоматически
}

void foo()
{
    static A a(10); // Объект типа A инициализированный числом 10 имеет static storage duration, 
    // деструктор вызовется в конце выполнения программы
}

thread_local A a {10}; // это пишем в global scope
 
void foo() // foo выполняется в потоке
{ 
   // 'a' создался
    a.bar();
} // 'a' уничтожился

void foo()
{
    log << "ololo"; //<--- треды за него не конкурируют
      //потому что он у каждого треда свой собственный
}

log << "one" << "two;

#include <iostream>
#include <sstream>
#include <vector>
#include <thread>
#include <mutex>
 
namespace detail{
 
    #define dFOR__(char_) \
        typename std::enable_if< std::is_same<typename T::char_type, char_>::value,
 
    #define THIS_OBJECT__(obj_) \
        decltype(obj_)>::type& { return obj_; }
 
    template<class T> auto ostream__() -> dFOR__(char) 
        THIS_OBJECT__(std::cout);
 
    template<class T> auto ostream__() -> dFOR__(wchar_t) 
        THIS_OBJECT__(std::wcout);
 
    #undef THIS_OBJECT__
    #undef dFOR__
 
}//detail
 
template<class T> class AtomicStream
{
    typedef std::mutex 
        mutex_t;
 
    typedef std::basic_ostringstream<typename T::char_type>
        accumulator_t;
public:
    AtomicStream(T& s = detail::ostream__<T>() )
        : mMutex(), mStream(), mDst(s){}
 
   ~AtomicStream(){
        mMutex.lock();
        mDst << mStream.str();
        mMutex.unlock();
    }
 
    template<class U> accumulator_t& operator << (U&& v) { 
        return mStream << v, mStream;
    }
private:
    mutex_t       mMutex;
    accumulator_t mStream;
    T&            mDst;
};
 
typedef AtomicStream<std::ostream>
    AStream;
typedef AtomicStream<std::wostream>
    WAStream;
 
 
 
//------------------------------------------------------
 
 
void atomic_print(const std::string& name, const size_t indx)
{
    AStream() << "thread(" << std::this_thread::get_id() << ") "<< name
        << " printing: " << indx 
        << std::endl;
}
 
void threadFunction(const std::string& name)
{
    for(size_t n=0;n<20; ++n)
        atomic_print(name, n);
}
 
 
 
int main()
{
    std::cout << "Hello, world!\n";
    
    const char* names[] = { "one", "two", "foo", "bar", "baz" };
    
    std::vector<std::thread> threads;
    for(size_t n=0; n< 5; ++n)
        threads.emplace_back(&threadFunction, names[n] );
 
    for(size_t n=0; n<5; ++n)
        threads[n].join();
    
    AStream() << "finished!"<<std::endl;
}