Create a launcher for a function of non-sequential arguments with default values

Question

I have a function like this:

typedef std::vector<std::map<int,std::string>> MyVec1;
typedef std::vector<std::map<std::string,std::string>> MyVec2;

enum options { DEFAULT_OPTIONS                   = 0x0000000u,
               OTHERS                            = 0x0000001u };

void func(std::string s1, MyVec1& vec1, MyVec2& vec2, bool type,
                      std::string s2, options opt, uint32_t opt2){
//do something
//And put data to the vectors
}

I want to create a luncher which can take any number of arguments (upto 7) and set default values for the arguments that are not passed and then call the func() with all arguments, kinda like this:

void launcher(args...){
//If any string is passed, pass it as the 1st arg of func, or an empty string
//If any second string is passed, pass it as the 5th arg of func or an empty string
//If any MyVec1 type is passed, pass it as the second arg or a dummy vector.
//If any MyVec2 type is passed, pass it as the third arg or a dummy vector.

////By dummy vector I mean create a vector with MyVec1 vec; and pass it as arg.

////Like this, if other args are passed they are passed to the func with 
////given value otherwise a default value is chosen
////And finally call func() with all arguments.
}

The same can be achieved by overloading and using default values for arguments but that's a huge task if you consider that I want those arguments to be non-sequential too (specially the vectors) i.e launcher will manage if you pass MyVec2 first and MyVec1 as the second.

I had to create 16 overload for a three vector function (3-vector: 6, 2-vector: 6, 1-vector: 3, 0-vector: 1).

Is this even possible?

Note:

1. I think I can detect the type with this. But the rest seems kinda impossible to me.
2. If it is not possible to work with reference then that will do too. I have other functions that needs the same which doesn't work with references (A function with lots of args like the above without those vectors).

Answer 1

A naive implementation of what you suggested is actually fairly straightforward - you basically need something that gets the Ith T out of a tuple, or some default value if it doesn't exist. Add some forwarding pixie dust and you are done.

But it's going to be hard to maintain, and there are thorny design issues with arguments that require a conversion. "foo" by C++'s overload resolution rules converts better to bool than to std::string. Do you want to follow those rules or design your own?

Instead, do something like the named parameters idiom:

struct launcher {
    std::string s1 = "";
    MyVec1* p_vec1 = nullptr;
    MyVec2* p_vec2 = nullptr;
    bool type = false;
    std::string s2 = "";
    options opt = DEFAULT_OPTIONS;
    uint32_t opt2 = 0;
    launcher& set_s1(std::string& s) { s1 = s; return *this; }
    launcher& set_vec1(MyVec1& vec1) { p_vec1 = &vec1; return *this; }
    // etc.
    void launch(){
        MyVec1 vec1; MyVec2 vec2;
        MyVec1& v1 = p_vec1 ? *p_vec1 : vec1;
        MyVec2& v2 = p_vec2 ? *p_vec2 : vec2;
        return func(s1, v1, v2, type, s2, opt, opt2);
    }
};

Answer 2

I assume your intention behind launcher is to deliver a more useable interface to func. Based on this, I wouldn't rely just one a bunch of overloads or templates. You could push a little work to the runtime, but simplify the interface a lot by using simple built in pointers.

void launcher(std::string* s1, MyVec1* vec1, MyVec2* vec2, bool* type,
                  std::string* s2, options* opt, uint32_t* opt2){
//is s1 set?
if (s1 != nullptr) // if(s1) would also be ok
/* Construct the default parameters based on what you get*/
/* not enough parameters to call func?*/
throw std::invalid_argument("You need to specify at least ...");

You could also replace the built-in pointers with boost::optional, since it's more clear what your intentions are and boost also makes some optimizing. You could mix this runtime checks, with overloading and templates, but I guess, launcher will not be called in a loop for scientific calculations, isn't it? And your goal is a simple interface.