C++ Passing templated functions to function

Question

I need to pass a templated function to a function.

Until now I haven't found any great advices on google. This is what I tried:

#include <iostream>
#include <sstream>
using namespace std;

struct event {
  bool signal;
};

template<typename T>
void out_stream(T &stream, event &evt) {
  stream << evt.signal;
}

template <typename F>
void doOperation(F f)
{
  event test;
  test.signal = 0;
  stringstream ss;

  f(ss, test);
}

int main() {

  doOperation(out_stream);

  return 0;
}

And that's the error the compiler gives me:

main.cc:27:3: error: no matching function for call to 'doOperation'
  doOperation(out_stream);
  ^~~~~~~~~~~
main.cc:16:6: note: candidate template ignored: couldn't infer template argument 'F'
void doOperation(F f)
     ^
1 error generated.

Some (I hope) useful information about my g++ compiler setup:

Apple clang version 13.0.0 (clang-1300.0.29.30)
Target: x86_64-apple-darwin20.6.0
Thread model: posix

Thank you in advance :)

In your case, change `T` to `ostream` and remove the template. In general, wrap the function in a generic lambda. — Passer By, Jan 26 '22 at 17:41
related/dupe: https://stackoverflow.com/questions/54182502/call-a-functor-with-a-specific-function-from-an-overload-set — NathanOliver, Jan 26 '22 at 17:43
Instead of accepting a template you could accept a function pointer with the type `template using F = void (*)(T&, event&);` specialized for `stringstream`. — vandench, Jan 26 '22 at 17:43

rturrado · Accepted Answer · 2022-01-26T19:47:01.353

For this particular case, you could help the compiler deduce T by calling doOperation with out_stream<std::stringstream>.

Also, within doOperation, you need to use f instead of F.

[Demo]

#include <iomanip>  // boolalpha
#include <iostream>  // cout
#include <sstream>  // stringstream

struct event {
    bool signal{};
};

template<typename T>
void out_stream(T& stream, const event& evt) {
    stream << std::boolalpha << evt.signal;
}

template <typename F>
void doOperation(F&& f) {
    std::stringstream ss{};
    f(ss, event{true});
    std::cout << ss.str() << "\n";
}

int main() {
    doOperation(out_stream<std::stringstream>);
}

// Outputs:
//
//   true

As suggested in the comments though, other options you have instead of passing an instantiation of a function template are:

Change out_stream to accept a std::ostream&.
Pass a generic lambda that just calls the instantiation of the function template.

[Demo]

#include <iomanip>  // boolalpha
#include <iostream>  // cout
#include <sstream>  // stringstream

struct event {
    bool signal{};
};

void out_stream1(std::ostream& stream, const event& evt) {
    stream << std::boolalpha << evt.signal;
}

template <typename T>
void out_stream2(T& stream, const event& evt) {
    stream << std::boolalpha << evt.signal;
}

template <typename F>
void doOperation(F&& f) {
    std::stringstream ss{};
    f(ss, event{true});
    std::cout << ss.str() << "\n";
}

int main() {
    doOperation(out_stream1);
    doOperation([](auto& stream, const auto& evt) { out_stream2(stream, evt); });
}

// Outputs:
//
//   true
//   true

Notice also there are no templated functions, but function templates. out_stream is a function template and needs to be instantiated with a given type, e.g. out_stream<std::stringstream>, to become a function. In the call doOperation(out_stream);, the compiler is unable to deduce the type to instantiate out_stream with.

C++ Passing templated functions to function

1 Answers1