std::invoke of a function template/lambda fails

Question

How can I get this working? (C++17/20) Note: I have to use std::invoke here because in the real code, the only guarantee I have is that this callable is invokable.

#include <bits/stdc++.h> // to include everything

int main() {
    const auto func = [&]<typename T>(const std::string& h) {
        T t;
        std::cout << t << " " << h << "\n";
    };
    std::invoke(func<std::string>, std::string("Hello"));
}

Error:

<source>:17:33: error: expected primary-expression before '>' token
   17 |     std::invoke(func<std::string>, std::string("Hello"));

please do not remove includes from your code. They are needed to reproduce you error. WIthout the includes this code produces totally diffferent errors. Its effort you ask from others trying to compile the code that isnt necessary — 463035818_is_not_an_ai, Jun 29 '23 at 11:33
I've included everything - using the header as such (this is just a dummy example that failed in godbolt, but it's enough to replicate the issue I'm facing in prod) — Happytreat, Jun 29 '23 at 11:34
[Why should I not `#include `?](https://stackoverflow.com/questions/31816095/why-should-i-not-include-bits-stdc-h) — 463035818_is_not_an_ai, Jun 29 '23 at 11:35
`#include ` is a **private** compiler header file. Don't include it yourself. — Eljay, Jun 29 '23 at 11:35
Like I mentioned it's just a dummy code to replicate the prod issue. — Happytreat, Jun 29 '23 at 11:36

Jarod42 · Answer 1 · 2023-06-29T11:52:04.787

2

lambda is not template, but its operator() is.

As T is not deducible, you might write:

std::invoke([&](const std::string &s) { func.operator()<std::string>(s); },
            std::string("Hello"));

or more "simply":

func.operator()<std::string>("Hello");

Demo

edited Jun 29 '23 at 11:52

answered Jun 29 '23 at 11:46

Jarod42

203,559
14
181
302

wohlstad · Accepted Answer · 2023-06-29T16:51:15.733

0

The problem is that your lambda func is not a function template, but rather has a templated operator().

One way to use std::invoke the way you attempted, would be to actually change func into a function template:

#include <string>
#include <iostream>
#include <functional>

template <typename T>
void func(const std::string& h)
{
    T t;
    std::cout << t << " " << h << "\n";
}

int main() 
{
    std::invoke(func<std::string>, std::string("Hello"));
}

Live demo - Godbolt

A side note: better to avoid #include <bits/stdc++.h>.

edited Jun 29 '23 at 16:51

answered Jun 29 '23 at 11:47

wohlstad

12,661
10
26
39

Please explain the downvote. If there's something wrong in my answer I'll be glad to understand it. – wohlstad Aug 30 '23 at 18:02

score 0 · Answer 3 · answered Jun 29 '23 at 17:51

0

One way is to pass the pointer-to-member function (&decltype(f)::operator()<int>), then give it the object (f) and the arguments(std::string)

#include "bits/stdc++.h"

int main() {
    const auto f = []<typename T>(std::string) -> void {};
    std::invoke(&decltype(f)::operator()<int>, f, "hello");
}

answered Jun 29 '23 at 17:51

weineng

146
6

[Why should I not #include ?](https://stackoverflow.com/questions/31816095/why-should-i-not-include-bits-stdc-h). – wohlstad Jun 30 '23 at 06:03

std::invoke of a function template/lambda fails

3 Answers3