How to update C++ optional parameter when argument is passed?

Question

Suppose I have a function like this:

vector<double> compute(const vector<double>& x, vector<double> dx = boost::none) const{
    if (dx)
        dx = getDerivative();
    // do operations on x and return result
}

and I have two use cases for this function, one where I just need the result of the computation, and another where I need the result and the derivative, e.g.:

vector<double> J;
vector<double> y = compute(x);
vector<double> y = compute(x, J);

When I call the second version (passing in J), the values of J are not updated, though dx gets updated inside compute. I would guess this is an issue regarding a pass by reference, but when I update the function signature to vector<double>& dx, I get the following error:

error: cannot bind non-const lvalue reference of type ‘vector<double>&’ to an rvalue of type ‘vector<double>’

Any suggestions how I can tackle this?

Reference can't be null, if you use a pointer instead it should work (with a default value to null) — Chelmy88, Sep 05 '19 at 22:00
How would I update `dx` then? Any alternative ways of doing it? — varagrawal, Sep 05 '19 at 22:06
can't you also pass the pointer to `getDerivative()`, and it is updated inside the function? — Chelmy88, Sep 05 '19 at 22:12
That function is for representative purposes (e.g. a 3rd party library). — varagrawal, Sep 05 '19 at 22:17
Here a solution is proposed: https://stackoverflow.com/questions/1059630/default-value-to-a-parameter-while-passing-by-reference-in-c — Chelmy88, Sep 05 '19 at 22:20
Pass it by pointer `vector* dx = nullptr` and then test and dereference `if (dx != nullptr) *dx = getDerivative();`. — Tom Trebicky, Sep 05 '19 at 23:00

score 3 · Answer 1 · answered Sep 05 '19 at 23:49

Here, you could use overloading instead of default argument.

From your code, the best approach would be:

vector<double> compute(const vector<double>& x) const
{
    // do operations on x and return result
}

vector<double> compute(const vector<double>& x, vector<double> &dx) const
{
    dx = getDerivative();

    compute(x);
}

Written that way, you avoid useless overhead when you don't need the derivative and still reuse common code.

If some other cases, it might make sense to do it the other way if the extra data is not hard to compute but you want simplest code at the caller site. It would look like:

vector<double> compute(const vector<double>& x, vector<double> &dx) const
{
    dx = getDerivative();

    // do operations on x and return result
}

vector<double> compute(const vector<double>& x) const
{
    vector<double> unused_dx;
    compute(x, unused_dx);        
}

However, it has more overhead as you construct a vector and compute the derivative even though you don't need them. Thus that solution is only appropriate when extra code is negligible.

score 0 · Answer 2 · answered Sep 05 '19 at 23:56

vector<double> compute(const vector<double>& x, vector<double> *dx = nullptr) const{
    if (dx)
        *dx = getDerivative();
    // do operations on x and return result
}

vector<double> y = compute(x);

vector<double> J;
vector<double> y = compute(x, &J);

score 0 · Answer 3 · answered Sep 05 '19 at 23:58

Sounds like you want to use a pointer, rather than a reference. For example:

vector<double> compute(const vector<double>& x, vector<double> * const dx = nullptr) const{
    if (dx != nullptr)
        *dx = getDerivative();
    // do operations on x and return result
}

From there, you just need to adjust your calls a little bit:

vector<double> J;
vector<double> y = compute(x);
vector<double> y = compute(x, &J);
//                            ^ Note passing address here.

How to update C++ optional parameter when argument is passed?

3 Answers3