Is it safe to cast from a pointer to a child variable to a pointer to a parent variable?

Question

The following code works (on ideone, Borland BCB 6 and gcc)

#include <stdio.h>

class Base {
private:
    Base **BPtr;
public:
    Base(void *Ptr) {
        BPtr = (Base **)Ptr;
        *BPtr = this;
    }

    virtual ~Base() {
        if(BPtr) *BPtr = NULL;
        printf("Base aufgelöst\n");
    }
};

class Child : public Base {
    public:
    Child(void *Var) : Base(Var) {}
    ~Child() {
        printf("Child aufgelöst\n");
    }
};

int main() {
    Child *Ptr = NULL;
    new Child(&Ptr);
    printf("Childptr: %p\n", Ptr);
    delete Ptr;
    printf("Childptr: %p\n", Ptr);
    return 0;
}

The output of above program is:

Childptr: 0x9cc0008
Child aufgelöst
Base aufgelöst
Childptr: (nil)

which is exactly what I expected and want.

My question is simple: Is this actually safe or does it only seem to work? Because it does feel a little bit hacky to first implicitly cast a Pointer of type Child to a void * and then cast it to a Base ** or are there any obvious (or hidden) problems with this?

Thank you very much.

Edit: Since there seemed to a bit of a misunderstanding regarding my intention:

The sole purpose of this 'hack' is to NULL the variable in question, once the object gets destroyed to protect myself against accidentally forgetting to NULL the variable manually and possibly accessing invalid memory later on.

The variable must and will not be used to access any other functionality of the classes.

However, what I also tried (and worked) before was the following:

void FreeFunc(void *Ptr) {
    if(Ptr) {
        Base **BPtr = (Base **)Ptr;
        delete *Ptr;    //Calls Destructors
        *Ptr = NULL;
    }
}

Which appears to be even worse from the replies I had been getting on here so far?

Answer 1

Casting a Child * to a Base * is safe. Casting a Child** to a Base** is not because those are unrelated. The problem with doing this is that if I cast to void * then to Base**, I can now assign a Base * to a pointer of type Derived *, like this:

#include <iostream>

class Base
{
public:
    virtual void Foo() { std::cout << "Base::Foo" << std::endl; }
};

class Child : public Base
{
public:
    virtual void Foo() { std::cout << "Child::Foo" << std::endl; }
    virtual void Bar() { std::cout << "Child::Bar" << std::endl; }
};


void main()
{
    Child *d = new Child();
    Base *b = d;

    Child **d2 = &d;
    Base **b2 = (Base **)(void *)d2; // Force it

    *b2 = new Base(); // Whoops!  Child *d now points to an instance of Base *

    d->Bar();
}

Answer 2

What would happen if:

1. Any of the Base functions call some other member func (either of Base or of Child? Virtual or non-virtual.

2. And what is the guarantee that the void *points to the Child* ? For ex: nothing prevents us to write in main:

   void *pv; new Child(pv);

These should point to say that such type cast is not guaranteed.

If we really need typecasting base<->derived, RTTI is the mechanism. Also see wiki for RTTI:

Answer 3

You can check, if the the void* pointer from your function can be cast to the Base* with the dynamic_cast<Child*> c++ function and check if the result is equal to 0 (no cast possible).

But a dynamic_cast is not very efficient and the cast ist very slow.

Answer 4

Converting from Base* to Derived* and vice versa can change the bits in the value -- you cannot safely convert from Base** to Derived**. The same in theory can be true for void*, but in practice is less likely.

Storing a void** is more likely to work than storing a Base** marginally. Still undefined.

Converting back and forth from void* is only valid if you go to and from the exact same type.

The most common case where the address changes when you simply change the type is with multiple inheritance:

struct Base1 { char x; };
struct Base2 { char y; };
struct Derived: Base1, Base2 {};

In this case, Derived* d points at the same address as Base1, but Base2 is after that. A pointer to the Base2 subobject of Derived will have a different binary address.

In C++, there are a limited number of situations where a pointer-to-A can be reinterpreted as a pointer-to-B. These are when the two are layout compatible. Layout compatible only occurs when the types in question are plain old data/standard layout, and when basically one class is a prefix of the other. Most other situation, the compiler is pretty much free to rearrange where things live.

At best you can delve into your particular implementation's object layout, and hope you didn't miss anything. In practice, it is often better to use something like a type-erased destroyer rather than risk the problem: store both the void** and a pointer-to-function that knows what type it was cast from, and casts it back to that.

struct cleanup_stuff {
  void* pvoid;
  void(*pfunc)(void*);
  void operator()() const {
    pfunc( pvoid );
  }
};

template<class T>
cleanup_stuff clear_pointer( T** ptr ) {
  return {
    static_cast<void*>(ptr),
    [](void* p){
      T** ptr = static_cast<T**>(p);
      *ptr = nullptr;
    }
  };
}

here we have our cleanup_stuff struct that stores a void* and an operation on said void*. Our clear_pointer takes a pointer-to-pointer, and creates a cleanup_stuff that stores the clearing of said pointer at a later point in time.

Store a cleanup_stuff in your Base, and have it take its pointer as a template T**. In the destructor, execute the cleanup_stuff. This has an extra pointer overhead over your solution, and does not execute undefined behavior.