Trick to prevent conversion

[Tomás Ó hÉilidhe]

(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).

--
Tomás Ó hÉilidhe

[Victor Bazarov]

Tomás Ó hÉilidhe wrote:

(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);

If you can, perhaps you would get in the habit of omitting 'void'
for a function with no arguments. I know I'd appreciate it because
your code would be easier to read and understand.

Also, it seems that those functions should perhaps be 'const'. If
they don't change anything in 'Processor', of course.

>
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?

Enums.

(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).

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[tragomaskhalos]

On 11 Jan, 19:18, "Tomás Ó hÉilidhe" <[e-mail]:

>
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?

I think this is a pretty good way of doing it. One way of making it
a bit more elegant/generic would be something like this
(warning - untested):

template <typename W, class TAGclass TypeWrapper {
W myWrapped;
public:
explicit TypeWrapper(W wrapped) : myWrapped(wrapped) {}
W getWrapped() { return myWrapped; }
};

#define TYPE_WRAPPER(W, X) \
struct X##Tag{}; \
typedef TypeWrapper<W, X##TagX

This could be in a generic header file, then you could say:
// define types ...
TYPE_WRAPPER(unsigned, ProcessHandle);
TYPE_WRAPPER(unsigned, ThreadHandle);

// use them
ProcessHandle ph(some_unsigned_var);
unsigned x = ph.getWrapped();
// etc but
ThreadHandle th = ph; // fails to compile

[Tomás Ó hÉilidhe]

tragomaskhalos <da*************@logicacmg.comwrote in news:b3fd120e-
46*************************@k2g2000h...legroup s.com:

I think this is a pretty good way of doing it. One way of making it
a bit more elegant/generic would be something like this
(warning - untested):

template <typename W, class TAGclass TypeWrapper {
W myWrapped;
public:
explicit TypeWrapper(W wrapped) : myWrapped(wrapped) {}
W getWrapped() { return myWrapped; }
};

#define TYPE_WRAPPER(W, X) \
struct X##Tag{}; \
typedef TypeWrapper<W, X##TagX

This could be in a generic header file, then you could say:
// define types ...
TYPE_WRAPPER(unsigned, ProcessHandle);
TYPE_WRAPPER(unsigned, ThreadHandle);

// use them
ProcessHandle ph(some_unsigned_var);
unsigned x = ph.getWrapped();
// etc but
ThreadHandle th = ph;

Honestly I think that's a bit much. Firstly, I'd want the type to remain
a POD, so constructors and private data are out the window. Also I
wouldn't want member functions coming into it.

I think I was right on track with my struct solution.
--
Tomás Ó hÉilidhe

[Jack Klein]

On Fri, 11 Jan 2008 19:18:05 GMT, "Tomás Ó hÉilidhe" <to*@lavabit.com>
wrote in comp.lang.c++:

>
(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).

Why not two enumeration types, suitably defined so that hold the value
range you want, i.e.:

enum process_id { process_id_min = 0, process_id_max = UINT_MAX };
enum thread_id { thread_id_min = 0, process_id_max = UINT_MAX };

Modify your functions to accept and receive the enumerated types, with
suitable static_casts to and from unsigned int, as needed, inside the
functions, invisible to the caller. Modify your callers who get the
values to accept the appropriate enumeration type.

A C++ compiler will reject code where a caller retrieves a process_id
from one function and attempts to pass it to another that needs a
thread_id.

I even use this technique in C, where any decent compiler will warn
about mixing different enumeration types even though the language
permits it.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.club.cc.cmu.edu/~ajo/docs/FAQ-acllc.html

[Tomás Ó hÉilidhe]

=?UTF-8?B?RXJpayBXaWtzdHLDtm0=?= <Er***********@telia.comwrote in
news:5c*****************@newsb.telia.net:

IF you do not want them to be mixed up you must use different types
for them, creating new types are done using class, struct, or enum. An
alternative is to use run-time checks, so instead of using indexes you
use handles (which could be unsigned ints) where each handles value is
some reversible function of both the type and the index, something
like:

unsigned getThreadHandle(unsigned index);
unsigned getThreadIndex(unsigned handle);

And if you pass a non-thread handle to getThreadIndex an exception is
thrown.

Only problem is that 3 could be a valid value for both an index and a
handle.

So far I'm still sticking with the simple struct method.

--
Tomás Ó hÉilidhe