从 void * 转换时的 C++ 多态性问题

Question

我有以下代码:

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

static DWORD __stdcall startThread(void *);

class BaseClass {
private:

    void threadLoop() {
        // stuff ...
        std::cout << someStuff() << std::endl;
        // stuff ...
    }
protected:
    HANDLE handle;
    virtual int someStuff() {
        return 1;
    }
public:
    friend DWORD __stdcall startThread(void *);

    BaseClass() {
        handle = 0;
    };

    void start() {
        handle = CreateThread(NULL, 0, startThread, this, 0, NULL);
    }

    ~BaseClass() {
        if(handle != 0) {
            WaitForSingleObject(handle, INFINITE);
            CloseHandle(handle);
        }
    }
    // stuff
};

static DWORD __stdcall startThread(void *obj_) {
    BaseClass *obj = static_cast<BaseClass *>(obj_);

    obj->threadLoop();
    return 0;
}

class DerivedClass : public BaseClass {
public:
    virtual int someStuff() {
        return 2;
    };
};

int main() {
    BaseClass base;
    base.start();
    DerivedClass derived;
    derived.start();
}

每个实例都使用 WINAPI 和辅助函数 startThread 创建一个线程，该函数将调用委托(delegate)回创建线程的对象的方法 threadLoop。现在的问题是 threadLoop 调用了另一个虚方法，但是如果我使用虚方法的其他实现创建派生类，多态性似乎不起作用。

为什么？我该如何解决这个问题？

编辑:我更新了代码，所以线程没有在构造函数中启动。

Answer 1

您在完成构造之前启动线程派生对象。这是未定义的行为(因为你会您可能正在访问新线程中的对象仍在创建线程中执行代码)。你必须单独构造和启动线程。

编辑:

处理此类问题的一种方法:

class Threadable
{
public:
    virtual Threadable() {}
    virtual run() = 0;
};

DWORD __stdcall startThread( void* object )
{
    static_cast<Threadable*>( object )->run();
}

class Thread
{
    std::auto_ptr<Threadable> myThread;
    HANDLE myHandle;
public:
    Thread( std::auto_ptr<Threadable> thread )
        : myThread( thread )
        , myHandle( CreateThread( NULL, 0, startThread, myThread.get(), 0, NULL ) )
    {
    }
    ~Thread()
    {
        if ( myHandle != NULL ) {
            WaitForSingleObject( myHandle, INFINITE );
            CloseHandle( myHandle );
        }
    }
};

然后让您的 BaseClass 和 DerivedClass 派生自Threadable，并将它们调用为:

Thread base( std::auto_ptr<Threadable>( new BaseClass ) );
Thread derived( std::auto_ptr<Threadable>( new DerivedClass ) );

这并不完美(我不喜欢或多或少地无限等待析构函数)，但它应该足以开始。 (模数上面代码中的任何拼写错误——我没有测试过。)