#include <iostream>

void f(double) { std::cout << "f(double)"; }

template <typename T>
void g(T const& x)
{
    f(x);
}

int main()
{
    g(1);
    std::cout << '\n';
}

void f(int) { std::cout << "f(int)"; }

I>Компилировать можно. Comeau C++ Online.

#include <iostream>

typedef char (&first)[1];
typedef char (&second)[2];

first f(double);

template <typename T>
void g(T const& x)
{
    first test=f(x);
}

int main()
{
    g(1);
    std::cout << '\n';
}

second f(int);

struct first {};
struct second {};

I>#include <iostream>

I>void f(double) { std::cout << "f(double)"; }

I>template <typename T>
I>void g(T const& x)
I>{
I>    f(x);
I>}

I>int main()
I>{
I>    g(1);
I>    std::cout << '\n';
I>}

I>void f(int) { std::cout << "f(int)"; }
I>

I>Компилировать можно. Comeau C++ Online.

#include <iostream>

int f(double) { std::cout << "f(double)"; return 0;}

template <typename T>
void g(T const& x)
{
    f(x);
    int arr[sizeof(f(x))] = {0};
}

int main()
{
    g(1);
    std::cout << '\n';
}

void f(int) { std::cout << "f(int)"; }

struct B {};
struct D : B {};

struct first {};
struct second {};

first f(B const&);

template <typename T>
void g(T const& x)
{
    first test=f(x);
}

int main()
{
    g(D());
}

second f(D const&);

I>struct B {};
I>struct D : B {};

I>struct first {};
I>struct second {};

I>first f(B const&);

I>template <typename T>
I>void g(T const& x)
I>{
I>    first test=f(x);
I>}

I>int main()
I>{
I>    g(D());
I>}

I>second f(D const&);
I>

struct B {};
struct D : B {};

struct first {};
struct second {};

first f(B const&);
first f(double);


template <typename T>
void g(T const& x)
{
    first test=f(x);
}

int main()
{
   g(int());//ok (вызывается f(double))
   g(D());//error (вызывается f(const D&))
   return 0;
}

second f(int);
second f(D const&);

B>struct B {};
B>struct D : B {};

B>struct first {};
B>struct second {};

B>first f(B const&);
B>first f(double);


B>template <typename T>
B>void g(T const& x)
B>{
B>    first test=f(x);
B>}

B>int main()
B>{
B>   g(int());//ok (вызывается f(double))
B>   g(D());//error (вызывается f(const D&))
B>   return 0;
B>}

B>second f(int);
B>second f(D const&);

14.6.4 Dependent name resolution
1 In resolving dependent names, names from the following sources are considered:
— Declarations that are visible at the point of definition of the template.
— Declarations from namespaces associated with the types of the function arguments 
  both from the instantiation context (14.6.4.1) and from the definition context.

struct B {};
struct D : B {};

struct first {};
struct second {};

//first f(B const&);

template <typename T>
void g(T const& x)
{
    first test=f(x);
}

int main()
{
    g(D());
}

second f(D const&);

"ComeauTest.c", line 12: error: no suitable user-defined conversion from "second" to
"first" exists
first test=f(x);
^
detected during instantiation of "void g(const T &) [with T=D]" at
line 17

struct first {};
struct second {};

//first f(double);

template <typename T>
void g(T const& x)
{
    first test=f(x);
}

int main()
{
    g(int());
}

second f(int);

"ComeauTest.c", line 9: error: identifier "f" is undefined
first test=f(x);
^
detected during instantiation of "void g(const T &) [with T=int]" at
line 14

B>14.6.4 Dependent name resolution
B>1 In resolving dependent names, names from the following sources are considered:
B>— Declarations that are visible at the point of definition of the template.
B>— Declarations from namespaces associated with the types of the function arguments 
B>  both from the instantiation context (14.6.4.1) and from the definition context.

template<bool> struct bool2type {};

bool2type<true> foo(int);
bool2type<false> foo(unsigned);
bool2type<false> foo(double);

int main()
{
    bool2type<true> t = foo( "hello"[2] ); // надеюсь, что будет foo(int)
}

B>14.6.4 Dependent name resolution
B>1 In resolving dependent names, names from the following sources are considered:
B>— Declarations that are visible at the point of definition of the template.
B>— Declarations from namespaces associated with the types of the function arguments 
B>  both from the instantiation context (14.6.4.1) and from the definition context.

A translation unit usually contains multiple POIs for the same instance. For class template instances, only the first POI in each translation unit is retained, and the subsequent ones are ignored (they are not really considered POIs). For nonclass instances, all POIs are retained. In either case, the ODR requires that the instantiations occurring at any of the retained POIs be equivalent, but a C++ compiler does not need to verify and diagnose violations of this rule. This allows a C++ compiler to pick just one nonclass POI to perform the actual instantiation without worrying that another POI might result in a different instantiation.

In practice, most compilers delay the actual instantiation of noninline function templates to the end of the translation unit. This effectively moves the POIs of the corresponding template specializations to the end of the translation unit. The intention of the C++ language designers was for this to be a valid implementation technique, but the standard does not make this clear.

I>In practice, most compilers delay the actual instantiation of noninline function templates to the end of the translation unit. This effectively moves the POIs of the corresponding template specializations to the end of the translation unit. The intention of the C++ language designers was for this to be a valid implementation technique, but the standard does not make this clear.

As usual, use of global functions can make matters worse. The global namespace is considered the namespace associated with built-in types, so global functions can be used to resolve dependent calls that take built-in types. For example:

    int f(int);

    template<class T> T g(T t) { return f(t); }

    char c = g('a');    // error: alternative resolutions of f(t) are possible

    char f(char);

We could generate the specialization g<char>(char) at the point of instantiation and get f(int) called. Alternatively, we could wait and generate the specialization at the end of the translation unit and get f(char) called. Consequently, the call g('a') is an error.