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<int> 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...

@Chris To conform to style-guidelines you should start all class names with a Capital letter. ex `base` to `Base`. — MartyE, Aug 19 '12 at 11:15
@MartyE is this from a "universal" style guide? (Well the class names in the real code were already starting with a capital letter - but I'm asking as I'm not sure that the rest is according, and as it's OSS I'd like to stay with what others would expect...) — Chris, Aug 19 '12 at 12:58
@Chris I recommend that from Google's style guide , while not universal. I mentioned that because it tripped me up while reading through (which is a class definition and which is an object of the class). — MartyE, Aug 19 '12 at 14:21
@MartyE Google's style guide is a guide to _Google's style_. Google's style is just _Google's_ style. It is not intended for use outside Google. It is not intended as a "best practices" document. Indeed, it contains some points that go against widely accepted best practices, for their own internal organisational reasons that generally do not apply outside Google. — Oktalist, May 05 '13 at 21:03

score 15 · Accepted Answer · answered Aug 19 '12 at 11:15

Well, you can't. In C++, classes are not objects, they are more of an abstract construct that only exists within the compilers working data while it compiles.

You could, however, create so called factory functions with a given signature:

class A : public Base
{
public:
     static Base* Create() { return new A; }
};

class B : public Base
{
public:
     static Base* Create() { return new B; }
};

...

EDIT: if the "Create" functions are uniform like this, you can of course make a template.

Then, you can store function pointers in the map:

typedef Base* (*FactoryType)();
std::map< std::string, FactoryType >

lookup["A"] = A::Create;
lookup["B"] = B::Create;

and call them appropiately:

task[end] = lookup[command]();

What does `typedef` do in `typedef Base * (*FactoryType)()`? — David G, Aug 19 '12 at 12:02
Thanks Christian, that's the solution I was looking for and how I'm doing it now (slightly modified to handle the constructor parameters) — Chris, Aug 19 '12 at 12:55

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

1 Answers1