#include <windows.h>
#include <iostream>
#include <sstream>
#include <process.h>

namespace TST
{
    class Exception
    {
    public:
        Exception(const wchar_t* szwText)
            :   m_wstrText(szwText)
        {;};

        std::wstring What() const throw()
        {
            return m_wstrText;
        };

    protected:
        const std::wstring m_wstrText;
    };

    void le_chk(BOOL bResult, const char* file, int line)
    {
        if(!bResult)
        {
            std::clog << "An error " << GetLastError() << "occured";
            std::wostringstream os;
            os  << L"Win32 error occured: GetLastError returned " << GetLastError() 
                << " in " << file << L"@" << line;
            throw Exception(os.str().c_str());
        };
    };

    #define TST_LE_CHECK(res)   le_chk((res), __FILE__, __LINE__)

    class CallBase
    {
    public:
        virtual void Call() = 0;
    };

    class AsyncActionBase
    {
    public:
        AsyncActionBase(CallBase* pCall)
            :   m_hThread(NULL)
        {
            unsigned uId = 0;
            m_hThread = (HANDLE)_beginthreadex(
                            NULL, 0, &AsyncActionBase::thread_proc, 
                            (void*)pCall, 0, &uId);
            TST_LE_CHECK(!!m_hThread);
        };

        virtual ~AsyncActionBase()
        {
            if(m_hThread)
            {
                TST_LE_CHECK(WaitForSingleObject(m_hThread, INFINITE) 
                    != WAIT_FAILED);
                TST_LE_CHECK(CloseHandle(m_hThread));
                m_hThread = NULL;
            };
        };
    protected:
        static unsigned __stdcall thread_proc(void * p)
        {
            try
            {
                ((CallBase*)p)->Call();
            }
            catch (const TST::Exception& excpt)
            {
                std::wcerr << excpt.What();
            };
            return 0;
        };
        HANDLE m_hThread;
    };

    class MyAsyncAction1
        :   public CallBase
        ,   public AsyncActionBase
    {
    public:
        MyAsyncAction1()
            :   AsyncActionBase(this)
        {
            ;
        };
        
        virtual ~MyAsyncAction1()
        {
            ;
        };

    //CallBase
        virtual void Call()
        {
            for(size_t i = 0; i < 100; ++i)
            {
                std::cout << "Test #" << (i+1) << std::endl;
                Sleep(10);
            };
        };
    };
};

int main()
{
    try
    {
        TST::MyAsyncAction1 oBj;
    }
    catch (const TST::Exception& excpt)
    {
        std::wcerr << excpt.What();
    };
};

AD>#include <windows.h>
AD>#include <iostream>
AD>#include <sstream>
AD>#include <process.h>

