Supply second optional argument without need to suply first optional argument?

Question

I have a function like this:

 void foo(int optionalinteger=0, float optionalfloat=0.0f, cell *optionalarray=NULL)
 {
          return;
 }

I tried to acces an optional argument like

 foo(.optionalfloat=5.5f); // from another programming language

but that gives an error. How do I access only the optional value I choose to without the need to supply other optional values?

Answer 1

Depending on your needs, you could overload the foo() function.

void foo(int optionalinteger=0, float optionalfloat=0.0f, cell *optionalarray=NULL)
{
    return;
}

void foo( float optionalfloat )
{
    foo( 0, optionalfloat, NULL );
}

This solution is of course limited as it will not work in all situations. If given the following method

void foo(int optlint=0, float optflt1=0.0f, float optflt2=0.0f, cell *optionalarray=NULL)
{
    return;
}

It would not be possible to create individual overloaded functions for both float parameters.

Answer 2

If you really want to, you can use something akin to the named parameter idiom, e.g.:

struct cell;

void foo(int optionalinteger, float optionalfloat, cell *optionalarray) {}

struct foo_params {
  foo_params& integer(int v) { integer_ = v; return *this; }
  foo_params& fl(float v) { fl_ = v; return *this; }
  foo_params& array(cell *v) { array_ = v; return *this; }

  // C++11 defaults for laziness, easy to change though
  int integer_=0;
  float fl_=0.0f;
  cell *array_=nullptr;
};

void foo(foo_params params = foo_params()) {
  foo(params.integer_, params.fl_, params.array_);
}

int main() {
  foo(foo_params().integer(100)
                  .array(0));
}

That's quite a lot of work for something quite simple and counter-intuitive if you're not really expecting to see something like that in your code base.

Or you could use the boost named parameter library if you prefer.