如何在不使用C ++ 0x auto的情况下实现此类型特定的对象生成器

Question

I have a templated function where the templated parameter is a functor. I want to generate some internal variables, specific to a particular quality function, to be used by other template functions called from this functor. so I have experimented with the auto keyword and it seems to work

template<typename QF>
float find_optimal_partition_louvain_with_gain(QF quality_function) {
    auto internal_variables = gen(quality_function);
    float result = do_some_work(internal_variables);
    ...
    return result;
}

struct internals_for_linearised_functor {
    double x;
};

internals_for_linearised_functor gen(mynamespace::linearised_function &f) {
    linearised_internals internals;
    internals.x = 5;
    return internals;
}

With auto this seems to compile fine, which is pleasing. I would like to try to stay within the current standard though to make my code more portable. Is there a way this can be handled using the current standard, or is this something that BOOST_AUTO will be able to handle? The general function I am trying to achieve is generate an object based on a on the type of templated paramater without actually passing the type of the new object into the function (ie inferring it)

Thanks

Answer 1

This should work out of the box:

template<typename QF>
float find_optimal_partition_louvain_with_gain(QF quality_function) {
    return do_some_work(gen(quality_function));
}

If you need internal_variables to be around longer than for just one call, you can use another small function to deduce the type:

template<typename QF, typename T>
float find_optimal_partition_louvain_with_gain_detail(QF quality_function, T internal) {
    float result = do_some_work(internal);
    /* use internal and quality_function again here!.*/
    return result;
}


template<typename QF>
float find_optimal_partition_louvain_with_gain(QF quality_function) {
    return find_optimal_partition_louvain_with_gain_detail(
      quality_function,
      gen(quality_function)
    );
}

Hope this helps!

Answer 2

If you don't want to use auto in this case, you'll need to use some kind of meta-function (a function trait, perhaps) to get the return type of gen .

Boost has function traits, or you could implement a traits class specifically for your QF type. If it's a standard function object type, it should have a result_type typedef, which you can get at using typedef typename QF::result_type result_type

Answer 3

Can you wrap gen() as static method inside a struct and then replace the internal_variables ? See the following modified code.

struct Generate
{
  static internals_for_linearised_functor s_Internals; // define somewhere
  static void gen(mynamespace::linearised_function &f)
  {
    linearised_internals internals;
    internals.x = 5;
    s_Internals = internals;
  }
 };

Now, in function find_optimal_partition_louvain_with_gain , you can first call Generate::gen() and then use, Generate::s_Internals instead of internal_variables .

This seems to be easier way to avoid knowing the type of auto . Also, you can make Generate as template<> if needed. For thread safety in above code, we can implement without static also.