// rhmRtti.cpp : Defines the entry point for the console application.
//
#include <stdafx.h
#include <iostream
#include <string

#define NULL 0 

//////////////////////////////////////////
// BASE CLASS
//////////////////////////////////////////

class I_TypeInfoClass
{
public:
	// public stuff here

	// This template accepts a reference, of a const pointer of type const T
	// and the template itself is a const function
	// Note: Visual C++ 6.0 requires the template member definition inside
	// the class declaration.  I.e. no separate definition outside of the
	// class { }; declaration is allowed.  Visual C++ 7.0 (.NET) seems to 
	// handle it fine.

	template <typename T
	bool IsOfExactType(const T * const & refClassType) const 
	{
		return  GetClassTypeAddress() ==
		  reinterpret_cast<unsigned long(&refClassType);
	}

	// This template may be unnecessary under another implementation
	// but I decided to use it because it elimates code in the subclasses
	// It's all a matter of taste though, imho.

protected:
   // enforce that the subclasses have to implement this method
   virtual unsigned long GetClassTypeAddress() const = 0;
};

/////////////////////////////////////////
// SUB CLASS A
/////////////////////////////////////////

class SubClassA: public I_TypeInfoClass
{
public:
	// We make this guy a const * that points to a const SubClass A
	// because we do not want the user to change it and call on
	// potentially anything. Since it points to NULL it would crash though
	static const SubClassA * const mClassType;
protected:

	// The keyword virtual in this statement is optional,
	// because once a base class defines a virtual function 
	// the derived classes that override it will always be virtual
	// also, but I want to be descriptive :-)

	virtual unsigned long GetClassTypeAddress () const
	{
		return reinterpret_cast<unsigned long(&mClassType);
	}

	// private code & stuff here
};

// It really does not matter, to what this pointer points to
// but let's make it point to NULL since it is true we point
// to no valid object :-)

const SubClassA * const SubClassA::mClassType = NULL;

///////////////////////////////////////////
// SUB-SUB CLASS C
///////////////////////////////////////////

class SubSubClassC: public SubClassA
{
public:

	// We make this guy a const * that points to a const SubClass A
	// because we do not want the user to change it and call on
	// potentially anything. Since it points to NULL it would crash though
	static const SubSubClassC * const mClassType;

protected:

	virtual unsigned long GetClassTypeAddress () const
	{
		return reinterpret_cast<unsigned long(&mClassType);
	}

	// private code & stuff here
};

const SubSubClassC * const SubSubClassC::mClassType = NULL;

///////////////////////////////////////////////////////
// Simple utility function to print status type checks for this
// example.
///////////////////////////////////////////////////////

void PrintTypeCheck(I_TypeInfoClass *pI_TypeInfoClass, std::string &refMessageString) 
{
	std::cout << "************" << refMessageString  << std::endl << std::endl;

	// Notice how we check for the exact type - we pass as a parameter
	// the static member that is a pointer of the class that we check against

	std::cout << "pI_TypeInfoClass..." << std::endl;

	if (pI_TypeInfoClass-IsOfExactType(SubClassA::mClassType) )
	  std::cout << "... points to an exact type SubClassA" << std::endl;
	else
	  std::cout << "... doesn't point an exact type SubClassA" << std::endl;

	if ( pI_TypeInfoClass-IsOfExactType(SubSubClassC::mClassType) )
	  std::cout << "... points to an exact type SubSubClassC" << std::endl;
	else
	  std::cout << "... doesn't point an exact type SubSubClassC" << std::endl;

	std::cout << "***********************************" << std::endl << std::endl;
}

///////////////////////////////////////////
// MAIN - duh! :-)
///////////////////////////////////////////

int main(int argc, char* argv[])
{
	// First some code setup for the example
	SubClassA anA;
	SubSubClassC aC;
	SubClassA *pA = &anA;
	I_TypeInfoClass *pB = &anA;
	SubSubClassC *pC = &aC;

	// check when pA points to SubClassA
	PrintTypeCheck(pA, std::string("When pA points to SubClassA..."));

	pA = &aC;

	// check when pA points to SubSubClassC
	PrintTypeCheck(pA, std::string("When pA points to SubSubClassC..."));

	// check when pB points to SubClassA
	PrintTypeCheck(pB, std::string("When pB points to SubClassA..."));

	pB = &aC;

	// check when pB points to SubSubClassC
	PrintTypeCheck(pB, std::string("When pB points to SubSubClassC..."));

	// check pC just for kicks
	PrintTypeCheck(pC, std::string("When pC points to SubSubClassC..."));
	return 0;
}

///////////////////////////////////////////////////////////////////
// SAMPLE OUTPUT:
///////////////////////////////////////////////////////////////////
/*

************When pA points to SubClassA...

pI_TypeInfoClass...
... points to an exact type SubClassA
... doesn't point an exact type SubSubClassC


************When pA points to SubSubClassC...

pI_TypeInfoClass...
... doesn't point an exact type SubClassA
... points to an exact type SubSubClassC


************When pB points to SubClassA...

pI_TypeInfoClass...
... points to an exact type SubClassA
... doesn't point an exact type SubSubClassC


************When pB points to SubSubClassC...

pI_TypeInfoClass...
... doesn't point an exact type SubClassA
... points to an exact type SubSubClassC


************When pC points to SubSubClassC...

pI_TypeInfoClass...
... doesn't point an exact type SubClassA
... points to an exact type SubSubClassC


Press any key to continue 

*/ 

    public: 
	static const I_TypeInfoClass * const mClassType; 

      template <typename T
      bool IsTypeOf(const T * const & refClassType) const 
      {
        // Let's use a variable for clarity
        unsigned long refClassTypeAddress = reinterpret_cast<unsigned long(&refClassType);

         // Query up the hierarchy if necessary 
        return GetClassTypeAddress() == refClassTypeAddress ? true : IsOfBaseType(refClassTypeAddress);
      }

protected:
	virtual bool IsOfBaseType(unsigned long pasUpAddress) const 
	{ 
           return reinterpret_cast<unsigned long(&mClassType) == pasUpAddress; 
	} 

	virtual unsigned long GetClassTypeAddress () const 
	{ 
	     return reinterpret_cast<unsigned long(&mClassType); 
	} 


SubClassA modifications/additions:

    public: 
	  static SubClassA * const mClassType; 
    protected: 
	virtual bool IsOfBaseType(unsigned long pasUpAddress) const 
	{
        // Query up the hierarchy if necessary
        return reinterpret_cast<unsigned long(&mClassType) == pasUpAddress ? 
          true : I_TypeInfoClass::IsOfBaseType(pasUpAddress);
	} 
	virtual unsigned long GetClassTypeAddress () const 
	{ 
		return reinterpret_cast<unsigned long(&mClassType); 
	}