~thread()
{
   if (this->joinable()) // если поток еще выполняется
      std::terminate(); // то это баг.

   free_native_thread_handle(this->handle);
}

class Data
{
  public:
    std::queue<std::string> m_data;
    std::string pop()
    {
      const std::string str = m_data.front();
      m_data.pop();
      return str;
    }   
};

    ThreadSharedPtr<Data> oSharedData(new Data);//common data will
    ... = new boost::thread(thread2, oSharedData);
    ....
    oSharedData->m_data.push("handshake");

void thread2(ThreadSharedPtr<Data> oSharedData)
{
    ....
    std::string str = oSharedData->pop();
    ....
}

#include <boost/utility.hpp>
#include <boost/thread/mutex.hpp>

//The class used for lock/unlock m_mutex
//It is a helper. It should be privated class and friend of SharedData,
template <class T>
class SharedDataLocker
{
  public:
    // copy constructor
    SharedDataLocker(const SharedDataLocker& obj)
        : m_mutex       (obj.m_mutex),
          m_ptr         (obj.m_ptr),
          m_nLockCounter(obj.m_nLockCounter)
    {
        assert(0 < m_nLockCounter);
        ++m_nLockCounter;
    }

    SharedDataLocker(boost::mutex& mutex, T* ptr, int& nLockCounter)
        : m_mutex(mutex), m_ptr(ptr), m_nLockCounter(nLockCounter)
    {
        m_mutex.lock();
        assert(0 == nLockCounter);
        ++nLockCounter;//after lock !
    }

    ~SharedDataLocker()
    {
        assert(0 < m_nLockCounter);
        --m_nLockCounter;
        if ( 0 == m_nLockCounter )
        {
          m_mutex.unlock();
        }
    }
  private:
    // forbid use of operator "="
    const SharedDataLocker& operator=( const SharedDataLocker& );
  public:
    T* operator -> ()
    {
        assert(NULL != m_ptr);
        return m_ptr;
    }
  private:
    boost::mutex& m_mutex;
    T*            m_ptr;
    int&          m_nLockCounter;
};


template <class T>
class SharedData : public boost::noncopyable
{
    public:
        SharedData(T* p)
          : m_ptr(p), m_nLockCounter(0)
        {
        }

        ~SharedData()
        {
            delete m_ptr;
        }
    public:
        SharedDataLocker<T> operator -> ()
        {
            return SharedDataLocker<T>(m_mutex, m_ptr, m_nLockCounter);
        }
        T& Unprotected()
        {
            assert(NULL != m_ptr);
            return *m_ptr;
        }
    private:
        boost::mutex m_mutex;
        T*           m_ptr;
        int          m_nLockCounter;
};



template <class T>
class ThreadSharedPtr
{
  public:
    ThreadSharedPtr(T* p)
        : m_SharedMutexAndData(new SharedData<T>(p))
    {
        assert(NULL != p);
    }

    ThreadSharedPtr(const ThreadSharedPtr& obj)
        : m_SharedMutexAndData(obj.m_SharedMutexAndData)
    {
    }

    ~ThreadSharedPtr()
    {
    }
  public:
    ThreadSharedPtr& operator = (const ThreadSharedPtr& obj)
    {
        m_SharedMutexAndData = obj.m_SharedMutexAndData;
        return *this;
    }
  public:
    SharedData<T>& operator -> () const
    {
        assert(NULL != m_SharedMutexAndData.get());
        return *m_SharedMutexAndData;
    }

    T& Unprotected()
    {
        assert(NULL != m_SharedMutexAndData.get());
        return m_SharedMutexAndData->Unprotected();
    }
  private:
    boost::shared_ptr< SharedData<T> > m_SharedMutexAndData;
};

shared_pait<T1, T2> p( new T1, new T2);

shared_pair<T1, T2> p( shared_ptr<T1>( new T1 ), shared_ptr<T2>( new T2 ) );

shared_ptr<T1> p1( new T1);
shared_ptr<T2> p2( new T2);
shared_pair<T1, T2> p( p1, p2 );

unique_pair<T1, T2> p;
p.first = new T1;
p.second = new T2;

shared_pait<T1, T2> p( make_shared<T1>(), make_shared<T2>());

shared_pait<T1, T2> p( new T1, new T2);

shared_pair<T1, T2> p( shared_ptr<T1>( new T1 ), shared_ptr<T2>( new T2 ) );

shared_pair<T1, T2> p{ std::shared_ptr<T1>( new T1 ), std::shared_ptr<T2>( new T2 ) };

