Store functions with different signatures in a map

by

You can type-erase the function types into a container, then provide a template operator(). This will throw std::bad_any_cast if you get it wrong.

N.B. because of the type erasure, you will have to specify exactly matching arguments at the call site, as e.g. std::function<void(std::string)> is distinct from std::function<void(const char *)>, even though both can be called with a value like "Hello".

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

template<typename Ret>
struct AnyCallable
{
    AnyCallable() {}
    template<typename F>
    AnyCallable(F&& fun) : AnyCallable(std::function(std::forward<F>(fun))) {}
    template<typename ... Args>
    AnyCallable(std::function<Ret(Args...)> fun) : m_any(fun) {}
    template<typename ... Args>
    Ret operator()(Args&& ... args) 
    { 
        return std::invoke(std::any_cast<std::function<Ret(Args...)>>(m_any), std::forward<Args>(args)...); 
    }
    std::any m_any;
};

void foo(int x, int y)
{
    std::cout << "foo" << x << y << std::endl;
}

void bar(std::string x, int y, int z)
{
    std::cout << "bar" << x << y << z << std::endl;
} 

using namespace std::literals;

int main()
{
    std::map<std::string, AnyCallable<void>> map;
    
    map["foo"] = &foo;      //store the methods in the map
    map["bar"] = &bar;
    
    map["foo"](1, 2);       //call them with parameters I get at runtime
    map["bar"]("Hello, std::string literal"s, 1, 2);
    try {
        map["bar"]("Hello, const char *literal", 1, 2); // bad_any_cast
    } catch (std::bad_any_cast&) {
        std::cout << "mismatched argument types" << std::endl;
    }
    map["bar"].operator()<std::string, int, int>("Hello, const char *literal", 1, 2); // explicit template parameters
    
    return 0;
}

More Related Contents:

  1. Avoid memory leaks in C++ Pointers [closed]
  2. How can I pad an int with leading zeros when using cout
  3. Why does C++11’s lambda require “mutable” keyword for capture-by-value, by default?
  4. Why is initialization of a new variable by itself valid? [duplicate]
  5. Error when compiling some simple c++ code
  6. Private virtual method in C++
  7. Is there a C++ equivalent to Java’s BigDecimal?
  8. How is P0522R0 breaking code?
  9. NetUIHWND and DirectUIHWND [closed]
  10. Using Boost to read and write XML files
  11. Calculating size of an array
  12. What is the proper function for comparing two C-style strings?
  13. What is a good OO C++ wrapper for sqlite [closed]
  14. How to pretty-print STL containers in GDB?
  15. How to extract the source filename without path and suffix at compile time?
  16. Is the ranged based for loop beneficial to performance?
  17. When extending a padded struct, why can’t extra fields be placed in the tail padding?
  18. Arity of a generic lambda
  19. Converting bool to text in C++
  20. How can i estimate memory usage of std::map?
  21. How can I use std::imbue to set the locale for std::wcout?
  22. Fastest way to Convert String to Binary?
  23. When a float variable goes out of the float limits, what happens?
  24. OpenMP: What is the benefit of nesting parallelizations?
  25. Deleted Function in std::pair when using a unique_ptr inside a map
  26. error for hash function of pair of ints
  27. Is it possible to use threads to speed up file reading?
  28. “APIENTRY _tWinMain” and “WINAPI WinMain” difference
  29. Qt equivalent of PathAppend?
  30. Reading a Matrix txt file and storing as an array

Leave a Comment