Container with function member with variable number of arguments - c++

Question

I'm trying to come up with a better way of representing the following:
using InsBase0 = std::tuple<std::string, std::function<void()>>;
static const std::array<InsBase0, 1> ins0_bases = {{
{"NOP", 0x0},
}};
using InsBase1 = std::tuple<std::string, std::function<void(const std::string &)>>;
static const std::array<InsBase1, 7> ins1_bases = {{
{"INC", 0x0},
{"DEC", 0x0},
{"AND", 0x0},
{"OR", 0x0},
{"XOR", 0x0},
{"CP", 0x0},
{"SUB", 0x0},
}};
using InsBase2 = std::tuple<std::string, std::function<void(const std::string &, const std::string&)>>;
static const std::array<InsBase2, 6> ins_bases = {{
{"LD", 0x0},
{"ADD", 0x0},
{"ADC", 0x0},
{"SBC", 0x0},
{"JP", 0x0},
{"JR", 0x0},
}};
(utterly contrived example, imagine functions in place of 0x0 and something more sane like a map instead of an array or a struct instead of the tuple)
The context is that this is an assembler, so I need to map instructions to functions.
In a perfect world, I'd like to be able to put all of the instructions into one array/container (with an additional args member to denote the number of args the function takes), but I'd be happy with not duplicating the definitions with StructName0 as well

Answer 1

Two bits of metaprogramming helpers:
template<std::size_t I>
using index=std::integral_constant<std::size_t, I>;
template<class T> struct tag_t {constexpr tag_t(){};};
template<class T> tag_t<T> tag{};
template<std::size_t, class T>
using indexed_type = T;
Now we define an enum type for each of the argument counts:
enum class zero_op:std::size_t { NOP };
enum class one_op:std::size_t { INC };
enum class two_op:std::size_t { ADD };
Next, a mapping from the types to the argument count:
constexpr index<0> args( tag_t<zero_op> ) { return {}; }
constexpr index<1> args( tag_t<one_op> ) { return {}; }
constexpr index<2> args( tag_t<two_op> ) { return {}; }
This takes a template and a count and a type, and repeatedly passes the type to the template:
template<template<class...>class Z, class T, class Indexes>
struct repeat;
template<template<class...>class Z, class T, std::size_t I>
struct repeat<Z, T, index<I>>:
repeat<Z, T, std::make_index_sequence<I>>
{};
template<template<class...>class Z, class T, std::size_t...Is>
struct repeat<Z, T, std::index_sequence<Is...>> {
using type=Z<indexed_type<Is, T>...>;
};
template<template<class...>class Z, class T, std::size_t N>
using repeat_t = typename repeat<Z, T, index<N>>::type;
We use this to build our std::function signatures:
template<class...Args>
using void_call = std::function<void(Args...)>;
template<std::size_t N, class T>
using nary_operation = repeat_t< void_call, T, N >;
and nary_operation< 3, std::string const& > is std::function<void(std::string const&,std::string const&,std::string const&)>.
We use this to create a compile time polymorphic table:
template<class...Es>
struct table {
template<class E>
using operation = nary_operation<args(tag<E>), std::string const&>;
template<class E>
using subtable = std::map< E, operation<E> >;
std::tuple< subtable<Es>... > tables;
template<class E>
operation<E> const& operator[]( E e ) {
return std::get< subtable<E> >( tables )[e];
}
};
or something like that.
If you have an intance of table<zero_op, one_op, two_op> bob, you can do
bob[ zero_op::NOP ]();
or
bob[ zero_op::INC ]("foo");
or
bob[ zero_op::ADD ]("foo", "bar");
The type of the enum in [] changes the type of the function object returned.
The above probably has typos.
But, the end result is type-safe.

Answer 2

I couldn't figure out a way to store all operations in one structure and still have compile time checks. Yet it is possible to check the number of passed values at runtime.
#include <iostream>
#include <functional>
#include <string>
#include <unordered_map>
class operation
{
using op0_funcptr = void(*)();
using op1_funcptr = void(*)(const std::string&);
using op2_funcptr = void(*)(const std::string&, const std::string&);
using op0_func = std::function<void()>;
using op1_func = std::function<void(const std::string&)>;
using op2_func = std::function<void(const std::string&, const std::string&)>;
std::tuple<
op0_func,
op1_func,
op2_func> m_functions;
public:
operation() :m_functions(op0_func(), op1_func(), op2_func()) {}
operation(const op0_func& op) :m_functions(op, op1_func(), op2_func()) {}
operation(const op0_funcptr& op) :m_functions(op, op1_func(), op2_func()) {}
operation(const op1_func& op) :m_functions(op0_func(), op, op2_func()) {}
operation(const op1_funcptr& op) :m_functions(op0_func(), op, op2_func()) {}
operation(const op2_func& op) :m_functions(op0_func(), op1_func(), op) {}
operation(const op2_funcptr& op) :m_functions(op0_func(), op1_func(), op) {}
operation(const operation& other) = default;
operation(operation&& other) = default;
void operator()() { std::get<op0_func>(m_functions)(); }
void operator()(const std::string& p1) { std::get<op1_func>(m_functions)(p1); }
void operator()(const std::string& p1, const std::string& p2) { std::get<op2_func>(m_functions)(p1, p2); }
};
void nop()
{
std::cout << "NOP" << std::endl;
}
void inc(const std::string& p1)
{
std::cout << "INC(" << p1 << ")" << std::endl;
}
void add(const std::string& p1, const std::string& p2)
{
std::cout << "ADD(" << p1 << ", " << p2 << ")" << std::endl;
}
std::unordered_map<std::string, operation> operations{ {
{ "NOP", nop },
{ "INC", inc },
{ "ADD", add }
} };
int main(int argc, char** argv)
{
operations["NOP"]();
operations["INC"]("R1");
operations["ADD"]("R2", "R3");
operations["ADD"]("R2"); //Throws std::bad_function_call
}
It's by far not the best solution, but it works.
If you want to make the access faster you can also try to change the lower part to something like this:
enum class OP : size_t
{
NOP,
INC,
ADD,
NUM_OPS
};
std::array<operation, (size_t)OP::NUM_OPS> operations{ nop ,inc, add };
int main(int argc, char** argv)
{
operations[(size_t)OP::NOP]();
operations[(size_t)OP::INC]("R1");
operations[(size_t)OP::ADD]("R2", "R3");
//operations[(size_t)OP::ADD]("R2"); //Throws std::bad_function_call
}

