Why does using the default template parameter for a function also used in a lambda parameter not work

Question

Take the following peice of c++ code, which compiles fine (gcc 10.1.0) : -

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

template <class T = std::string>
void foo(T src, std::function<void(T&& t)> completionFn)
{
    completionFn(std::move(src));
}

int main(int argc, char *argv[])
{
    foo<std::string>("hello", [] (auto && t) {
        std::cout << t << std::endl;
    });

    return 0;
}

If I modify the main function to remove the template parameter in the call to "foo", it no longer compiles even though I have a default template parameter, and I cannot work out why.

int main(int argc, char *argv[])
{
    foo<>("hello", [] (auto && t) {
        std::cout << t << std::endl;
    });

    return 0;
}

I am probably missing something obvious.

Here is the compiler output : -

src/scanner_test.cpp: In function ‘int main(int, char**)’:
src/scanner_test.cpp:19:6: error: no matching function for call to ‘foo(const char [6], main(int, char**)::<lambda(auto:11&&)>)’
   19 |     });
      |      ^
src/scanner_test.cpp:10:6: note: candidate: ‘template<class T> void foo(T, std::function<void(T&&)>)’
   10 | void foo(T src, std::function<void(T&& t)> completionFn)
      |      ^~~
src/scanner_test.cpp:10:6: note:   template argument deduction/substitution failed:
src/scanner_test.cpp:19:6: note:   ‘main(int, char**)::<lambda(auto:11&&)>’ is not derived from ‘std::function<void(T&&)>’
   19 |     });

What am I missing? Thanks! Apologies if it's a silly question.

ceorron · Accepted Answer · 2020-07-14 13:57:00Z

3

The default template parameter is only used if the template CANNOT be determined from context. In the context given foo<>("hello", ...) the template T is determined to be const char [6] (as given in the error message). For functions this will always be the case for template parameters that relate to real parameters in the function.

The solution you maybe looking for is:

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

template <class T>
void foo(T src, std::function<void(std::string&& t)> completionFn)
{
    //NOTE cast here to std::string, ensures we always have an std::string
    completionFn(std::move((std::string&)src));
}

int main(int argc, char *argv[])
{
    foo("hello", [] (std::string&& t) {
        std::cout << t << std::endl;
    });

    return 0;
}

edited Jul 14, 2020 at 13:57

answered Jul 14, 2020 at 13:51

ceorron

1,2662 gold badges17 silver badges29 bronze badges

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

Collectives™ on Stack Overflow

Why does using the default template parameter for a function also used in a lambda parameter not work

1 Answer 1

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Related