static void funcA(void *p) {}

template<class T>
void funcT(T &t)
{
  funcA(&t);
}

void test()
{
  int t;
  funcT(t);
}

static void funcA(int p) {}

template<class T>
void funcT(T t)
{
  funcA(t);
}

void test()
{
  int t = 0;
  funcT(t);
}

error: no instance of function "funcA" matches the argument

<quote>
[temp.dep.candidate] 14.6.4.2 Candidate functions
1 For a function call that depends on a template parameter, if the function
name is an unqualified-id but not a template-id, the candidate functions
are found using the usual lookup rules (3.4.1, 3.4.2) except that:
— For the part of the lookup using unqualified name lookup (3.4.1), only
function declarations with external linkage from the template definition
context are found.
— For the part of the lookup using associated namespaces (3.4.2), only
function declarations with external linkage found in either the template
definition context or the template instantiation context are found.
</quote>

"Static functions" have internal, not external linkage, and the function
call depends on template parameter A, so it is an error.

HTH,
--
Michiel Salters

НЕ>static void funcA(void *p) {}

НЕ>template<class T>
НЕ>void funcT(T &t)
НЕ>{
НЕ>  funcA(&t);
НЕ>}

НЕ>void test()
НЕ>{
НЕ>  int t;
НЕ>  funcT(t);
НЕ>}
НЕ>

14.6.4.2/1 For a function call that depends on a template parameter, if the function name is an unqualified-id but not a
template-id, the candidate functions are found using the usual lookup rules (3.4.1, 3.4.2) except that:

— For the part of the lookup using unqualified name lookup (3.4.1), only function declarations with external
linkage from the template definition context are found.

void funcA(void *p) {}

namespace
{
   void funcA(void *p) {}
}

template<class T>
void funcT(T &t)
{
  funcA(static_cast<void*>(&t));
}

static void funcA(void *p) {}

template<class T>
void funcT(T& t)
{
  ::funcA(&t);
}

void test()
{
  int t;
  funcT(t);
}

A trailing template-argument can be left unspecified in an explicit instantiation of a function template specialization or of a member function template specialization provided it can be deduced from the type of a function parameter (14.8.2).

template<class T>
static void funcT(T &t)
{
}

a.cpp:
template<class T>
void func()
{
 a = 10;
}

void f1()
{
  func<int>();
}

b.cpp

template<class T>
void func()
{
 b = 20;
}

void f2()
{
  func<int>();
}

namespace
{
   void funcA(void *p) {}

   template<class T>
   void funcT(T &t)
   {
     funcA(&t);
   }
}

void test()
{
  int t;
  funcT(t);
}

B>template<class T>
B>void funcT(T &t)
B>{
B>  funcA(static_cast<void*>(&t));
B>}
B>

static void funcA(int *p) {}

template<class T>
void funcT(T &t)
{
  funcA((int *)&t); // тоже нужно
}

void test()
{
  int t;
  funcT(t);
}