Re: Replacing a void* in C++
On Sep 29, 5:11 am, "Jim Langston" <tazmas...@rocketmail.com> wrote:
"Chris ( Val )" <chris...@gmail.com> wrote in messagenews:1190978575.003843.327370@22g2000hsm.googlegroups.com...
On Sep 28, 10:33 am, "Jim Langston" <tazmas...@rocketmail.com> wrote:
I am using some code that I got that uses a form a message dispatching
where
the data is passed via a void*. I don't like void*'s so am experimenting
with a different way to do them in C++. I don't use boost, and this is
what
I've come up with so far, but it seems fairly ugly.
In actual use the final handler that handles the data would know what
type
the data should be based on other paramaters in the function call, so
this
is just proof of concept.
Has anyone a better idea? I tend to like MessageHandler2 using a
reference
instead of a pointer.
I don't completely understand why you require 2 classes, but you
could look into template specialisation to see if that helps you.
I just wanted to make the point that unless it has changed in the
recent standard, relying on an accurate string from the 'typeid'
"name()" member is not reliable, and implementation dependant; if
a string is returned at all.
Additionally, I don't think it is being used effectively the way
you have it.
For example, the construct "typeid( float ).name()" will always
produce the same hard coded result on one side of the evaluation,
provided a valid result is available for evaluation.
Much better to use something like the following, so you're
not bound to that hard coded construct:
template<typename A, typename B> bool isEqual( A a, B b ) {
return typeid( a ) == typeid( b );
}
int main()
{
char A(0);
int B(0);
long C(0);
std::cout << std::boolalpha << isEqual( A, A ) << '\n';
std::cout << std::boolalpha << isEqual( A, B ) << '\n';
std::cout << std::boolalpha << isEqual( A, C ) << '\n';
return 0;
}
-- OUTPUT --
true
false
false
I would rather not hard code any types at all. I'm working with existing
code that recieves messages such as:
bool MinerGlobalState::OnMessage(Miner* pMiner, const Telegram& msg)
With Telegram defined as:
struct Telegram
{
int Sender;
int Receiver;
int Msg;
double DispatchTime;
void* ExtraInfo;
// constructor etc...
}
It is the void* ExtraInfo I am trying to make a little more friendly. In the
OnMessage I have to do things such as:
int Amount = *reinterpret_cast<int*>( msg.ExtraInfo );
Which, okay, usually, is okay. But, somewhere someone may have stuck an int
in there instead of a float or such. Not very typesafe. And I don't like
the reinterpret_cast.
[snip]
What are the data types are you only interested
in accepting?
When you say "instead of a float", does that mean
you require floats and floates only? or are doubles
legal according to your spec as well?
The reason I ask, is because I think your biggest
problem happens well before the OnMessage member
function.
Personally, I would stop the client entering the
wrong data type to begin with, and set up a
constraint to dissallow the wrong types to be
entered from the word go.
You could use teamplates and function overloading
to do this. Or even capture the data into a
std::stringstream object and sort it out from
there.
[snip]
The existing code I'm working with has many source files and I don't really
want to have to redesign the whole class heirarchy to use the visitor
pattern, and also there may be a case where one message handler may need to
have the ExtraInfo as different typed depending on the Msg paramater of the
Telegram.
That visitor pattern looks different to ones
that I've seen in the past :-)
It is just a simple function acting polymorphically.
--
Chris Val