CODEWITHSUNDEEP
c++
R. N
R. N

Reputation: 759

C++ function map with varialbles input

In C++, I want to use a map of functions with different type of input or output.

Do to so, I found that using a map with any type could be a way. But I get several problems. First, I can not use directly the functions in the map. However, I can use a lambda function to wrap the functions then use these lambda functions in the map. But, I get a second problem, I still need to cast with the lambda function which is not a variable. This makes a use from a string variable complicated.

Here is a MWE:

#include <any>
#include <functional>
#include <iostream>
#include <map>
#include <string>


void funct0()
{
std::cout << "funct0" << std::endl;
}

void funct1(int p)
{  
std::cout << "funct1 " << p << std::endl;
};

int funct2(int p, std::string s)
{  
std::cout << "funct2 " << s << std::endl;
return p+1;
};

float funct3(int a, float b)
{
std::cout << "funct3 " << std::endl;
return a +b;
}

auto funct4(int a, float b)
{
std::cout << "funct4 " << std::endl;
std::vector<float> v;
v.push_back(a); 
v.push_back(b);
return v;
}


int main()
{  
    std::map<std::string, std::any> mapFunct;
    mapFunct["F0"]= funct0;
    // mapFunct["FO"](); // error: no match for call to ‘(std::map<std::__cxx11::basic_string<char>, std::any>::mapped_type {aka std::any}) ()’
    mapFunct["F1"]= funct1;
    // mapFunct["F1"](12); // error: no match for call to ‘(std::map<std::__cxx11::basic_string<char>, std::any>::mapped_type {aka std::any}) (int)’
    // WHY THIS IS NOT WORKING ?


    // From this link: https://stackoverflow.com/questions/61969316/is-it-possible-to-put-lambda-expressions-into-a-map-or-list-in-c
    auto lambda0 = [](){funct0();};
    auto lambda1 = [](int p) { funct1(p); return p; };
    auto lambda2 = [](int p, std::string s) { return funct2(p,s); };
    auto lambda3 = [](int a, float b){return funct3(a,b);};
    auto lambda4 = [](int a, float b){return funct4(a,b);};

    std::map<std::string, std::any> mapLambda;
    mapLambda["L0"]=lambda0;
    mapLambda["L1"]=lambda1;
    mapLambda["L2"]=lambda2;
    mapLambda["L3"]=lambda3;
    mapLambda["L4"]=lambda4;

    std::any_cast<decltype(lambda0)>(mapLambda["L0"])();
    std::any_cast<decltype(lambda1)>(mapLambda["L1"])(2);
    std::cout << std::any_cast<decltype(lambda2)>(mapLambda["L2"])(4, "HELLO") << std::endl;
    std::cout << std::any_cast<decltype(lambda3)>(mapLambda["L3"])(3, 4.32) << std::endl ;
    auto vec4= std::any_cast<decltype(lambda4)>(mapLambda["L4"])(6, 9.1);
    std::cout << "vec4" << vec4[1] << vec4[2] << std::endl ;

    std::vector<std::string> inputString;
    inputString.push_back("L3(3, 4.32)");
    inputString.push_back("L4(6, 9.1)");

    // Using a for loop with iterator
    for(auto it = std::begin(inputString); it != std::end(inputString); ++it) {
        std::cout << *it << "\n";
        std::string line=*it;
        std::string functionInput = line.substr( 0, line.find("(") );
        std::cout << functionInput << std::endl;
        // argumentsInput= ;
        mapLambda[functionInput](argumentsInput);
}
};

So my question are:

Upvotes: 0

Views: 131

Answers (2)

Dave
Dave

Reputation: 327

std::any_cast needs to cast to constructible types. A standard C++ function is neither a type nor constructible (it's just a group of statements given a name [edit: this isn't technically true, but what's going on under the hood is fairly complicated]), but std::function is. One way to get around this is to assign a standard C++ function to an std::function. Here's an example using a std::map like you were using:

#include <any>
#include <functional>
#include <iostream>
#include <map>

int my_func(int val) { return val + 1; }

std::function<int(int)> f = my_func;

int main() {
  auto my_map = std::map<std::string, std::any>();
  my_map["func"] = f;

  std::cout << std::any_cast<std::function<int(int)>>(my_map["func"])(13) << std::endl; // prints "14"

  return 0;
}

Lambdas are constructible types, which is why your code works for lambdas.

To answer your second question: I don't think it's possible. Functions with different signatures are different types, and you have to know what you're casting to. std::function<int(int, string)> and std::function<float(int, float)>, for example, are different types.

Also, the intended purpose of lambdas is to be used once then discarded. If you're going to keep lambdas around for reuse, it's better to simply just use functions.

Upvotes: 1

Igor Tandetnik
Igor Tandetnik

Reputation: 52471

What you probably want is something like this:

using CallWrapper = std::function<void(const std::string&)>;
std::map<std::string, CallWrapper> mapLambda;

mapLambda["L0"] = [funct0](const std::string&) { funct0(); };

mapLambda["L1"] = [funct1](const std::string& args) {
  int p = ...; // parse the argument from `args`
  funct1(p);
};

mapLambda["L2"] = [funct2](const std::string& args) {
  // parse the arguments from `args`
  int p = ...; 
  std::string s = ...;
  funct2(p, s);
};

Now you can run the loop you envision:

for(const std::string& line : inputString) {
    size_t pos = line.find('(');
    std::string functionInput = line.substr( 0,  pos);
    std::string argumentsInput = line.substr(pos);
    mapLambda[functionInput](argumentsInput);
}

The hard part, of course, is "parse the arguments from args", left as an exercise for the reader.

Upvotes: 1

Related Questions