Thread: dereferencing a pointer to a pointer

Ok so lets say you have a base class called Object.

you also have another class that derives from class Object called subObject

you lastly have a pointer to a void called pVoid, which i think you could make by doing this:

Code:

void* pVoid

now if you had:

Code:

Object* pObject = new subObject;

and did this:

Code:

pVoid = dynamic_cast<(pObject*)>(pVoid);

would pVoid be a pointer to the new subObject, in the sense that you could do:

Code:

pVoid->(memberfunction of subObject)();

NOTE: both classes are normal, not virtual

Why don't you try it?

Code:

class Base
{
public:
	Base() {}

	void Print()
	{
		std::cout << "In Base.Print" << std::endl;
	}
};

class Derived : public Base
{
public:
	Derived() {}

	void DerivedPrint()
	{
		std::cout << "In Derived.DerivedPrint" << std::endl;
	}
};

int main()
{
	Base* baseObj = new Derived();
	void* pVoid = baseObj;
	dynamic_cast<Base*>(pVoid)->DerivedPrint();

	return 0;
}

Can you give better examples, those are not correct. pVoid is uninitialized, so if you cast it it will still be uninitialized. When you cast, you put the type in the angle brackets, so it should be dynamic_cast<Object*>. Did you mean to point pVoid at pObject first, and then cast to Object* like in pianorain's example?

If that is the case, and any time you have an Object* pointer, you cannot call subObject member functions directly. If you had a virtual method in the Object class that was implemented in the subObject class, then you could call that from the Object* pointer. You cannot call any of them from a void*. If you use a dynamic_cast on a void*, I'm not sure if it would work at all.

pVoid is uninitialized, so if you cast it it will still be uninitialized.

A void pointer can point to any data type. However, you cannot dereference a void pointer. In your example, you have two errors in that regard:

1) Your void pointer never points to anything.

2) The operator -> is shorthand for the combination of the dereference operator followed by the member access operator, so pVoid->memberFunction is equivalent to (*pVoid).memberFunction. That dereferences a void pointer which is illegal.

As for a dynamic_cast, you can only use it when you are dealing with polymorphic class types, which means the base class has to contain at least one virtual function. Dynamic casts are used to cast down the class hierarchy, from a base class to a derived class; or across a class hierarchy. However, you are trying to use a dynamic cast to cast to a base class.

by the way you can make a cast up to a base class if the derived class is directly derived

You can cast up to a base class if the derived class is indirectly derived as well. The cast is usually done implicitly:

Base* pBase = pIndirectlyDerived;

but it can be done explicitly:

Base* pBase = static_cast<Base*>(pIndirectlyDerived)

However, in neither case is that a dynamic_cast.