Better way than casting??

[Shal]

Hi,

Class B inherits from class A
class D inherits from class A

D has a function say, fun_D()

B has a function say, fun_B(A* Dtype)

void main()
{
	
	D *pD = new D();
	B *pB = new B();
	pB->fun_B(pD);

}

I want to call fun_D() from B. But I don't want to include fun_D in A.


The best way I could think was,

void B::fun_B(A *Dtype)
{

	D *lDtype = static_cast <D*>(Dtype);
	
	lDtype->fun_D();
}

But I am not happy with this casting. Is there any better way to do this?

Best Regards,
Shal

[whiteflags]

If it doesn't completely bother you, you can take your foo_function out of the class implementation, and have it work on a const reference to a B object.

And because of scope, there shouldn't be any conflicts if D uses it's own foo_function while B uses the global one.

[Daved]

>> Is there any better way to do this?

In many (but not all) cases, yes. The way to get rid of the cast is to identify why fun_B has an A* parameter while it only expects D* arguments to be passed to it. Why not just have fun_B take a D* instead?

If the reason is that sometimes you will be passing a D, and other times you will be passing A or other classes derived from A that are not D's, then you should be using dynamic_cast to verify that the pointer is in fact a D, not an A or some other derived class. That won't fix your design problem though.

To fix the design problem, you have to separate the use of D specific functions to places where only a D can be used. If fun_D makes sense as part of the interface to A, but B objects will do nothing and D objects will do something, then you could add fun_D as a virtual function in A and you would no longer need the cast. That is closer to good design, although it might not be the best solution especially if the fun_D interface makes no sense anywhere but for D objects.

[JaWiB]

On an unrelated note, main returns int

[Magos]

You're doing a down-cast (down the inheritance hiearchy) and thus dynamic_cast would be better suited as it's not guaranteed that the A* is a D* (in the general case).