Question

I am having trouble with forcing data type changes has on my own objects. I have a base class say A and two classes derived from A called B and C. I pass objects B and C to a function that checks which type of object it is (B or C). Here is some example code below and the question to my problem:

enum ClassType {"B", "C"};

class A {
  protected:
     m_Type;

  public:
     ClassType Type() { return m_Type}
     ...
     ...
};

class B : public A {
   otherMemberFunctions();

}

 class C : public A {
   otherMemberFunctions();

}


void WhatType(vector<A*>* candidates){


  vector<B*> b_candidates(0);
  vector<C*> c_candidates(0);

  for(int i = 0; i < candidates->size(); i++){

    if(candidates->at(i)->Type() == B ){

      B* b = (B*) candidates->at(i);
      b_candidates(b);
   }

  //Same idea for Object C
  }
}

I would then use WhatType(vector<A*>* candidates) as follows

vector<B*>* b_example

WhatType((vector<A*>*) b_exmaple)

When I have filled the new vector b_candidates in the function WhatType. Will I still have access to the member functions in the B object or will I only have the access to the member functions in the base class A?

I am confused to what happens with the object when I change the type of the object.

Here

WhatType((vector<A*>*) b_exmaple)

and here

B* b = (B*) candidates->at(i);

Answer 1

When you receive a pointer to a polymorphic object you have two types: the “static” type of the object, which, in your case, will be A *, and its “dynamic” or “real” type, that depends on what was actually assigned to it.

Casting your A * to B * forces the compiler to consider that pointer as a pointer to B; this is safe as long as you actually know that that pointer is actually a pointer to B, otherwise the compiler will start writing nonsensical code (invoking B methods on data of another type).

The checks you are trying to implement are a homegrown version of RTTI, which is a mechanism that allows you to know which is the “real type” of a pointer or a reference to a polymorphic class, and to perform that kind of casts safely. Check out typeid and dynamic_cast on your C++ manual for more info about it. (Incidentally, IIRC dynamic_cast is not only for safety in case the dynamic type is wrong, but it may perform also some extra magic on your pointer if you use it in complicated class hierarchies; so, avoid C-style casting for polymorphic classes)

By the way, in general it’s considered “code smell” to have to manually check the “real type” of the pointer in order to cast it and use its methods: the OOP ideal would be being able to do the work only though virtual methods available in the base class.

---

Big warning: RTTI works only on polymorphic classes, i.e. classes that have at least one virtual method. On the other hand, if you are building a class hierarchy where objects are being passed around as pointers to the base class you’ll almost surely want to have a virtual destructor, so that’s no big deal.