Why use RTTI?

We have virtual functions in a base class, and those would seem to be able to handle the polymorphic distinction between the object type.

So why would we use RTTI?

When we want to act through a pointer or reference to a base function, but cannot use virtual functions.
Why couldn’t we use virtual functions?
- We could but it would be awkward ... an example will help.

In a previous set of notes we talked about the idea of not wanting to have to go back and make changes to a base class based on specialisations of it, and that’s what we would need to do here. Virtual functions need to have the same parameter set across the class hierarchy, but that doesn’t always make sense.

We might reach a specialisation where an additional parameter is needed, and going back to modify the original and intermediate classes isn’t ideal, nor is adding another virtual function with a different signature.

A warning: Operator overloading and polymorphism

Since the operator definitions have different signatures:

virtual bool operator==( Base& bs ){. . .}
virtual bool operator==( Derived& dr ){. . .}

... dynamic binding won’t work.

int main()
{
Base *bp1 = new Base(1);
Base *bp2 = new Base(2);
if( *bp1 == *bp2 ) // uses Base::operator==(..)
cout << "Objects are equal" << endl;
Base *bp3 = new Derived(1);
Base *bp4 = new Derived(2);
if ( *bp3 == *bp4 ) // uses Base::operator==(..) too!
cout << "Objects are equal" << endl;

return 0;
}

A step back first, to specify the base class ...

class Base {
public:
int value;
virtual bool operator== (Base& bs)
{
cout << "Base" << endl;
return ( value == bs.value );
}
Base(int val) : value(val){}
};

To enable dynamic binding we need to define in the derived class an additional function with exactly the same signature as in the base class.

class Derived : public Base {
int data;

public:
Derived( int a ) : Base(0), data(a) {}
virtual bool operator==(Base& bs)
{
cout << "Base in Derived" << endl;
Derived* dp = dynamic_cast<Derived*>(&bs);
if (dp) return ( *this == *dp );
else return false;
}
bool operator==(Derived& dr)
{
cout << "Derived" << endl;
return ( data == dr.data );
}

};

int main()
{
Base *bp1 = new Base(1);
Base *bp2 = new Base(2);
if( *bp1 == *bp2 ) { // uses Base::operator==(..)
cout << "Objects are equal" << endl;
}
Base *bp3 = new Derived(1);
Base *bp4 = new Derived(2);
if ( *bp3 == *bp4 ) { // uses Derived::operator==(..)
cout << "Objects are equal" << endl;
}

}

What would happen if we compared bp2 and bp4, or bp4 and bp2?

An aside: Object slicing ...

This happens when a derived class object is assigned to a base class object.

Slicing is the removal of the additional attributes that the derived object had relative to the base class.