How to store an "object type" in a std::map?

Question

Long introduction, question is at the end:

Assume I have a base class that's creating an interface

class base
{
public:
  virtual ~base();
  virtual void calc( int* variables ) = 0;
}

and a few classes that are inherited that do the work (only two are shown here):

class add : public base
{
  const int a, b, c;
public:
  add( int a_, int b_, int c_ ) : a(a_), b(b_), c(c_) {}
  void calc( int* variables ) 
  {
     variables[a] = variables[b] + variables[c];
  }
}

class inc : public base
{
  const int a;
public:
  inc( int a_ ) : a(a_) {}
  void calc( int* variables ) 
  {
     variables[a]++;
  }
}

and finally some code that's using this construct:

base* task[2];
task[0] = new add( 0, 1, 2 );
task[1] = new inc( 3 );
int data[4];

/* ... */

for( int i = 0; i < 2; i++ )
  task[i]->calc( data );

That's working so far - but it's defining my tasks during compile time. This should be changed to runtime by parsing an input file. Assume the parsing has been done and in std::string variable command is the object type (like add or inc) and in a std::vector params are the parameters for the constructor.

Now I could have a long list of

if( command.compare( "add" ) ) 
  task[end] = new add( params[0], params[1], params[2] );
else if( command.compare( "inc" ) ) 
  task[end] = new inc( params[0] );
else /... */

apart from becoming quite unreadable that's just a linear seach. So in the spirit of Why switch statement cannot be applied on strings? I'd like to replace that linear search by a std::map (or hash map...).

So after this long introduction I can finally come to the question:

How can I define and fill a std::map so that references(?) to an object are stored in such a way that I can create late on the object dynamically out of that informations?

So with the code above I'd like to do something that might look like this in the end:

// define and fill
std::map< std::sting, ???? > lookup;
lookup["add"] = add;
lookup["inc"] = inc;

/* ... */

// use:
while( linesInConfigAvailable )
{
  /* ... parse ... */
  switch( params.size() )
  {
    case 1:
      task[end] = new lookup[command]( params[0] );
      break;
    case 3:
      task[end] = new lookup[command]( params[0], params[1], params[2] );
      break;
  }
}

PS: So far I didn't need RTTI in my code. It'd be nice if that could stay so...

How to store an "object type" in a std::map?

1 Answers