very_long_foo()
{
    FILE* file = fopen( ... // не забудь про fclose!!!

    // тут дофига кода

    fclose( file );
}

very_long_foo()
{
    RaiiFile file( ... // не забудь про file.close()!!!

    // тут дофига кода

    file.close( file );
}

typedef std::unique_ptr<X> U;
U p1(new X(1));
U p2(new X(2));
std::pair<U, U> p(std::move(p1), std::move(p2));

typedef std::unique_ptr<X> U;
std::pair<U, U> p{U(new X(1)), U(new X(2))};

E>>Это эквивалентно поддержки реинициализации, и это всё равно надо не забыть сделать...

RO>typedef std::unique_ptr<X> U;
RO>U p1(new X(1));
RO>U p2(new X(2));
RO>std::pair<U, U> p(std::move(p1), std::move(p2));
RO>

pair<U, U> p;
p.first = new X;
p.second = new X;

E>О том, что make_share это уход от концепции RAII, я вообще молчу. Просто что бы не сбивать народ с темы

x(new A, new B)

E>Если всем так рвёт шаблон восприятие сессии редактирования документа, как ресурса, который надо освободить, сохранив изменения на диск, можно рассмотреть стандартный пример, с CFile::Close, который нельзя звать из ~CFile...

class RAII_Deferred
{
    bool fail_on_flush;
public:
    // Normal contrustor
    RAII_Deferred(bool fail_on_flush_) : fail_on_flush(fail_on_flush_)
    {
        cout << "acquiring resource" << endl;
    }
    // Release part of destructor.
    // Herb Sutter: "letting go of a resource" must never fail
    // (http://cpp-next.com/archive/2012/08/evil-or-just-misunderstood/)
    TWO_STAGE_DESTRUCTOR_RELEASE(RAII_Deferred)
    {
        cout << "release resource" << endl;
    }
    // Deferred part of destructor. May fail(for instance fflush).
    // Called when object is destroyed due to normal flow, not stack unwinding
    TWO_STAGE_DESTRUCTOR_DEFERRED(RAII_Deferred)
    {
        cout << "flush pending actions on resource" << endl;
        if(fail_on_flush) throw 1;
    }
};

E>Суть-то проблемы не в том, что ТС идиот и придумал смешной пример, а в том, что многие ресурсы требуют нетривильных действий в конце сессии использования ресурса. И такие ресурсы в С++ версию RAII ложатся плохо. И хорошего ОБОБЩЁННОГО решения, кроме, как отказаться от RAII или перенести его на более высокий уровень -- нет...

{
    File a(/*...*/),b(/*...*/);
    /* ... */
    /* use a and b*/
    b.flush();
    a.flush();
}

{
    File a(/*...*/),b(/*...*/);
    /* ... */
    /* use a and b*/
}

E>Грубо говоря, мы код вида

very_long_foo()
E>{
E>    FILE* file = fopen( ... // не забудь про fclose!!!

E>    // тут дофига кода

E>    fclose( file );
E>}

меняем на код вида

very_long_foo()
E>{
E>    RaiiFile file( ... // не забудь про file.close()!!!

E>    // тут дофига кода

E>    file.close( file );
E>}

И в чём, спрашивается, профит?

E>Потерю открытого файла в случае исключения, которая легко детектится автоматическими средствами тестирования, мы заменили на потерю в случае исключения flush, то есть, возможно, части данных, что в общем случае не детектится никак...

For example, it might be reasonable to simply drop the second exception on the floor and propagate the original one. Before you freak out, consider this: the second exception doesn’t change the unwinding process in any way, at least, not until the exception is caught, and the original failure is still the root cause of the current unwind. The program or the user can likely deal just as well with that root cause without knowing anything about the second exception.

class NotTerminator
{
public:
    void something_throwable()
    {
        throw 0;
    }
    DESTRUCTOR_BUT_NOT_TERMINATOR(NotTerminator)
    {
        something_throwable();
    }
};

E>Только я прошу не скатываться опять в обсуждение того, как оно надо *правильно* работать с файлами. Ресурсов правда много бывает разных. И не все из них закрываются тривиально...

Как ни странно, но мой опыт говорит, что при работе с объектом уровня File исключение не должно произойти нигде

E>... раз две недели роняя ответственный сервер клиента в непонятный момент по терминэйт, без логов и сохранения данных. Прекрасное решение, демонстрирующее всю мощь RAII в кривых руках...

Precondition failures indicate coding errors, which are non-recoverable conditions. Exceptions are for recoverable conditions. No point in unwinding if you won’t be able to recover. In general, you should only throw in response to a precondition failure if you can’t convince your customer that further arbitrarily erroneous (aka undefined) behavior is worse than termination.

#include <boost/test/included/prg_exec_monitor.hpp> 
#include <boost/test/execution_monitor.hpp>
#include <exception>
#include <iostream>
#include <ostream>
 
using namespace std;
 
void myterminate ()
{
  cerr << "terminate handler called\n";
}
int terminator()
{
    terminate();
}
int cpp_main( int, char* [] )
{
    set_terminate(myterminate);
    boost::execution_monitor m;
    try
    {
        m.execute(terminator);
    }
    catch ( boost::execution_exception const& ex )
    {
        cout << "Caught exception: " << ex.what() << endl;
    }
    cout << "Alive!" << endl;
    return 0;
}

struct Foo
{
    UNWINDING_AWARE_DESTRUCTOR(Foo,due_to_unwinding)
    {
        if(due_to_unwinding)
            // ...
        else
            // ...
    }
};

A>Конечно в с++11 есть current_exception(), но проверять и отлавливать свои исключения...

18.8.5/8
current_exception Returns: An exception_ptr object that refers to the currently handled exception

EP>{
EP>    File a(/*...*/),b(/*...*/);
EP>    /* ... */
EP>    /* use a and b*/
EP>    b.flush();
EP>    a.flush();
EP>}
EP>

EP>{
EP>    File a(/*...*/),b(/*...*/);
EP>    /* ... */
EP>    /* use a and b*/
EP>}
EP>

{
    File a(/*...*/),b(/*...*/);
    scope(success)
    {
        b.flush();
        a.flush();
    }
    /* ... */
    /* use a and b*/
}

{
    SCOPE_FAILURE(void) {
        log("could not update user info");
    } SCOPE_FAILURE_END

    File passwd("/etc/passwd");

    SCOPE_SUCCESS( (&passwd) ) {
        passwd.flush();
    } SCOPE_SUCCESS_END

    BOOST_SCOPE_EXIT( (&passwd) ) {
        passwd.close();
    } BOOST_SCOPE_EXIT_END

    // ...
}

#include "stdafx.h"

#include <iostream.h>


struct TestObj {
   virtual ~TestObj() {}
   TestObj() { cout << "Start build obj at 0x" << hex << (int)this << endl; }   
};

struct ThrowInCtor : TestObj {
   ThrowInCtor() { throw 1; }
};

struct ObjOwner {
   ObjOwner( TestObj* p ) { cout << "Take obj: 0x" << hex << (int)p << endl; }
};

void foo( ObjOwner a1, ObjOwner a2 ) {}



int main(int argc, char* argv[])
{
   try {
      foo( new ThrowInCtor, new TestObj );
   } catch( int i ) {
      cout << i << " catched" << endl;
      return i;
   }

    
    return 0;
}

Start build obj at 0x220030
Start build obj at 0x2217d0
1 catched

   ThrowInCtor() { throw 1; }

Start build obj at 0x430030
Start build obj at 0x4317d0
Take obj: 0x430030
Take obj: 0x4317d0

for( int i = 0; i < bib_number; i++ ) {
    MyClass p( x+y+z+QQQ );
    p.Do( i );
}

EP>>{
EP>>    File a(/*...*/),b(/*...*/);
EP>>    /* ... */
EP>>    /* use a and b*/
EP>>    b.flush();
EP>>    a.flush();
EP>>}
EP>>

EP>>{
EP>>    File a(/*...*/),b(/*...*/);
EP>>    /* ... */
EP>>    /* use a and b*/
EP>>}
EP>>

{
KK>    File a(/*...*/),b(/*...*/);
KK>    scope(success)
KK>    {
KK>        b.flush();
KK>        a.flush();
KK>    }
KK>    /* ... */
KK>    /* use a and b*/
KK>}

{
    File a(/*...*/),b(/*...*/);
    SCOPE_SUCCESS(&a,&b)
    {
        b.flush();
        a.flush();
    } SCOPE_SUCCESS_END
    /* ... */
    /* use a and b*/
}

EP>{
EP>    File a(/*...*/),b(/*...*/);
EP>    SCOPE_SUCCESS(&a,&b)
EP>    {
EP>        b.flush();
EP>        a.flush();
EP>    } SCOPE_SUCCESS_END
EP>    /* ... */
EP>    /* use a and b*/
EP>}
EP>

{
    File a(/*...*/),b(/*...*/);
    SCOPE_SUCCESS
    {
        b.flush();
        a.flush();
    };
    /* ... */
    /* use a and b*/
}

EP>>{
EP>>    File a(/*...*/),b(/*...*/);
EP>>    SCOPE_SUCCESS(&a,&b)
EP>>    {
EP>>        b.flush();
EP>>        a.flush();
EP>>    } SCOPE_SUCCESS_END
EP>>    /* ... */
EP>>    /* use a and b*/
EP>>}
EP>>

{
KK>    File a(/*...*/),b(/*...*/);
KK>    SCOPE_SUCCESS
KK>    {
KK>        b.flush();
KK>        a.flush();
KK>    };
KK>    /* ... */
KK>    /* use a and b*/
KK>}

{
    File a(/*...*/),b(/*...*/);
    SCOPE_SUCCESS_ALL(&)
    {
        b.flush();
        a.flush();
    };
    /* ... */
    /* use a and b*/
}

{
    File a(/*...*/),b(/*...*/);
    scope(success)
    {
        b.flush();
        a.flush();
    };
    /* ... */
    /* use a and b*/
}

EP>{
EP>    File a(/*...*/),b(/*...*/);
EP>    SCOPE_SUCCESS_ALL(&)
EP>    {
EP>        b.flush();
EP>        a.flush();
EP>    };
EP>    /* ... */
EP>    /* use a and b*/
EP>}
EP>

{
    File a(/*...*/),b(/*...*/);
    COMMIT_ON_SCOPE_SUCCESS(a, b);
    /* ... */
    /* use a and b*/
}

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <ostream>
#include <cstdio>
#include <stdexcept>
#include <two_stage_destructor.hpp>
using namespace std;

class File
{
    FILE *file_handle;
public:
    explicit File(const char *filename)
    {
        if( (file_handle=fopen(filename,"w"))==0 )
            throw runtime_error("fopen failed");
    }
    void puts(const char *str)
    {
        if(fputs(str,file_handle)<0)
            throw runtime_error("fputs failed");
    }
    TWO_STAGE_DESTRUCTOR_RELEASE(File)
    {
        fclose(file_handle);
    }
    TWO_STAGE_DESTRUCTOR_DEFERRED(File)
    {
        if(fflush(file_handle)!=0)
            throw runtime_error("fflush failed");
    }
};

int main(int,char *[])
{
    try
    {
        File test("out.txt");
        test.puts("Hello");
    }
    catch(const exception &e)
    {
        cout << e.what();
    }
    try
    {
        File test("out2.txt");
        test.puts("Hello2");
        throw runtime_error("test");
    }
    catch(const exception &e)
    {
        cout << e.what();
    }
    return 0;
}

При текущем положении дел, кидание исключений из деструкторов опасное занятие, даже если не брать во внимание технические проблемы — большинство кода просто не рассчитано на исключения из деструкторов. Я не агитирую за необдуманное кидание исключений из деструкторов налево и направо (несмотря на название топика )
Но в то же время, помимо непосредственно деструкции и освобождения ресурсов, на деструкторы навешиваются разного рода отложенные действия, например тот же flush, которые могут фэйлится. Проглатывание всех этих фэйлов по-умолчанию — решение далёкое от идеала.

try
{
    int some_var=1;
    cout << "Case #1: stack unwinding" << endl;
    scope(exit)
    {
        cout << "exit " << some_var << endl;
        ++some_var;
    };
    scope(failure)
    {
        cout << "failure " << some_var << endl;
        ++some_var;
    };
    scope(success)
    {
        cout << "success " << some_var << endl;
        ++some_var;
    };
    throw 1;
} catch(int){}
{
    int some_var=1;
    cout << "Case #2: normal exit" << endl;
    scope(exit)
    {
        cout << "exit " << some_var << endl;
        ++some_var;
    };
    scope(failure)
    {
        cout << "failure " << some_var << endl;
        ++some_var;
    };
    scope(success)
    {
        cout << "success " << some_var << endl;
        ++some_var;
    };
}

E>Это зависит от ОС...

When the application is linked with a debug version of the run-time libraries, abort creates a message box with three buttons: Abort, Retry, and Ignore. If the user clicks Abort, the program aborts immediately. If the user clicks Retry, the debugger is called and the user can debug the program if just-in-time (JIT) debugging is enabled. If the user clicks Ignore, abort continues with its normal execution: creating the message box with the OK button.

abort also invokes an error reporting mechanism to report failures to Microsoft. This behavior can be disabled by calling _set_abort_behavior.

template <bool Condition, typename T = void>
using enable_if = typename enable_if_impl<Condition, T>::type;

KK>Ты меня окончательно запутал Давай ещё раз по порядку.

Одним из вариантов является введение понятия отложенных действий

Автор: Evgeny.Panasyuk
Дата: 01.10.12

, что позволяет чётко разграничить непосредственно освобождение ресурсов(которое не фейлится) и различные нетривиальные действия над этими ресурсами, которые выполняются перед их освобождением и по сути своей могут фейлится.

template <bool Condition, typename T = void>
KK>using enable_if = typename enable_if_impl<Condition, T>::type;