AD>namespace TST
AD>{
AD>    class Exception
AD>    {
AD>    public:
AD>        Exception(const wchar_t* szwText)  // должен быть explicit
AD>            :   m_wstrText(szwText)
AD>        {;};  // лишние точки с запятой

AD>        std::wstring What() const throw()  // throw() зло
AD>        {
AD>            return m_wstrText;
AD>        };  // лишние точки с запятой

AD>    protected:
AD>        const std::wstring m_wstrText;
AD>    };

AD>    void le_chk(BOOL bResult, const char* file, int line)  // неудачное имя функции
AD>    {
AD>        if(!bResult)
AD>        {
AD>            std::clog << "An error " << GetLastError() << "occured";  // неконсистентная табуляция
AD>            std::wostringstream os;
AD>            os  << L"Win32 error occured: GetLastError returned " << GetLastError()  // два вызова GetLastError подряд, и не факт, что предыдущий вывод в clog на них не влияет
AD>                << " in " << file << L"@" << line;
AD>            throw Exception(os.str().c_str());
AD>        };  // лишние точки с запятой
AD>    };  // лишние точки с запятой

AD>    #define TST_LE_CHECK(res)   le_chk((res), __FILE__, __LINE__)

AD>    class CallBase
AD>    {
AD>    public:
AD>        virtual void Call() = 0;
AD>    };

AD>    class AsyncActionBase
AD>    {
AD>    public:
AD>        AsyncActionBase(CallBase* pCall)  // explicit
AD>            :   m_hThread(NULL)
AD>        {
AD>            unsigned uId = 0;
AD>            m_hThread = (HANDLE)_beginthreadex(  // C-style cast. Должен быть reinterpret_cast
AD>                            NULL, 0, &AsyncActionBase::thread_proc, 
AD>                            (void*)pCall, 0, &uId);  // C-style cast. Должен быть static_cast
AD>            TST_LE_CHECK(!!m_hThread);
AD>        };  // лишние точки с запятой

AD>        virtual ~AsyncActionBase()
AD>        {
AD>            if(m_hThread)
AD>            {
AD>                TST_LE_CHECK(WaitForSingleObject(m_hThread, INFINITE) 
AD>                    != WAIT_FAILED);  // деструкторы, бросающие исключения — зло
AD>                TST_LE_CHECK(CloseHandle(m_hThread));  // деструкторы, бросающие исключения — зло
AD>                m_hThread = NULL;
AD>            };  // лишние точки с запятой
AD>        };  // лишние точки с запятой
AD>    protected:
AD>        static unsigned __stdcall thread_proc(void * p)  // protected static — это для кого?
AD>        {
AD>            try
AD>            {
AD>                ((CallBase*)p)->Call();  // C-style cast. Должен быть static_cast
AD>            }
AD>            catch (const TST::Exception& excpt)
AD>            {
AD>                std::wcerr << excpt.What();
AD>            };  // лишние точки с запятой
AD>            return 0;
AD>        };  // лишние точки с запятой
AD>        HANDLE m_hThread;
AD>    };

AD>    class MyAsyncAction1
AD>        :   public CallBase
AD>        ,   public AsyncActionBase
AD>    {
AD>    public:
AD>        MyAsyncAction1()
AD>            :   AsyncActionBase(this)  // this ещё не сконструирован, а AsyncActionBase уже вызывает на него Call
AD>        {
AD>            ;  // лишние точки с запятой
AD>        };  // лишние точки с запятой
        
AD>        virtual ~MyAsyncAction1()
AD>        {
AD>            ;  // лишние точки с запятой
AD>        };  // лишние точки с запятой

AD>    //CallBase
AD>        virtual void Call()
AD>        {
AD>            for(size_t i = 0; i < 100; ++i)
AD>            {
AD>                std::cout << "Test #" << (i+1) << std::endl;  // лучше было бы крутить цикл от 1 до <=100 и выводить i
AD>                Sleep(10);
AD>            };  // лишние точки с запятой
AD>        };  // лишние точки с запятой
AD>    };
AD>};  // лишние точки с запятой

AD>int main()
AD>{
AD>    try
AD>    {
AD>        TST::MyAsyncAction1 oBj;
AD>    }
AD>    catch (const TST::Exception& excpt)
AD>    {
AD>        std::wcerr << excpt.What();
AD>    };  // лишние точки с запятой
AD>};  // лишние точки с запятой

