CObect , CRuntimeClass and related macros

Introduction

When I was making a project that will dynamically create an object from a class, I decided that the CObject class should be the basis for all classes.

But why was it necessary to make a CObject the base class? I went searching on Code Project. Unfortunately I didn't find an explanation. Rather I created more questions, they are:

1. Why should CObject be a base class and how we can be facilitate this?
2. What is CRuntimeClass? What is the RUNTIME_CLASS macro?
3. What are all these macros:
   • DECLARE_DYNAMIC
   • IMPLEMENT_DYNAMIC
   • DECLARE_DYNCREATE
   • IMPLEMENT_DYNCREATE

I have tried to describe all of them with simple and easy examples. I have even explained the use of some important member functions of these classes and structures. Such as:

• IsKindOf
• GetRuntimeClass
• CreateObject
• FromName
• IsDerivedFrom

Answers

1. If you derive a class from CObject, then you will get this kind of support run-time class information, dynamic creation, and serialization.
2. CRunitmeClass is a structure and does not have a base class.
   RUNTIME_CLASS: this macro is used to Get the object of run-time class structures from the name of a given class name.
   RUNTIME_CLASS(class_name): the class name should not enclosed in quotation marks. Inside this class, DECLARE_DYNAMIC macro must be used.
3. See the table. This is not same as MSDN's table:

Figure 1

Using the code with examples

If you follow all the examples, it will be easy to grab the total concept.

//In interface file 
//CMyRuntime should be derived from CObject for run time support

class CMyRuntime : public CObject
{
    DECLARE_DYNAMIC(CMyRuntime) // for run time support 

public:
    BOOL ShowName(CString strName);
}; 

class CMyRuntime_Derived : public CMyRuntime
{
    DECLARE_DYNAMIC(CMyRuntime_Derived) // for run time support 

public:
    BOOL ShowNameDrvd(CString strName);
}; 


//In implementation file
IMPLEMENT_DYNAMIC(CMyRuntime, CObject) 

BOOL CMyRuntime::ShowName(CString strName)
{
    AfxMessageBox(strName);
    return TRUE;
} 

IMPLEMENT_DYNAMIC(CMyRuntime_Derived, CMyRuntime)

BOOL CMyRuntime_Derived::ShowNameDrvd(CString strName)
{
    AfxMessageBox(strName);
    return TRUE;
} 

//BOOL RuntimeCkeck(CRuntimeClass *pRTClass)
BOOL RuntimeCkeck(CObject* pObj)
{
    //first use
    // To get class name
    CRuntimeClass *pClass = pObj.GetRuntimeClass();
    LPCSTR className = pClass->m_lpszClassName;

    //or you can use this
    if(strcmp(pRTClass->m_lpszClassName, "CMyRuntime" ) == 0)
    {
        //do whatever
    } 

    //second use
    //To be sure that, is there any relation between this two class 
    //e.g. "CMyRuntime_Derived" is base or child of "CMyRuntime"

    CMyRuntime_Derived pMyruntime;
    BOOL bRTCheck = pMyruntime.IsKindOf(RUNTIME_CLASS(CMyRuntime)); 

    return bRTCheck;
} 

//In any other file 
void AnyFunction()
{
    CMyRuntime_DerivedpObj;
    BOOL bCheck = RuntimeCkeck(&pObj);//check class name is correct or not 

    //BOOL bCheck =
    RuntimeCkeck(RUNTIME_CLASS(CMyRuntime));
}

Up to here all discussion has been about:

• CObject
• DECLARE_DYNAMIC
• IMPLEMENT_DYNAMIC
• IsKindOf
• GetRuntimeClass()
• m_lpszClassName

In the above example you can use the CRuntimeClass::IsDerivedFrom((RUNTIME_CLASS(CMyRuntime)) function, but you can't use CRuntimeClass::CreateObject() , because you did not use the DECLARE_DYNCREATE and the IMPLEMENT_DYNCREATE macro.

Now see the use of CRuntimeClass::CreateObject() function:

//In interface file

class CMyRuntime : public CObject
{
    DECLARE_DYNCREATE(CMyRuntime) // for run time support

public:
    BOOL ShowName(CString strName);
}; 

class CMyRuntime_Derived :public CMyRuntime
{
    DECLARE_DYNCREATE(CMyRuntime_Derived) // for run time support 

public:
    BOOL ShowNameDrvd(CString strName);
}; 

//In implementation file 
CObject* GlobalObjectCreator(CRuntimeClass
                             *pClass)
{
    CObject *pObject = NULL; 

    if(pClass == NULL)
    {
        return pObject;
    }
    //if CMyRuntime_Derived is not derived from CMyRuntime, it will return 0
    BOOL bRelation = pClass->IsDerivedFrom(RUNTIME_CLASS(CMyRuntime)); 

    pObject = pClass->CreateObject();
    if(pObject == NULL)
    {
        AfxMessageBox(_T("Out of memory creating an object "));
    }
    //if you use any other class name instead of CMyRuntime, it will return 0.
    bRelation = pObject->IsKindOf(RUNTIME_CLASS(CMyRuntime)); 

    return pObject;
} 

//----- 

IMPLEMENT_DYNCREATE(CMyRuntime, CObject) 

BOOL CMyRuntime::ShowName(CString strName)
{
    AfxMessageBox(strName);
    return 1;
} 

IMPLEMENT_DYNCREATE(CMyRuntime_Derived, CMyRuntime) 

BOOL CMyRuntime_Derived::ShowNameDrvd(CString strName)
{
    AfxMessageBox(strName); 
    return TRUE;
} 

//In any other file 
void AnyFunction()
{
    CMyRuntime_Derived* pMyRuntime = NULL; 
    pMyRuntime = (CMyRuntime_Derived*)GlobalObjectCreator(RUNTIME_CLASS(
        CMyRuntime_Derived));
    pMyRuntime->ShowName(_T("Hi"));
}

Note: An easy and simple way of learning this is to just copy the code and debug with break point.

Also, I didn't discuss Serialization here, though this is also part of this topic.

If there are any suggestions, requests or problems please inform me.

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here