How to map a string to a function with Visual Studio 2008?

Question

This question references the following asked question: Using a STL map of function pointers

In C++11, I am using a map to store a <string, function> pair to more efficiently execute code instead of using if...else if...else if as mentioned by the referenced link.

The code is encapsulated in a member function, where this refers to the class, allowing access to member variables.

using f = std::function<void()>;
static const std::map<std::string, f> doSumthin{
  {"case 1", [this]() {
    // execute code in case 1
  }},
  {"case 2", [this]() {
   // execute code in case 2
  }},
  …
};

auto it = doSumthin.find(someString);

if (it != doSumthin.end())
{
    it->second();
}

However, I need to make the code base work in VS 2008. I'm not sure what the most optimal way to achieve replicate the above code to work in VS 2008 without reverting back to the less efficient if...else if.

Can I get some guidance in regards to this issue?

Do you mean to say C++98(http://www.cplusplus.com/doc/oldtutorial/) ? — H S, Jan 09 '20 at 06:22
Could you provide more context? What does `this` refer to? Is the map created inside a member function? Also, why is it `static`? Does the code that uses the map have access to the object that `this` refers to? — Indiana Kernick, Jan 09 '20 at 06:29
VS2008 doesn't support C++11. (We switched to VS2013 to get least C++11 support at all.) So, I doubt that `std::function` is available. I doubt as well that `using` is supported the way you use it in `using f = std::function;`. Actually, I didn't try these modern things then we used VS2008 in the past. — Scheff's Cat, Jan 09 '20 at 06:33

score 4 · Answer 1 · answered Jan 09 '20 at 06:33

4

#include <map>
#include <string>

typedef void (*func_ptr_type)();

void func_case_1() {}
void func_case_2() {}

static std::map<std::string, func_ptr_type> doSumthin;

void initMap()
{
    doSumthin["case 1"] = func_case_1;
    doSumthin["case 2"] = func_case_2;
}

int main()
{
    initMap();

    std::map<std::string, func_ptr_type>::iterator it = doSumthin.find("case 1");
    if (it != doSumthin.end())
    {
        it->second();
    }
    return 0;
}

answered Jan 09 '20 at 06:33

robthebloke

9,331
9
12

I have over a dozen cases, do I have to declare `void case_x()` a dozen times? – Pangu Jan 09 '20 at 06:57
Sadly, yes. Lambdas didn't arrive until C++11. – robthebloke Jan 09 '20 at 07:02

Indiana Kernick · Accepted Answer · 2020-01-09T09:03:36.453

I haven't tested this on VS2008 specifically but I'm fairly sure it's valid C++98.

#include <map>
#include <string>

class Foo {
  void case_1() {}
  void case_2() {}

  typedef std::map<std::string, void(Foo::*)()> CaseMap; 

  static CaseMap initCases() {
    CaseMap cases;
    cases["case_1"] = &Foo::case_1;
    cases["case_2"] = &Foo::case_2;
    return cases;
  }

  static const CaseMap cases;

public:
  void execute(const std::string &name) {
    CaseMap::const_iterator iter = cases.find(name);
    if (iter != cases.end()) {
      void(Foo::*func)() = iter->second;
      (this->*func)();
    }
  }
};

const Foo::CaseMap Foo::cases = Foo::initCases();

Another possibility is to use X-macros. I believe this is as close as you can get to the C++11 snippet (but I wouldn't recommend using it).

#define CASES(X)        \
  X(case_1, {           \
    /* do case 1 */     \
  })                    \
  X(case_2, {           \
    /* do case 2 */     \
  })

#define DEFINE_FUNCTION(NAME, CODE) void NAME() CODE
#define INIT_MAP(NAME, CODE) cases[#NAME] = &Bar::NAME;

class Bar {
  CASES(DEFINE_FUNCTION)

  typedef std::map<std::string, void(Bar::*)()> CaseMap;

  static CaseMap initCases() {
    CaseMap cases;
    CASES(INIT_MAP)
    return cases;
  }

  static const CaseMap cases;

public:
  void execute(const std::string &name) {
    CaseMap::const_iterator iter = cases.find(name);
    if (iter != cases.end()) {
      void(Bar::*func)() = iter->second;
      (this->*func)();
    }
  }
};

const Bar::CaseMap Bar::cases = Bar::initCases();

I have over a dozen cases, do I have to declare `void case_x()` a dozen times? — Pangu, Jan 09 '20 at 06:56
C++98 doesn't have lambdas so you'll have to declare a function for each case. An if-else chain is probably the only way to avoid that — Indiana Kernick, Jan 09 '20 at 06:58
I prefer efficiency over cleanliness.....do you believe your first answer executes quicker then the big-chain if-else? — Pangu, Jan 09 '20 at 08:08
@Pangu Both `Foo` and `Bar` are *probably* faster than an if-else chain. In terms on time complexity, the if-else is O(n) and the others are O(log n). You'll have to measure the performance to see for yourself. — Indiana Kernick, Jan 09 '20 at 08:11

How to map a string to a function with Visual Studio 2008?

2 Answers2