I am trying to implement the template using globally overloaded function to perform custom actions per signature. Since there could be group of types (eg. numeric types) having a similar implementation I tried to use concepts to cover it, but stumbled into the problem where the compiler doesn't see the definition with concept without explicit instantiation.

MSVC 17.13.0 (/std:c++latest)

// my.hpp
template <typename value_type>
void bar(value_type value);

template <typename value_type>
void foo(value_type value)
{
    bar<value_type>(value);
}

// my.cpp
#include "my.hpp"
#include <print>
#include <type_traits>

template<std::integral value_type>
void bar(value_type value)
{
    std::println("bar(integral[{}])", value);
}

int main()
{
    //bar(5);
    foo(6);
}

The program above does not build because the linker doesn't see bar's definition:

unresolved external symbol "void __cdecl bar(int)" (??$bar@H@@YAXH@Z) referenced in function "void __cdecl foo(int)" (??$foo@H@@YAXH@Z)

Though, if I uncomment the line bar(5); in main(), it will obviously instantiate the concept-constrained template, and the result will be proper (but with extra output from direct call bar(5)):

bar(integral[5])

bar(integral[6])

Is there common pattern for solving such a task? Basically, I want that the template receiving the type was able to find the suitable definition of template function itself, void bar<int> in my case.

I am trying to implement the template using globally overloaded function to perform custom actions per signature. Since there could be group of types (eg. numeric types) having a similar implementation I tried to use concepts to cover it, but stumbled into the problem where the compiler doesn't see the definition with concept without explicit instantiation.

MSVC 17.13.0 (/std:c++latest)

// my.hpp
template <typename value_type>
void bar(value_type value);

template <typename value_type>
void foo(value_type value)
{
    bar<value_type>(value);
}

// my.cpp
#include "my.hpp"
#include <print>
#include <type_traits>

template<std::integral value_type>
void bar(value_type value)
{
    std::println("bar(integral[{}])", value);
}

int main()
{
    //bar(5);
    foo(6);
}

The program above does not build because the linker doesn't see bar's definition:

unresolved external symbol "void __cdecl bar(int)" (??$bar@H@@YAXH@Z) referenced in function "void __cdecl foo(int)" (??$foo@H@@YAXH@Z)

Though, if I uncomment the line bar(5); in main(), it will obviously instantiate the concept-constrained template, and the result will be proper (but with extra output from direct call bar(5)):

bar(integral[5])

bar(integral[6])

Is there common pattern for solving such a task? Basically, I want that the template receiving the type was able to find the suitable definition of template function itself, void bar<int> in my case.

• c++
• visual-c++
• c++-concepts
• c++23

• Forward declaration of bar and definition of bar aren't same, coz definition has concept std::integral and forward declaration doesn't. Try adding concept in forward declaration. – kiner_shah Commented Apr 2 at 9:10
• the program does not compile but I dont follow your conclusion godbolt./z/rqz3Mx7Kj. Please include the compiler error message in the question. Not doing that will cause confusion, because others will see different diagnostics than you do – 463035818_is_not_an_ai Commented Apr 2 at 9:12
• 1 Just reorder your code to this : godbolt./z/E6j1T9TTo – Pepijn Kramer Commented Apr 2 at 9:46
• 1 If you want to handle multiple implementations, then maybe use if constexpr to check types and process accordingly. Like godbolt./z/s3W6EEr66 – kiner_shah Commented 2 days ago
• 1 @kiner_shah Good point. Still slightly not what I wanted. But it may work locally – Symon Commented 2 days ago

1 Answer 1

First,

template <typename      value_type> void bar(value_type value); // #1
template <std::integral value_type> void bar(value_type value); // #2

are two different overloads.

Second, so in

template <typename value_type> void bar(value_type value); // #1

template <typename value_type>
void foo(value_type value)
{
    bar<value_type>(value);
}

Unless ADL kicks in, bar<value_type>(value); refers to #1 (the only one visible). As you use value_type=int, ADL (Argument-Dependent Lookup) is not involved.

If you add dummy parameter to enable ADL, then you might have:

struct adl_enabler{};

template <typename value_type>
void foo(value_type value)
{
    bar<value_type>(value, adl_enabler{});
}

template <std::integral value_type>
void bar(value_type value, adl_enabler) // in same namespace than `adl_enabler`
                                        // (global namespace here)
{
    std::println("bar(integral[{}])", value);
}

Demo