how to go through a string array and apply functions for different strings?

Question

Ok, this may be really noobish question, but i am wishing there is something i dont know yet.

I go through a file, and check which string each line has, depending on the string value i execute a different function for it (or functions).

This is how i do it now:

Edit: I need to use variables outside the if-else-if range inside the if's, updated code:

string s1 = "used";
string s2 = "in";
string s3 = "functions";

if(str == "something"){
    something = process(s1, s2);
}else if(str == "something else"){
    something = process(s2, s3);
}else if(str == "something more"){
    something = process(s1, s3);
    something = process(s1, s2);
}else if(str == "something again"){
    // do more stuff
}else if(str == "something different"){
    // do more stuff
}else if(str == "something really different"){
    // do more stuff
}

I am afraid this will become "slow" after i have to repeat those else if lines a lot...

I tried to use switch() statement, but obviously it doesnt work here, is there something similar to switch() to use here?

Answer 1

That should be the most effective. But maybe a switch-case statement would be more elegant?

Answer 2

If you just want to execute different functions, you can use a map from strings to function pointers or functors like boost::function / tr1::function:

void f1() { /* ... */ }
void f2() { /* ... */ }

// ... creating the map:
typedef void (*FuncPtr)();
typedef std::map<std::string, FuncPtr> FuncMap;
FuncMap fnMap;
fnMap["something"] = &f1;
fnMap["something else"] = &f2;

// ... using the map:
FuncMap::const_iterator it = fnMap.find(str);
if (it != fnMap.end()) { // is there an entry for str?
    it->second(); // call the function
}

---

As for passing parameters, with the details given so far i'd probably go for passing the unparsed remainder of the line or a list of string tokens to the functions and let them handle those as they see fit:

void f1(const std::vector<std::string>& tokens) { /* ... */ }
// ...

typedef void (*FuncPtr)(const std::vector<std::string>&);
typedef std::map<std::string, FuncPtr> FuncMap;
// ...

std::vector<std::string> tokens = /* ...? */; 
FuncMap::const_iterator it = fnMap.find(str);
if (it != fnMap.end()) { 
    it->second(tokens); 
}

You could also take a look at the interpreter example from Boost.FunctionTypes (header, source file) wether that is similar to your scenario.

Answer 3

I would try a simple data structure, but maybe C++ gurus and STL lovers can think something better. My idea is like

struct smap {
  string s;
  int i;
} str_int_map[] = { { string("strng"), 1 }, /*...*/ };

and then

  j = 0; //default if no match found
  for(i=0; i < 2; i++)
  {
    if ( str_int_map[i].s == a ) 
    {
      j = str_int_map[i].i;
      break;
    }
  }
  switch( j )
  {
  case 1:
    cout << "oooo"; break;
  case 2:
    cout << "nnnn"; break;
  }

Instead of "mapping" to integer, you could "map" to a function address and call it directly, if it fits your need this approach. Instead of this looping for match approach, you could use a real map/dictionary whatever is called in STL from string to number, and then switch on that number as the above example.

Answer 4

First off, Georg's version with the map is more elegant and extensible than a long cascade of comparisons. However, if you are concerned with performance and your cascade being 'slow', then measure how fast it is.

For the example strings you give, I constructed three variations of a function which incremented a value in an array based on the string passed to it. The first was based on your code, the second on Georg's, and the third on the code below, which is the same as yours but with constant strings rather than having to construct the strings from literals each time it's called.

void foo (const std::string& str, int (&count)[6]) 
{
    static const std::string s0 = "something";
    static const std::string s1 = "something else";
    static const std::string s2 = "something more";
    static const std::string s3 = "something again";
    static const std::string s4 = "something different";
    static const std::string s5 = "something really different";

    if(str == s0) {
        ++count[0];
    }else if(str == s1) {
        ++count[1];
    }else if(str == s2) {
        ++count[2];
    }else if(str == s3) {
        ++count[3];
    }else if(str == s4) {
        ++count[4];
    }else if(str == s5) {
        ++count[5];
    }
}

Using VS 2008 Express on the default release settings, these come out as:

operator== with constant strings (the code above)

time 7.015 seconds
0.116917 microseconds per call

std::map lookup (Georg's code)

time 9.687 seconds
0.16145 microseconds per call

operator== with literal strings (original code)

time 10.437 seconds
0.17395 microseconds per call

So unless you're calling the code a lot, then you are not going to notice 174 nanoseconds for your original version. Assuming the map and the if-cascade behave as expected (O(N) and O(log₂N)), then the map should be faster at around 13 strings. But if it matters that much to you, then profile or benchmark it.