用模板向前声明所有将来的函数会导致模棱两可，而不是将声明与定义配对

Question

I'm using a c++ idiom that allows defining a common behavior ( GeneralFunction ) that is customized by making it call specific functions ( SpecificFunction ) – switching between them by tag classes (unfortunately I forgot the name of the idiom).

I decided I wanted the SpecificFunctions to have an arbitrary return type. But since we're in c++ I need to declare the identifier in advance before mentioning it in GeneralFunction .

Here I hope I'm declaring a SpecificFunction template that will be upon its instantiation a declaration matching a concrete SpecificFunction overload which will be defined below:

#include <utility>
#include <iostream>

template <typename Tag, typename ... Args>
struct ReturnTypeTrick;

template <typename Tag, typename ... Args>
inline auto SpecificFunction(Tag, Args&& ... args) -> typename ReturnTypeTrick<Tag, Args...>::type;  // basically saying SpecificFunction returns what it returns

the return type is not known until instantiation, but it should not matter now. I just need to to declare the identifier, so that I can use it in GeneralFunction

template <typename Tag, typename ... Args>
struct ReturnTypeTrick {
    using type = decltype(SpecificFunction(Tag(), std::declval<Args>() ...));
};

The general function with common behavior:

template <typename Tag, typename ... Args>
inline auto GeneralFunction (Args&& ... specific_args) {
    // do something common for all implementations

    // this is where the behavior differs
    return SpecificFunction(Tag(), std::forward<Args>(specific_args) ...);
}

Default implementation for SpecificFunction I decided to provide:

template <typename Tag, typename ... Args>
inline bool SpecificFunction(Tag, Args&& ...) {  // default implementation
    return false;
}

defining specific behavior functions:

struct Algorithm1 {};

inline auto SpecificFunction(Algorithm1, int param1, char param2) {
    return 10;
}


struct Algorithm2 {};

inline auto SpecificFunction(Algorithm2, long param1) {
    return "y";
}

struct Algorithm3 {};



int main() {
    std::cout << GeneralFunction<Algorithm1>(1, 'a') << std::endl;
    std::cout << GeneralFunction<Algorithm2>(1l) << std::endl;  
    /* these somehow work, probably independently on the
   `SpecificFunction` declaration above because my compiler is OK with
   functions not being declared at all. BUT changing these simple
   SpecificFunction definitions into templates – that is line in
   GeneralFunction would look like 
   return SpecificFunction<SomeTemplateArg>(Tag(), std::forward<Args>(specific_args) ...); 
   – and removing the declaration results in undeclared indentifier
   `SpecificFunction`, so I need to be able to declare it */

    std::cout << GeneralFunction<Algorithm3>("wtf this should call the  // default implementation") << std::endl;
    // error: call to 'SpecificFunction' is ambiguous

    static_assert(std::is_same_v<typename ReturnTypeTrick<Algorithm3, const char*>::type, bool>, "the return type of the generated declaration is correct if you don't see this message");

    return 0;
}

Error message:

/scratch_2.cpp:22:12: error: call to 'SpecificFunction' is ambiguous
    return SpecificFunction(Tag(), std::forward<Args>(specific_args) ...);
           ^~~~~~~~~~~~~~~~
/scratch_2.cpp:51:18: note: in instantiation of function template
      specialization 'GeneralFunction<Algorithm3, char const (&)[52]>' requested here
    std::cout << GeneralFunction<Algorithm3>("wtf this should call the  // default implementation") << std::endl;
                 ^
/scratch_2.cpp:8:13: note: candidate function [with Tag = Algorithm3, Args
      = <char const (&)[52]>]
inline auto SpecificFunction(Tag, Args&& ... args) -> typename ReturnTypeTrick<Tag, Args...>::type;  // basically saying Spe...
            ^
/scratch_2.cpp:26:7: note: candidate function [with Tag = Algorithm3, Args
      = <char const (&)[52]>]
inline bool SpecificFunction(Tag, Args&& ...) {  // default implementation

It seems it cannot match the generated declaration to the definition of the default SpecificFunction implementation.

You can see the generated declaration is the same (they call it error: ambiguous) as the definition header. That's funny, because that's exactly the thing – that identity – based on which I thought the declaration and definition was paired.

Also I tried changing the header of // default implementation SpecificFunction to

template <typename Tag>
inline bool SpecificFunction(Tag, ...) {  // default implementation
    return false;
}

but then I get a linker error instead:

Undefined symbols for architecture x86_64:
  "ReturnTypeTrick<Algorithm3, char const (&) [52]>::type SpecificFunction<Algorithm3, char const (&) [52]>(Algorithm3, char const (&&&) [52])", referenced from:
      auto GeneralFunction<Algorithm3, char const (&) [52]>(char const (&&&) [52]) in scratch_2-b3bb4f.o
ld: symbol(s) not found for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)

Answer 1

First note that the return type is a part of the function signature of a function template specialization.

Thus, the compiler sees two overloads that match Tag = Alogirthm3 , which (may) differ in their return types:

// (A)
template <typename Tag, typename ... Args>
inline auto SpecificFunction(Tag, Args&& ... args)
    -> typename ReturnTypeTrick<Tag, Args...>::type;

and

// (B)
template <typename Tag, typename ... Args>
inline bool SpecificFunction(Tag, Args&& ...);

To figure out that they are in fact the same, it has to figure out what is typename ReturnTypeTrick<Tag, Args...>::type , which is defined as decltype(SpecificFunction(Tag(), std::declval<Args>() ...) , once again leading to the resolution of the SpecificFunction overload for Tag = Algorithm3 (which was the problem that we started with). So, what the code is telling the compiler is:

(A) and (B) are the same if and only if (A) and (B) are the same.

which is obviously ambiguous. Thus, your return type trick is actually incorrect.

The question is: why do you even need (A) and ReturnTypeTrick in the first place? Because of the way template instantiation works (in short, specializations are instantiated lazily, just before the place where they are first needed), you should not need the forward declaration at all. Just remove ReturnTypeTrick and (A) altogether and your code will compile.

See live example . Also, the discussion in this question might be an interesting read. The setting is not exactly the same as yours, but it does discuss the issue of templates behaving differently than normal functions / classes (complete with references to the C++ standard, as opposed to hand waving used in this answer).

BTW: In case you were wondering why the specializations for Algorithm1 and Algorithm2 do not have the same problem, it is because a non-template parameter is a better match in overload resolution than a template parameter, so (A) is immediately discarded as a candidate, before even going through the return type resolution.