Re: Creating threads in C vs C++

From:

Rolf Magnus <ramagnus@t-online.de>

Newsgroups:

comp.lang.c++

Date:

Sat, 09 Jan 2010 20:08 +0100

Message-ID:

<hiak6g$ibc$02$1@news.t-online.com>

James Kanze wrote:

You actually often need a double conversion when calling
pthread_create (and other, similar functions). Basically, if
you convert to void*, the only legal conversion is back to the
type you converted. And in the simplest case, you will have
just constructed a derived class (and have a pointer to it),
but will cast back to the base class, in order to call a virtual
function. So you need to ensure that the pointer you convert to
void* is a pointer to the base class, not to the derived class.

The typical implementation that I know is based roughly on something like
that:

class Thread
{
public:
    // ...
    void run()
    {
        // ...
        pthread_create(&tid, 0, thread_helper, this);
    }
private:
    virtual void doit() = 0;

    pthread_t* tid;
};

extern "C"
void* thread_helper(void* arg)
{
    static_cast<Thread*>(arg)->doit();
    return arg;
}

Then you derive from Thread and implement the doit() function. Doesn't get
much simpler than that, and you get a conversion from a Thread* to void* and
back to Thread*.

BTW: When implementing something like that, I noticed that C++ lacks a way
of defining functions with internal C linkage. I'd usually make a function
like thread_helper static (or, if it were a C++ function, put it in an
unnamed namespace), but I have to make the linkage extern to make it a C
function, and there is no such thing as static "C" or extern "C" static.