Re: Is void* as key a bad idea?

From:

DeMarcus <use_my_alias_here@hotmail.com>

Newsgroups:

comp.lang.c++

Date:

Fri, 19 Feb 2010 11:29:16 +0100

Message-ID:

<4b7e67fc$0$275$14726298@news.sunsite.dk>

Alf P. Steinbach wrote:

* DeMarcus:

Alf P. Steinbach wrote:

* Leigh Johnston:

All that's needed is inheritance.

Example? And don't say virtual inheritance.

Please quote enough of the article you're responding to to establish
the necessary context for your response. Not all readers have easy
access to the thread history.

Anyway, you're asking for and doubting the existence of this problem:

  #include <assert.h>

  struct A
  {
      int blah;
  };

  struct B: A
  {
      virtual ~B() {}
      int doh;
  };

  int main()
  {
      B* p1 = new B;
      A* p2 = p1;
      void* pv1 = p1;
      void* pv2 = p2;

      assert( pv1 == pv2 ); // Uh oh, not guaranteed.
  }

To some C++ programmers it comes as a surprise.

Note that the introduction of a virtual destructor in the derived
class is not necessary in order to have this problem, except that
with that it's easier to convince folks since then the assertion
fails with two popular compilers.

How can I solve this to always be safe? Would a base class solve
everything?

struct A
{
   int a;
};

struct B : A
{
   virtual ~B() {}
   int b;
}

struct C : A
{
   virtual ~C() {}
   int c;
}

struct D : B, C
{
   virtual ~D() {}
   int d;
}

int main()
{
   B* b = new B;
   A* a = b;

   assert( a == b );

   C* c = new C;
   a = c;

   assert( a == c );

   D* d = new D;
   a = d;

   assert( a == d );

}

Yes, it's one solution. Here the pointers are all converted up to A*,
and adjusted appropriately (which is one important difference between
static_cast and reinterpret_cast; the latter is not guaranteed to
adjust). Another solution is as mentioned to have all classes
polymorphic and use dynamic_cast<void*> to obtain pointer to most
derived object.

Cheers & hth.,

- Alf

Thanks for the insight!! Before I just went on with my void*, but after
a while I felt that there might be a small possibility of problems using
void*, hence I posted this thread. At least my intuition works sometimes. ;)

You brought light to my problem. Thanks!