C / C++ / MFC

9-Jun-02 5:24

In standard C++, you'd write it like this:

typeid(fruit1)==typeid(*fruit2);

PS: Ummm. The latter just checks whether fruit1 and fruit2 are of he same type. Determining if fruit1 is derived from the the type fruit2 seems a little harder. I'll think it over to try to find a solution.

Joaquín M López Muñoz
Telefónica, Investigación y Desarrollo

Joaquín M López Muñoz9-Jun-02 5:54

9-Jun-02 5:54

OK. To determine wheter fruit1 derives from the type of fruit2, you have to know at compile time the exatc type of fruit2. Suppose both objects are Fruits and moreover fruit2 is an Apple. Then you'd write something like this:

dynamic_cast<Apple*>(fruit1)!=0

In C++, you can't get closer to the semantics of IsKindOf, but usually this is close enough, since you can do little with the type of an object ar run-time if you didn't know it before at compile-time --I hope I'm making myself clear enough.

Joaquín M López Muñoz
Telefónica, Investigación y Desarrollo

Rama Krishna Vavilala9-Jun-02 6:22

9-Jun-02 6:22

The only problem is that you need to enable RTTI and that increases the size of compiled code a lot. then you run into all kind of problems like linking with libraries without RTTI etc.

Joaquín M López Muñoz9-Jun-02 6:39

9-Jun-02 6:39

The only problem is that you need to enable RTTI and that increases the size of compiled code a lot.

Does it? I'd bet MFC's run-type schema adds a lot more code bloat to the app, and it is less efficient than RTTI, which after all is natively handled by the compiler. As for linking problems, you won't find any more problems as with any other RT schema external developers would have to implement anyway to be compatible with you.
Having RTTI switched off by default by VC++ is, to put it simply, non-standard, and a very bad decision IMHO.

Joaquín M López Muñoz
Telefónica, Investigación y Desarrollo

Rama Krishna Vavilala9-Jun-02 6:35

9-Jun-02 6:35

Joaquín M López Muñoz wrote:
Does it? I'd bet MFC's run-type schema adds a lot more code bloat to the app, and it is less efficient than RTTI,

No this is not true. RTTI simply adds too much extra code. I will write an article on it soon.

Joaquín M López Muñoz wrote:
Having RTTI switched off by default by VC++ is, to put it simply, non-standard, and a very bad decision IMHO.

Even strourstrup recommends in his book not use RTTI.

Joaquín M López Muñoz9-Jun-02 11:30

9-Jun-02 11:30

No this is not true. RTTI simply adds too much extra code. I will write an article on it soon.

RTTI adds some bytes of information for each polymorphic class. I doubt this can generate much code bloat. Nevertheless, it'll be interesting to know what you come up with in your forthcoming article.

Even strourstrup recommends in his book not use RTTI.

Yep, but one thing is advising against RTTI and other recommending that RTTI be not included in the object code by default (which is, to say it once more, non-standard), or recommending that one writes RTTI replacements.

Joaquín M López Muñoz
Telefónica, Investigación y Desarrollo

Mike Nordell9-Jun-02 6:12

Mike Nordell

9-Jun-02 6:12

Joel Holdsworth wrote:
fruit1->IsKindOf(fruit2->GetRuntimeClass());

Does this really tell you if fruit2 is of the same type as fruit1? Wouldn't this only tell you if fruit2 was of the same type _or an inherited type_ as fruit1?

Perhaps if you tell us what you want to accomplish there is a better way to do it? RTTI is almost always not the way you want to travel. Also be aware that MFC is often the blueprint of how not to do something.

Rama Krishna Vavilala9-Jun-02 6:20

9-Jun-02 6:20

Mike Nordell wrote:
RTTI is almost always not the way you want to travel.

Good point. I agree.

Rama Krishna Vavilala9-Jun-02 6:19

9-Jun-02 6:19

You can use RTTI but I don't recommend it. It adds lot of unecessary code. The easiest way for you would be to imitate what MFC does. i did have a set of classes to imitate this feature I will post it here if I find them.

Joaquín M López Muñoz9-Jun-02 6:32

9-Jun-02 6:32

I could partially agree with your advise of not using RTTI if avoidable, but imitating what MFC does (i.e. replacing RTTI with your own homemade schema) is usually much worse than relying in RTTI.

