4

I'm working on a function which invokes a supplied function with a variable number of arguments. It compiles and works correctly on Visual Studio 2015, but fails to compile on Clang . I've prepared a demonstration which shows what I'm trying to do. The error I get in Clang is:

prog.cpp: In function 'int main()': prog.cpp:31:2: error: no matching function for call to 'run(std::vector&, void ()(int&, const int&), const int&)' ); ^ prog.cpp:7:6: note: candidate: template void run(std::vector&, const std::function&, mutrArgs ...) void run( ^ prog.cpp:7:6: note: template argument deduction/substitution failed: prog.cpp:31:2: note: mismatched types 'const std::function' and 'void ()(int&, const int&)' );

#include <functional> #include <iostream> #include <vector> using namespace std; template<int RepeatTimes, class ... mutrArgs> void run( vector<int>& vec, const function<void(int&, mutrArgs ...)>& mutr, mutrArgs ... args ) { for (int times{0} ; times < RepeatTimes ; ++times) for (auto& item : vec) mutr(item, args...); } void adder(int& i, const int& val) { i += val; } int main() { vector<int> v{0,1,2,3,4,5,6,7,8,9}; const int addValue{4}; run<2, const int&>( v, &adder, addValue ); for (auto i : v) cout << i << " "; cout << endl; return 0; }
Improve this question
5
  • Instead of using std::function, make the type a template too, like all standard algorithm functions. Commented Jul 15, 2016 at 12:52
  • In the non demonstration function, it's required to take a set number of arguments. Commented Jul 15, 2016 at 12:54
  • 2
    If you use std::function<void(int&,const int&)>(&adder) it compiles. Not sure why it needs to be specified though. Might have to do with the pack part not being deducible but I am uncertain of the rules. Commented Jul 15, 2016 at 12:57
  • Or if you pass by function pointer for run<2, const int&>, it works too Demo Commented Jul 15, 2016 at 13:02
  • 1
    using std::function<decltype(adder)>(adder) compile with clang++ 3.5 and with g++ 4.9.2 Commented Jul 15, 2016 at 13:12

2 Answers 2

Reset to default
1

run<2, const int&> just state the first argument, but doesn't deactivate deduction.

run<2, const int&>(v, &adder, addValue);

has 2 places to deduce mutrArgs:

  • addValue -> mutrArgs = { const int& }

  • &adder which is not a std::function and so fail.

Taking address of function fix that problem

auto call_run = &run<2, const int&>; call_run(v, &adder, addValue);

Strangely, clang doesn't support the inlined usage contrary to gcc :/

(&run<2, const int&>)(v, &adder, addValue);

If you want to disable deduction, you may make your template arg non deducible:

template <typename T> struct identity { using type = T; }; template <typename T> using non_deducible_t = typename identity<T>::type;

And then

template<int RepeatTimes, class ... mutrArgs> void run( std::vector<int>& vec, const std::function<void(int&, non_deducible_t<mutrArgs> ...)>& mutr, non_deducible_t<mutrArgs> ... args )

Demo

Even if in your case a simple typename F as suggested by Joachim Pileborg seems better.

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

1 Comment

To get it to finally compile correctly on clang I needed to do both, get the function address and use the deducing template.
1

If you look at all standard library algorithm function, at least the ones taking a "predicate" (a callable object) they take that argument as a templated type.

If you do the same it will build:

template<int RepeatTimes, typename F, class ... mutrArgs> void run( vector<int>& vec, F mutr, mutrArgs ... args ) { ... }

See here for an example of you code. Note that you don't need to provide all template arguments, the compiler is able to deduce them.

Improve this answer

1 Comment

This circumvents the required usage, and would certainly work of course.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.