Better design for using function pointers with varying arguments

Question

I have an optimisation algorithm which finds the best partition of a graph.

There are many measures for the quality of a partition (the variable being optimised), so I thought it would be a good idea to use function pointers to these quality functions, and pass that into my optimisation algorithm function.

This works fine, but the problem is different quality functions take some different arguments.

For example one quality function is find_linearised_stability and it requires a markov_time parameter:

float find_linearised_stability(cliques::Graph<T> &my_graph, cliques::Partition &my_partition,
                               std::vector<float> &markov_times, std::vector<float> &stabilities)

and is used in the optimisation function :

cliques::find_optimal_partition_louvain(my_new_graph, markov_times, &cliques::find_linearised_stability);

however another quality function find_modularityrequires no markov_time parameter. Of course I could just include it as an argument and not use it in the function but that seems like bad practice, and would get unwieldy once I start adding a lot of different quality functions.

What is a better design for this kind of situation?

Benjamin Lindley · Accepted Answer · 2011-01-13 19:00:09Z

6

Use function objects. One of those function objects can have a markov_time member that is passed in to the constructor:

struct find_linearised_stability {
    std::vector<float> & markov_times_;

    find_linearised_stability(std::vector<float> & markov_times)
        :markov_times_(markov_times)
    {}

    float operator () (cliques::Graph<T> &my_graph, cliques::Partition &my_partition,
                 std::vector<float> &stabilities)
    {
        // use markov_times_ in here, we didn't need to pass it since it's a member
    }
};

(you may need to make adjustments to constness/referenceness to suit your needs)

Then you can call your function like this:

cliques::find_optimal_partition_louvain(my_new_graph, cliques::find_linearised_stability(markov_times));

"what type for the function object do I use when declaring the ... function?"

Make it a function template that takes the function object type as a template parameter, thusly:

template<typename PR>
whatever find_optimal_partition_louvain(my_new_graph, PR & pr)
{
    ...
    pr(my_new_graph, partition, stabilities);
    ...
}

edited Jan 13, 2011 at 19:00

answered Jan 13, 2011 at 18:24

Benjamin Lindley

104k11 gold badges210 silver badges285 bronze badges

Sign up to request clarification or add additional context in comments.

6 Comments

zenna Over a year ago

Ok but then what type for the function object do I use when declaring the cliques::find_optimal_partition_louvain function?

Benjamin Lindley Over a year ago

@zenna -- Make it a function template, see updated answer for example.

Benjamin Lindley Over a year ago

@zenna -- Note that this also allows you to still pass in regular functions if you have some lying around that you don't feel like converting to function object classes.

Sedat Kapanoglu Over a year ago

If the "extra variable" is a kind which changes every iteration doesn't the programmer need to re-create the function object again and again? Doesn't have that a performance penalty?

Benjamin Lindley Over a year ago

@ssg -- The options are wide here, depending upon the programmer's needs. If this changing extra variable is modified every iteration(rather than using a completely different object), then you can just create a named function object and modify it's member every iteration.

|

Edward Strange · Accepted Answer · 2011-01-13 18:20:02Z

2

Your only option is boost::bind or something like it stored in a boost::function or something like it.

If profiling shows that to be too slow then you'll be stuck with the "poor practice" version because any alternative is going to run afoul of UB and/or end up being just as 'slow' as the more reasonable alternative.

answered Jan 13, 2011 at 18:20

Edward Strange

41k9 gold badges80 silver badges128 bronze badges

Comments

peenut · Accepted Answer · 2011-01-13 18:24:19Z

0

parameter is not known before: add argument to every function (reference/pointer) that contains all info, every function uses whatever it needs
parameter is known before: use boost::bind, e.g.:

sample source code:

#include <iostream>
#include <cstddef>
#include <algorithm>
#include <boost/bind.hpp>
using namespace std;

void output(int a, int b)
{
    cout << a << ", " << b << '\n';
}

int main()
{
    int arr[] = { 1, 2, 3, 4, 5 };
    for_each(arr, arr + 5, bind(output, 5, _1));
    return 0;
}

Outputs:

5, 1
5, 2
5, 3
5, 4
5, 5

answered Jan 13, 2011 at 18:24

peenut

3,42625 silver badges24 bronze badges

Collectives™ on Stack Overflow

Better design for using function pointers with varying arguments

3 Answers 3

6 Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

6 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related