Factoring out an overloaded function call

Question

Suppose we have two overloads of a function, where A and B are user-defined types:

void f(A &a, B *b);
void f(B *b);

We also have the corresponding overloads of a function implementing an algorithm:

void alg(A &a, B *b) {
    // ... some code calling f(a,b)
}

void alg(B *b) {
    // ... same code as alg(A &a, B *b), with f(a,b) replaced by f(b)
}

Is there a way to factor out the calls to f to avoid code duplication in this case?

http://stackoverflow.com/questions/6829241/perfect-forwarding-whats-it-all-about ? — user3159253, Sep 20 '16 at 08:07
@user3159253 I do not see how perfect forwarding helps in this case. In particular, please note that the number of parameters varies between overloads. — AlwaysLearning, Sep 20 '16 at 08:11
Which code do you want to minimize? Source or compiled? Does `alg(...)` use its arguments aside from passing them on to `f(...)`? — Deduplicator, Sep 20 '16 at 08:33
Well, then interjay got it. If a bit more source is acceptable for less compiled, look for delegates in C++. — Deduplicator, Sep 20 '16 at 08:39

Garf365 · Accepted Answer · 2016-09-20T08:30:11.310

3

A possible solution is using lambda:

template<typename T>
static function doAlg(T fct)
{
    // Common code, use fct() instead of f(a,b) or f(b)
}

void alg(A &a, B*b)
{
    doAlg([&a, b](){ f(a,b); }); // when doAlg call fct(), it will call f(a,b);
}

void alg(B*b)
{
    doAlg([b](){ f(b); }); // when doAlg call fct(), it will call f(b);
}

If you can not use feature of C++11 like lambda, just use functor or abstract class in place of lambda

Version with functor (if you can not/don't want to use lambda):

struct CallFWithAB
{
    CallFWithAB(A &a, B *b):
        _a(a), _b(b)
    {}

    A &_a;
    B *_b;

    void operator()()
    {
        f(_a,_b);
    }
}

struct CallFWithB
{
    CallFWithAB(B *b):
        _b(b)
    {}

    B *_b;

    void operator()()
    {
        f(_b);
    }
}

template<class T>
static function doAlg(T& fct)
{
    // Common code, use fct() instead of f(a,b) or f(b)
}

void alg(A &a, B*b)
{
    CallFWithAB caller(a,b);
    doAlg(caller); // when doAlg call fct(), it will call f(a,b);
}

void alg(B*b)
{
    CallFWithB caller(b);
    doAlg(caller); // when doAlg call fct(), it will call f(b);
}

edited Sep 20 '16 at 08:30

answered Sep 20 '16 at 08:12

Garf365

3,619
5
29
41

`doAlg()` could be templated to avoid the need to build the `std::function` – Richard Hodges Sep 20 '16 at 08:27
@RichardHodges right, I forget it everytime. Corrected – Garf365 Sep 20 '16 at 08:31
@RichardHodges Sorry for the possibly dumb question. I do not understand what the savings is. – AlwaysLearning Sep 20 '16 at 08:35
1

@AlwaysLearning `std::function` is likely to perform dynamic memory allocation and calls through it are polymorphic. If you're calling it in a loop, you're likely to see a performance benefit using a callable template type instead. – Richard Hodges Sep 20 '16 at 08:40

score 3 · Answer 2 · answered Sep 20 '16 at 08:28

3

You can use perfect forwarding with variadic templates:

template <typename... Args>
void alg(Args&&... args)
{
    // ...

    f(std::forward<Args>(args)...);

    // ...
}

answered Sep 20 '16 at 08:28

interjay

107,303
21
270
254

Very nice solution. The only reason I did not choose it is that I want to keep my parameter list for consistency with other classes implementing a similar `alg` member function. – AlwaysLearning Sep 20 '16 at 08:45

Factoring out an overloaded function call

2 Answers2