AD>Код давали одной знакомой в качестве теста — судя по тому, что я полностью был с ней согласен — я ошибки не нашел тоже (или нашел, но не те

Сидит программист глубоко в отладке.
Подходит сынишка:
— Папа, почему солнышко каждый день встает на востоке, а садится на западе?
— Ты это проверял?
— Проверял.
— Хорошо проверял?
— Хорошо.
— Работает?
— Работает.
— Каждый день работает?
— Да, каждый день.
— Тогда ради Бога, сынок, ничего не трогай, ничего не меняй!

    class MyAsyncAction1 : public CallBase, public AsyncActionBase
    {
    public:
        MyAsyncAction1() : AsyncActionBase(this)
        {
        };
       
        virtual ~MyAsyncAction1()
        {
        };

    //CallBase
        virtual void Call()
        {
            for(size_t i = 0; i < 100; ++i)
            {
                std::cout << "Test #" << (i+1) << std::endl;
                Sleep(10);
            };
        };
    };

    class MyAsyncAction1 : public CallBase, public AsyncActionBase
    {
    public:
        MyAsyncAction1() : AsyncActionBase(this)
        {
        };
       
        virtual ~MyAsyncAction1()
        {
            std::cout << m_out.str();
        };

    //CallBase
        virtual void Call()
        {
            for(size_t i = 0; i < 100; ++i)
            {
                m_out << "Test #" << (i+1) << std::endl;
                Sleep(10);
            };
        };
    private:
        std::ostringstream m_out;
    };

    class MyAsyncAction1 : public CallBase, public AsyncActionBase
    {
    public:
        MyAsyncAction1() : AsyncActionBase(this) // вот в этой точке,
                                                                         // даже ещё раньше, в конструкторе AsyncActionBase,
                                                                         // система начала запуск потока, который
                                                                         // вызовет Call() этого объекта.
                                                                         // Компилятор MS умеет создавать виртуальную
                                                                         // таблицу до создания объекта, так что вызовется именно MyAsyncAction1::Call().
                                                                         // Создание нового потока в Windows процедура долгая, так что весьма вероятно,
                                                                         // что этот конструктор успеет отработать до вызова MyAsyncAction1::Call() из
                                                                         // параллельного потока, но полагаться на это нельзя. Теоретически
                                                                         // возможен вызов MyAsyncAction1::Call() до создания m_out, что приведёт
                                                                         // к UB последствиям.
        {
        };
       
        virtual ~MyAsyncAction1()
        {
            std::cout << m_out.str();
        };// Вот в этой точке сначала вызовется деструктор m_out и m_out будет разрушен, а потом вызовется 
           // деструктор ~AsyncActionBase() в котором текущий поток будет ждать завершения работы MyAsyncAction1::Call().
           // Возможны два варианта: 1) поток, в котором выполнялся MyAsyncAction1::Call() уже завершился к этому моменту,
           // тогда всё завершится обычным образом. Но возможен и вариант 2) когда MyAsyncAction1::Call() продолжает
           // выполнятся после разрушения m_out. Это ведёт к UB.

    //CallBase
        virtual void Call()
        {
            for(size_t i = 0; i < 100; ++i)
            {
                m_out << "Test #" << (i+1) << std::endl;
                Sleep(10);
            };
        };
    private:
        std::ostringstream m_out;
    };

C>время жизни потока и объекта никак не связанны

#include <windows.h>  // такого монстра как "windows.h" лучше выносить в прекомпайл
#include <iostream>   // ...
#include <sstream>    // ...
#include <process.h>  // ...

namespace TST
{
    class Exception // не наследуется от std::exception
    {
    public:
        Exception(const wchar_t* szwText)
            :   m_wstrText(szwText)
        {;}; // мусор: ";"

        std::wstring What() const throw() // реально бросает исключение, возврящает по значению (c++11?)
        {
            return m_wstrText;
        }; // мусор: ";"

    protected:
        const std::wstring m_wstrText;
    };

    void le_chk(BOOL bResult, const char* file, int line) // если это в хедере то стоит добавить inline
    {
        if(!bResult)
        {
            std::clog << "An error " << GetLastError() << "occured";
            std::wostringstream os;
            os  << L"Win32 error occured: GetLastError returned " << GetLastError() 
                << " in " << file << L"@" << line; // неоправданно смешанны "" и L"", для file есть макрос __FILEW__
            throw Exception(os.str().c_str());
        }; // мусор: ";"
    };// мусор: ";"


    #define TST_LE_CHECK(res)   le_chk((res), __FILE__, __LINE__)

    class CallBase
    {
    public:
        virtual void Call() = 0;
    }; // а где виртуальный деструктор?

    class AsyncActionBase
    {
    public:
        AsyncActionBase(CallBase* pCall)
            :   m_hThread(NULL)
        {
            unsigned uId = 0;
            m_hThread = (HANDLE)_beginthreadex( // зачем (чтоб закрыть с CloseHandle(?)) пользоваться _beginthreadex и плодить не нужные сущьности uId, когда есть _beginthread
                            NULL, 0, &AsyncActionBase::thread_proc, 
                            (void*)pCall, 0, &uId);
            TST_LE_CHECK(!!m_hThread); // _beginthreadex это не CreateThread(), и GetLastError() тут бесполезен; смотреть _get_errno, и внимание сюрприз: returns -1L on an error
        }; // мусор: ";"

        virtual ~AsyncActionBase()
        {
            if(m_hThread)
            {
                TST_LE_CHECK(WaitForSingleObject(m_hThread, INFINITE) 
                    != WAIT_FAILED); // исключения в деструкторе = зло
                TST_LE_CHECK(CloseHandle(m_hThread)); // исключения в деструкторе = зло
                m_hThread = NULL;
            }; // мусор: ";"
        }; // мусор: ";"
    protected:
        static unsigned __stdcall thread_proc(void * p)
        {
            try
            {
                ((CallBase*)p)->Call(); // вызов pure virtual функции, объект ещё не построился...
            }
            catch (const TST::Exception& excpt)
            {
                std::wcerr << excpt.What();
            }; // мусор: ";"
            return 0;
        }; // мусор: ";"
        HANDLE m_hThread;
    };

    class MyAsyncAction1
        :   public CallBase
        ,   public AsyncActionBase
    {
    public:
        MyAsyncAction1()
            :   AsyncActionBase(this)
        {
            ;  // мусор: ";"
        }; // мусор: ";"
        
        virtual ~MyAsyncAction1()
        {
            ; // не дожидаемся остановки потока, соответственно на выходе разрушаем объект с которым он работает в virtual void Call()
        }; // мусор: ";"

    //CallBase
        virtual void Call()
        {
            for(size_t i = 0; i < 100; ++i)
            {
                std::cout << "Test #" << (i+1) << std::endl; // лучше от (=1 до <=100)
                Sleep(10);
            }; // мусор: ";"
        }; // мусор: ";"
    };
}; // мусор: ";"

int main()
{
    try
    {
        TST::MyAsyncAction1 oBj;
    }
    catch (const TST::Exception& excpt)
    {
        std::wcerr << excpt.What();
    }; // мусор: ";"
}; // мусор: ";"

AD>            :   AsyncActionBase(this)  // this ещё не сконструирован, а AsyncActionBase уже вызывает на него Call

Don't embed a std::string object or any other data member or base class whose copy constructor could throw an exception. That could lead directly to std::terminate() at the throw point. Similarly, it's a bad idea to use a base or member whose ordinary constructor(s) might throw, because, though not necessarily fatal to your program, you may report a different exception than intended from a throw-expression that includes construction such as:

throw some_exception();

There are various ways to avoid copying string objects when exceptions are copied, including embedding a fixed-length buffer in the exception object, or managing strings via reference-counting. However, consider the next point before pursuing either of these approaches.

C>>время жизни потока и объекта никак не связанны

C>    class CallBase
C>    {
C>    public:
C>        virtual void Call() = 0;
C>    }; // а где виртуальный деструктор?
C>

C>    class AsyncActionBase
C>    {
C>    public:
C>        AsyncActionBase(CallBase* pCall)
C>            :   m_hThread(NULL)
C>        {
C>            unsigned uId = 0;
C>            m_hThread = (HANDLE)_beginthreadex( // зачем (чтоб закрыть с CloseHandle(?)) пользоваться _beginthreadex и плодить не нужные сущьности uId, когда есть _beginthread
C>                            NULL, 0, &AsyncActionBase::thread_proc, 
C>                            (void*)pCall, 0, &uId);
C>

C>            TST_LE_CHECK(!!m_hThread); // _beginthreadex это не CreateThread(), и GetLastError() тут бесполезен; смотреть _get_errno, и внимание сюрприз: returns -1L on an error
C>        }; // мусор: ";"
C>

Remarks

...
_beginthreadex returns 0 on failure, rather than -1L.
...

AD>>>            :   AsyncActionBase(this)  // this ещё не сконструирован, а AsyncActionBase уже вызывает на него Call

Before the lifetime of an object has started but after the storage which the object will occupy has been allocated […] any pointer that refers to the storage location where the object will be or was located may be used but only in limited ways. For an object under construction or destruction, see 12.7.[…]

To explicitly or implicitly convert a pointer (a glvalue) referring to an object of class X to a pointer (reference) to a direct or indirect base class B of X, the construction of X and the construction of all of its direct or indirect bases that directly or indirectly derive from B shall have started and the destruction of these classes shall not have completed, otherwise the conversion results in undefined behavior.

Member functions, including virtual functions (10.3), can be called during construction or destruction (12.6.2). […] If the virtual function call uses an explicit class member access (->) and the object expression refers to the complete object of x or one of that object’s base class subobjects but not x or one of its base class subobjects, the behavior is undefined.

AD>Код давали одной знакомой в качестве теста — судя по тому, что я полностью был с ней согласен — я ошибки не нашел тоже (или нашел, но не те

AD>    class Exception
AD>    {
AD>    public:
AD>        Exception(const wchar_t* szwText)
AD>            :   m_wstrText(szwText)
AD>        {;};
...
AD>    protected:
AD>        const std::wstring m_wstrText;
AD>    };
AD>

KO>>Теоретически, всё верно, но на практике оказалось что это не так уж и чревато: большая система, куча legacy кода с более чем 10 летней историей, куча абстрактных классов без виртуальных или защищенных деструкторов и ни одной вызванной этим ошибки. В общем, правильная архитектура оказалась полезней следованию советов из книжки, которой ещё не было когда этот код начинали писать.

Значение виртуальных деструкторов сильно преувеличено, при использовании умных указателей, знающих как удалять объект (например, boost::shared_ptr/std::shared_ptr) можно прекрасно обходиться без виртуальных деструкторов.

There is no substitute for intelligence, experience, common sense, and good taste.

The Microsoft-specific __declspec(novtable) option instructs the compiler not to initialize the virtual function pointer in the constructor of the given object. Normally, this would be a "bad thing." However, for abstract classes, there's no reason to initialize the pointer, because it will always be properly initialized when a concrete class derived from the object is constructed.

By the way, this option is misnamed. It sounds like it removes the vtable itself, which isn't at all true. The option should be called noinitvtable.