Answer 3

I suggest the use of single std::map where the key is the name of the function (NOP, AND, ADD, etc.).
Using inheritance, a trivial base class, a std::function wrapper...
Not really elegant, I suppose, but...
#include <map>
#include <memory>
#include <iostream>
#include <functional>
struct funBase
{
// defined only to permit the dynamic_cast
virtual void unused () const {};
};
template <typename R, typename ... Args>
struct funWrap : public funBase
{
std::function<R(Args...)> f;
funWrap (R(*f0)(Args...)) : f { f0 }
{ }
};
template <typename R, typename ... Args>
std::unique_ptr<funBase> makeUFB (R(*f)(Args...))
{ return std::unique_ptr<funBase>(new funWrap<R, Args...>(f)); }
template <typename F, typename T, bool = std::is_convertible<F, T>::value>
struct getConv;
template <typename F, typename T>
struct getConv<F, T, true>
{ using type = T; };
template <typename F, typename T>
struct getConv<F, T, false>
{ };
template <typename ... Args>
void callF (std::unique_ptr<funBase> const & fb, Args ... args)
{
using derType = funWrap<void,
typename getConv<Args, std::string>::type const & ...>;
derType * pdt { dynamic_cast<derType *>(fb.get()) };
if ( nullptr == pdt )
std::cout << "call(): error in conversion" << std::endl;
else
pdt->f(args...);
}
void fNop ()
{ std::cout << "NOP!" << std::endl; }
void fAnd (std::string const & s)
{ std::cout << "AND! [" << s << ']' << std::endl; }
void fAdd (std::string const & s1, std::string const & s2)
{ std::cout << "ADD! [" << s1 << "] [" << s2 << ']' << std::endl; }
int main()
{
std::map<std::string, std::unique_ptr<funBase>> fm;
fm.emplace("NOP", makeUFB(fNop));
fm.emplace("AND", makeUFB(fAnd));
fm.emplace("ADD", makeUFB(fAdd));
callF(fm["NOP"]); // print NOP!
callF(fm["AND"], "arg"); // print AND! [arg]
callF(fm["ADD"], "arg1", "arg2"); // print ADD! [arg1] [arg2]
callF(fm["ADD"], "arg1"); // print call(): error in conversion
//callF(fm["ADD"], "arg1", 12); // compilation error
return 0;
}
P.s.: works with C++11 too.

Answer 4

Instead of having a std::string argument for your functions, you could use a std::vector<std::string>, so you could store multiple arguments.
That would relate to something like :
using function_t = std::function<void(const std::vector<std::string>&)>;
static const std::unordered_map<std::string, function_t> instructions =
{
{"INC", somefunc},
...
};
And then to call the proper instruction :
std::vector<std::string> arguments = { "zob", "zeb" };
auto result = instructions["INC"](arguments);
Edit :
Here's the rest of how I would do it, to prove you it's not that long :
/**
* Your instruction type. Contains its name,
* the function to call, and the number of args required
*/
struct Instruction {
using function_t = std::function<void(std::vector<std::string>)>;
std::string name;
function_t function;
std::size_t numargs;
Instruction(const std::string& name = "undefined", const function_t& function = function_t(), std::size_t numargs = 0)
: name(name)
, function(function)
, numargs(numargs) {}
}
/**
* Your instruction set. It contains the instructions you want to register in.
* You can call the instructions safely through this
*/
struct InstructionSet {
std::unordered_map<std::string, Instruction> instructions;
void callInstruction(const std::string& inst_name, const std::vector<std::string>& arguments) {
if (!instructions.count(inst_name))
return; // no instruction named "inst_name", return or throw something relevant
auto instruction = instructions[inst_name];
if (instruction.numargs != arguments.size())
return; // too many / not enough parameters, return or throw something relevant
instruction.function(arguments);
}
void registerInstruction(const Instruction& instruction) {
instructions[instruction.name] = instruction;
}
};
int main() {
InstructionSet instruction_set;
instruction_set.registerInstruction(Instruction(
"INC",
[](const std::vector<std::string>& arguments) {
bake_cookies_plz(arguments);
},
2)
);
instruction_set.callInstruction("INC", { "1", "2" });
return 0;
}
Note 1 : in this example, the InstructionSet is responsible for checking the number of arguments passed, but the functions could do it themselves. I would do that if there was a possibility of variable arguments count
Note 2 : the registering part is not quite elegant with lambdas, but it's quick to write
Note 3 : if you want more type safety for your arguments, go check max66 answer to get an idea of how to master templates in this situation