Reflect child classes from base classes in C++

Question

We want a solution in C++ that must be able to do the following: Given a string of particular type, lets say 'A', we want to find all the types that derives from 'A'. Instantiate new objects out of the types that are derived from 'A'. E.g. Lets say we have a class, VehicleEntity. VehicleEntityhas child classes, PassangerCarEntity, TruckEntity, TrainEntity, BoatEntity. We are unsure what vehicle entities there may be as the a library could be added containing more VehicleEntities. E.g. an AirplaneEntity thaterives from VehicleEntity could be added after deployment. In the application, when a user wants to select a VehicleEntity, the user should be able to pick any of the entities deriving from VehicleEntity. This includes the PassangerCarEntity, TruckEntity, TrainEntity, BoatEntity and AirplaneEntity. The user selects an Entity, lets say AirplaneEntity, A new object of type AirplaneEntity must be instantiated.

The following is an concept example in C# of what we want to achieve in C++. In C# the items for the dropdown list can be retrieved as follows:

Type vehicleEntityType = typeof(VehicleEntity);
List<Type> types = new List<Type>();
foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
    types.AddRange(assembly.GetTypes().Where(x => vehicleEntityType.IsAssignableFrom(x) && !x.IsGenericType && !x.IsAbstract));
dropDownBox.ItemList = types;

//To instantiate the object:
List<VehicleEntity> vehicleList = new List<VehicleEntity>();
Type newVehicleType = (Type)dropDownBox.SelectedItem;
object newVehicle = Activator.CreateInstance(newVehicleType ); // default constructor used, parameterless constructors for vehicles.
vehicleList.Add(newVehicle);

Standard C++ seems unable to do this as it does not store any metadata on its objects. There exist external libraries that provides reflection to C++. RTTI and boost.Mirror seems unable to do this. I am sure that we are not the only ones that had this problem and that solutions exist. What solutions exist to address our problem? External libraries or other means.

Answer 1

Using reflection for such task seems to be a little bit of overengineering for me. Look at the problem from the another perspective: you want to know, when someone derives from your class. This can be achieved in the following way (but not limited to):

• Create static VehicleRepository class.

• Prepare a following function:

  static VehicleContext * VehicleRepository::Register(string newName, std::function<Vehicle * (void)> vehicleCtor)
  

  The task of this method is to register new vehicle type available to be constructed.

• Require the VehicleContext in the base class' ctor of VehicleBase:

  VehicleBase::VehicleBase(VehicleContext * newContext)
  

• Create static ctors for derived classes, which obtains the context:

  static VehicleContext * context;
  
  static NewVehicle()
  {
      context = VehicleBase::Register("NewVehicle", []() { return new NewVehicle(); });
  }
  

  C++ doesn't have the static constructors, but you can emulate them in the following way: Static constructor in c++ . Also, this code can be placed in some initialization section of your application or library.

• Use the context when instantiating new derived classes:

  NewVehicle::NewVehicle()
      : base(NewVehicle::context)
  {
  }
  

This is a simple way of making sure, that every Vehicle will register itself properly in the VehicleRepository. You also will have a centralized repository of all registered vehicles along with proper constructor functions to create them.

---

In general, you have to create an architecture, which follows the rule:

Instantiating derived class should be impossible, if the class didn't registered itself in some global repository prior to instantiating.

Another approach to presented above:

BaseVehicle::BaseVehicle(Token token)
{
    // token is passed from the derived class

    if (!GlobalRepository.IsRegistered(token))
        throw new std::exception("Vehicles should be registered prior to instantiating!");
}

Token may be class name, GUID associated with the class or something else. Food for thought :)

Answer 2

This is not exactly what you want, but you can use a simple base class in C++. It does give you the ability to check for a base class. However, it does take more careful consideration and planning than in C# - as those who commented on your post suggested...

class Vehicle {
  public:
    virtual int move (void) = 0;
};

class Airplane : public Vehicle {
  public:
    int move (void);
    void autoPilot (void);
};

void GoFromMaineToSpainInVehicle (Vehicle *v);

int main (int argc, char *argv[]) {
    Vehicle *v = NULL;
    Airplane *cessna = new Airplane();

    // Request base class pointer
    v = dynamic_cast<Vehicle *>(cessna);

    if ( v ) { GoFromMaineToSpainInVehicle(v); }
    else { /*not a vehicle*/ }

    return 0;
}

Answer 3

If we want to get group of objects depending on user input string. What we can implement here is modified Factory design pattern using string input we could decide which type of vehicle objects to return.

Something like this:

#include <iostream>
#include <boost/any.hpp>
#include <boost/unordered_map.hpp>
#include<list>

using namespace std;

boost::unordered_map<string, boost::any> objects;

class A{

  public:
    virtual void print()
    {
      cout<<"A"<<endl;
    }

};


class B:public A{

  public:

    void print()
    {
      cout<<"B"<<endl;
    }

};


class C:public A{

  public:

    void print()
    {
      cout<<"C"<<endl;
    }

};


class D{

  public:

    virtual void print()
    {
      cout<<"D"<<endl;
    }
};

class E:public D{

  public:

    void print()
    {
      cout<<"E"<<endl;
    }
};


class F:public D{


  public:

    void print()
    {
      cout<<"F"<<endl;
    }
};

boost::unordered_map<string, list<boost::any> > createInstance(string input)
{
  boost::unordered_map<string, list<boost::any> > list;
  if(input.compare("A") == 0 )
  {
    list[input].push_back(new A);
    list[input].push_back(new B);
    list[input].push_back(new C);
  }
  else if(input.compare("D") == 0 )
  {
    list[input].push_back(new D);
    list[input].push_back(new E);
    list[input].push_back(new F);
  }
  return list;
}



int main()
{

  string input;
  cout<<"input "<<endl;
  cin>>input;
  boost::unordered_map<string, list<boost::any> > objectList = createInstance(input);

  for(boost::unordered_map<string, list<boost::any> >::iterator itr = objectList.begin();
      itr!= objectList.end(); ++itr)
  { 
    for(list<boost::any>::iterator itrList = itr->second.begin();
        itrList!= itr->second.end();++itrList)
    {
      if((*itrList).type() == typeid(A*))
      (boost::any_cast<A*>(*itrList))->print();
      else if((*itrList).type() == typeid(B*))
      (boost::any_cast<B*>(*itrList))->print();
      else if((*itrList).type() == typeid(C*))
      (boost::any_cast<C*>(*itrList))->print();
      else if((*itrList).type() == typeid(D*))
      (boost::any_cast<D*>(*itrList))->print();
      else if((*itrList).type() == typeid(E*))
      (boost::any_cast<E*>(*itrList))->print();
      else if((*itrList).type() == typeid(F*))
      (boost::any_cast<F*>(*itrList))->print();
    }
  }
  return 0;
}

Answer 4

Could you provide more details on how is it planned to expand list of available types?

As other commenter said, you can't implement reflection in the way you've described in C++.

I assume all subtypes will be defined in some redistributable library (or different libraries) which will be linked dynamically with application. In this case I suppose it should be the library's responsibility to provide list of available types and some factory method to instantiate some particular subtype based on the context.

Answer 5

I found two solutions to my problem.

The first one is trough a reflection library, Reflex. It is used by the ROOT library as well (developed by the CERN laboratory, and actively maintained.)

The second one, is what it seems @Spook and @Eugene was trying to get at. Cplusplus

Thanks for all the input.