Joaquín M López Muñoz
Telefónica, Investigación y Desarrollo

Mike Nordell9-Jun-02 7:43

Mike Nordell

9-Jun-02 7:43

Joaquín M López Muñoz wrote:
but imitating what MFC does (i.e. replacing RTTI with your own homemade schema) is usually much worse than relying in RTTI.

Indeed. Fortunately there often are (way better) alternatives to do stuff than the MFC way. Smile | :)

Rama Krishna Vavilala9-Jun-02 7:25

9-Jun-02 7:25

Here is a simple implementation of RuntimeClass mechanism to give you an idea.

#include "assert.h"

class RuntimeObject;

class RuntimeClass
{
private:
RuntimeClass* m_pBaseClass;

private:
RuntimeClass()
: m_pBaseClass(NULL)
{
}

protected:
RuntimeClass(RuntimeClass* pBaseClass)
: m_pBaseClass(pBaseClass)
{
}

public:
virtual RuntimeClass* GetBaseClass()
{
return m_pBaseClass;
}

virtual RuntimeObject* CreateInstance();

friend class RuntimeObject;
};

class RuntimeObject
{
public:
RuntimeObject()
{
}

virtual RuntimeClass* GetRuntimeClass()
{
return &_runtimeClass;
}

bool IsKindOf(RuntimeClass* pClass);

static RuntimeClass _runtimeClass;
};

template<class T, class Base>
class RuntimeClassImpl : public RuntimeClass
{
public:
RuntimeClassImpl(RuntimeClass* pBaseClass)
: RuntimeClass(pBaseClass)
{
}

RuntimeObject* CreateInstance()
{
return new T();
}
};

template<class T, class Base>
class RuntimeObjectImpl : public Base
{
public:
RuntimeClass* GetRuntimeClass()
{
return &_runtimeClass;
}

static RuntimeClassImpl<T, Base> _runtimeClass;
};

template<class T, class Base>
RuntimeClassImpl<T, Base> RuntimeObjectImpl<T, Base>::_runtimeClass(&Base::_runtimeClass);

bool RuntimeObject::IsKindOf(RuntimeClass* pClass)
{
RuntimeClass* pThisClass = this->GetRuntimeClass();

while(pThisClass)
{
if (pThisClass == pClass)
return true;

pThisClass = pThisClass->GetBaseClass();
}

return false;
}

RuntimeClass RuntimeObject::_runtimeClass;

RuntimeObject* RuntimeClass::CreateInstance()
{
return new RuntimeObject();
}

//A derives from RuntimeObject
class A : public RuntimeObjectImpl<A, RuntimeObject>
{
};

//B derives from A
class B : public RuntimeObjectImpl<B, A>
{
};

//C derives from A
class C : public RuntimeObjectImpl<C, A>
{
};

int _tmain(int argc, _TCHAR* argv[])
{
C c;
A a;
B b;

assert(c.IsKindOf(a.GetRuntimeClass()));
assert(b.IsKindOf(a.GetRuntimeClass()));
assert(!c.IsKindOf(b.GetRuntimeClass()));

return 0;
}

Mike Nordell9-Jun-02 7:49

Mike Nordell

9-Jun-02 7:49

Hah, you messed up "<" and ">"! :->

Maybe just copy it into e.g. notepad and replace < with & gt; and so on? Smile | :)

Don't mention it, I'm sure you'd do the same for me. Smile | :)

Rama Krishna Vavilala9-Jun-02 8:30

9-Jun-02 8:30

It happens to me every time. It happens with #include so I changed < to ". Now I need to take care of templates.

Nish Nishant9-Jun-02 9:57

Nish Nishant

9-Jun-02 9:57

Rama Krishna wrote:
It happens with #include so I changed < to ". Now I need to take care of templates.

You might also check the [Display this message as-is (no HTML)] check-box Smile | :)

Then you can type < and > and whatever

<html>
<head>
<meta name="Generator" content="CP Post edit textbox">
<title>Nish</title>
</head>
<body>
<p> Hello Rama </p>
<a href='www.google.com'>google</a>
</body>
</html>

Rama Krishna Vavilala9-Jun-02 9:55

9-Jun-02 9:55

That's what I did when I modified the message.