Thread: Eliminating dynamic_cast<>

I have a polymorphic set of classes, and I want to have a virtual comparison function. Right now each of the derived classes has a function that looks something like this:

Code:

bool
DerivedClass::Compare( const BaseClass* B ) const
    {
    if( const DerivedClass* derived = dynamic_cast<const DerivedClass*>(B) )
        return details_ == derived->details_ ;
    return false ;
    }

Is it possible to eliminate the dynamic_cast, or am I stuck with it?

Use an overloaded helper function;

Code:

class BaseClass
{
     public:

           virtual bool Compare(const BaseClass *) const;
};

class DerivedClass : public BaseClass
{
       public:

             bool Compare(const BaseClass *) const;                // override inherited virtual function
             virtual bool Compare(const DerivedClass *) const; // overload function of the same name
};

bool BaseClass::Compare(const BaseClass *b)   // implementation only required if BaseClass can be instantiated
{
    // compare b with * this
}

bool DerivedClass::Compare(const BaseClass *b)
{
     return b->Compare(this);    // this is a pointer to DerivedClass, so this calls the overloaded version
}

bool DerivedClass::Compare(const DerivedClass *b)
{
     // both this and b point to a DerivedClass, so ...

    return details_ == b->details_;
}

This code above assumes that the pointers provided as arguments to the functions point at valid objects.

The double dispatch does use dynamic_cast (it is one of the few places where using dynamic_cast makes sense). So if you need different derived classes to be able to compare to each other then you're probably best off to use it.

True, and the problem you speak of is why double dispatch might be better implemented with dynamic_cast, right?

>> Is it possible to eliminate the dynamic_cast, or am I stuck with it?
Is there any reason why you want to eliminate the cast or is it just for the convenience?

Couldn't you create a base comparison operator which is inherited? Or a function with the same properties:

Code:

class base {
public:
  int details_;

  /* etc */

  template<typename type>
    bool operator == ( const type &inst ) {
      return details_ == inst.details_;
    }
};


class derr_1 : public base   {};
class derr_2 : public base   {};
class derr_3 : public derr_2 {}; // etc


int main( void ) {
  base   thing_0;
  derr_1 thing_1;
  derr_2 thing_2;
  derr_3 thing_3;

  thing_0.details_ = 42;
  thing_1.details_ = 42;
  thing_2.details_ = 42;
  thing_3.details_ = 42;

  std::cout<< (thing_0==thing_1 ? "Same\n" : "Different\n");
  std::cout<< (thing_0==thing_2 ? "Same\n" : "Different\n");
  std::cout<< (thing_0==thing_3 ? "Same\n" : "Different\n");

  std::cout<< (thing_1==thing_2 ? "Same\n" : "Different\n");
  std::cout<< (thing_1==thing_3 ? "Same\n" : "Different\n");
  
  std::cout<< (thing_2==thing_3 ? "Same\n" : "Different\n");

  return 0;
}

Or am I missing something?

> Or am I missing something?

That only works because the objects are essentially the same. In real code you would want to maintain the ability to compare objects in different ways, despite being related.

To me it seems like template abuse, especially if bar objects were different from foo objects in significant ways. Then things get really hairy if another class quz implements just bar, and you want to compare those objects differently. You would need the flexibility of virtual functions to compare bar and quz objects differently from foo and bar objects, I beleive.

You don't need the list of the other derived classes if you are only comparing against yourself. If the two types are different, use the base class comparison (or whatever function), and if they are the same then use that class's function. Why does any class need to know about any other class?

Code:

class Base
{
  friend bool operator == (const Base &lhs, const Base &rhs);
protected:
  virtual bool dispatch_equals(const Base &rhs) const
  {
    // implement generic compare.
  }
};

bool operator ==(const Base &lhs, const Base &rhs)
{
  return lhs.dispatch_equals(rhs);
}

class A : public Base
{
protected:
  virtual bool dispatch_equals(const Base &rhs) const {
    A* rhsA = dynamic_cast<A*>(&rhs);
    if (rhsA)
    {
      // implement A specific compare
    }
    return Base::dispatch_equals(rhs);
  }
};

class B : public Base
{
protected:
  virtual bool dispatch_equals(const Base &rhs) const {
    B* rhsB = dynamic_cast<B*>(&rhs);
    if (rhsB)
    {
      // implement B specific compare
    }
    return Base::dispatch_equals(rhs);
  }
};

The point of the original question, Daved, was on how usage of dynamic_cast can be eliminated which your solution does not do. And the obvious approach to doing that is some variant of the self-visitor pattern. Using that pattern can introduce some need for all derived classes to be aware of each other; that is one of the trade-offs.

I thought the point was whether there was a better way that doesn't use dynamic_cast. I'm saying that using dynamic_cast is acceptable here and is better in many cases that forcing derived classes to be aware of each other. It doesn't matter if it is possible to remove the dynamic_cast if the alternative is worse.

Or you could do something gangsta like this

Code:

#include <iostream>

enum enClassObjectType{
	eClassBase,
	eClassDerivedOne
};

class CBaseClass{
public:
	CBaseClass()
	{
		mObjectType = eClassBase;
	}
	virtual ~CBaseClass()
	{
	}
public:
	void SetDetails(const int value)
	{
		mDetails = value;
	}

	enClassObjectType GetObjectType() const
	{
		return mObjectType;
	}
	virtual bool operator==(const CBaseClass *pBaseClass) const
	{
		return compare_details(pBaseClass);
	}
protected:
	bool compare_details(const CBaseClass *pBaseClass) const
	{
		return mDetails == pBaseClass->mDetails;
	}
	int mDetails;
	enClassObjectType mObjectType;
};

class CDerivedClassOne : public CBaseClass
{
public:
	CDerivedClassOne()
	{
		mObjectType = eClassDerivedOne;
	}

	virtual bool operator==(const CBaseClass *pBaseClass) const
	{
		if(pBaseClass->GetObjectType() == eClassDerivedOne){
			return compare_details(pBaseClass);
		}//if
		return false;
	}
};

int main()
{
	CBaseClass *pBaseClass = new CBaseClass;
	CBaseClass *pChildClassOne = new CDerivedClassOne;
	CBaseClass *pChildClassTwo = new CDerivedClassOne;

	
	pBaseClass->SetDetails(10);
	pChildClassOne->SetDetails(10);
	pChildClassTwo->SetDetails(10);

	if(*pBaseClass == pChildClassOne){
		std::cout<<"I should be here"<<std::endl;
	}//if

	if(*pBaseClass == pChildClassTwo){
		std::cout<<"I should be here"<<std::endl;
	}//if
	
	if(*pChildClassOne == pBaseClass){
		std::cout<<"I should not be here"<<std::endl;
	}//if

	if(*pChildClassTwo == pBaseClass){
		std::cout<<"I should not be here"<<std::endl;
	}//if

	if(*pChildClassOne == pChildClassTwo){
		std::cout<<"I should be here"<<std::endl;
	}//if

	return 0;
}

But doing all these tricks to just get rid of dynamic_cast just seems like a waste of your time. Thats why it was invented.