Re: Trick to prevent conversion

(I'm simplifying this problem greaty in the following code but you get
the idea)

I have a class something like:

class Processor {
public:
    unsigned GetCurrentProcess(void);
    unsigned GetCurrentThread(void);

    void DoSomethingWithProcess(unsigned process_id);
    void DoSomethingWithThread(unsigned thread_id);
};

    The function, GetCurrentProcess, returns an unsigned integer value
which represents a process.
    The function, GetCurrentThread, returns an unsigned integer value
which represents a thread.

The problem is, that it's very easy to mistakenly take the value from
GetCurrentProcess and pass it as an argument to DoSomethingWithThread.
(I've done it already!). Therefore, I want two different types for these
identifiers, two types that can't convert to each other. At the moment I
have the following:

class Processor {
public:

    struct ProcessHandle { unsigned i; };
    struct ThreadHandle { unsigned i; };

    ProcessHandle GetCurrentProcess(void);
    ThreadHandle GetCurrentThread(void);

    void DoSomethingWithProcess(ProcessHandle process_id);
    void DoSomethingWithThread(ThreadHandle thread_id);
};

Of course, this does the trick. But I'm wondering if there's a more
elegant way of doing it? What other methods are there for making types
incompatible with each other?

(My actual code is far more complicated than this -- obviously I wouldn't
be very competant if I made such a stupid mistake in code as simple as
this).