// header.h
template<class T> void f(T);

//template<> void f(int);

inline void fi(int x) { f(x); }

#include "header.h"

template<> void f(int x) {}

_>// header.h
_>template<class T> void f(T);

_>//template<> void f(int);

_>inline void fi(int x) { f(x); }
_>

_>#include "header.h"

_>template<> void f(int x) {}
_>

If a template, a member template or a member of a class template is explicitly specialized then that specialization shall be declared before the first use of that specialization that would cause an implicit instantiation to take place, in every translation unit in which such a use occurs; no diagnostic is required. If the program does not provide a definition for an explicit specialization and either the specialization is used in a way that would cause an implicit instantiation to take place or the member is a virtual member function, the program is ill-formed, no diagnostic required. An implicit instantiation is never generated for an explicit specialization that is declared but not defined.

// header.h
template<class T> void f(T);

//template<> void f(int);

inline void fi(int x) { f(x); }

#include "header.h"

// template<> void f(int x) {}

_>// header.h
_>template<class T> void f(T);

_>//template<> void f(int);

_>inline void fi(int x) { f(x); }
_>

_>#include "header.h"

_>// template<> void f(int x) {}
_>

template<class T> void f(T); // повторное объявление вместо подключения заголовка

template<> void f(int x) {}

// another_translation_unit.cpp
template<class T> void f(T);
template<> void f(int x) {}

template<class T>void f(T);

template<> void f(int); inline void fi(int x) { f(x); }

template<> void f(int x) {}

void ok() { void fn(); fn(); }
void fail(int x) { template<> void f(int); f(x); } // с чем связан запрет подобных объявлений?

struct Helper {
  Tape &tape; bool store;
  template<class T> void process(T &t);
  template<class T> Helper& operator<< (T &t) { process(t); return *this; }
  Helper(Tape &tape,bool store,int id) : tape(tape), store(store) { process(id); }
};

template<class T>
void f(T t)
{
  // Do smth with t
}

void fi(int x)
{
  f(x);
}

template<class T> void f0(T&);
template<class T> void f1(T&) {}

inline void f0i(int x) { f0(x); }
inline void f1i(int x) { f1(x); }
//...
// template<> void f1(int&) {} // ошибка, уже есть реализация, полученная при инстанцировании
// template<> void f0(int&) {} // ошибка, просто за компанию. реализаци не ну и пофиг всё равно нельзя.

template<class T> void f0(T&);
template<class T> void f1(T&) {}

template<> void f0(int &); inline void f0i(int x) { f0(x); }
inline void f1i(int x) { f1(x); }
//...
// template<> void f1(int&) {} // ошибка, уже есть реализация, полученная при инстанцировании
template<> void f0(int&) {} // теперь можно

template<class T>void f(T t);
template<class T>void g(T t);

inline void fi(int x) { f(x); }

template<class T>void f(T t) { g(t);}
template<> void g(int x) {}

_>template<class T>void f(T t);
_>template<class T>void g(T t);

_>inline void fi(int x) { f(x); }

_>template<class T>void f(T t) { g(t);}
_>template<> void g(int x) {}
_>

// header.h

template<class T> void f(T t);

inline void fi(int x) { f(x); }

// main.cpp
#include header.h

int main()
{
   fi(42);
}

// separate.cpp

// Primary template definition
template<typename T>
void f(T t)
{
   // . . .
}

// Explicit template instantiations
template void f<char>(char);
template void f<short>(short);
template void f<double>(double);

// Explicit specialization for f<int>
template<>
void f<int>(int i)
{
   // . . .
}

template<class T>void f(T); // заявляем что есть скоро будетет такой дефолтный метод

inline void fi(int x) { f(x); } // используем дефолтную реализацию f<int> пофиг что её пока нет, вруг ниже есть

template<class T>void f(T) {} // и тут фигакс вот он. теперь ок. но если мы его не объявим ... то ub (ну вы вкурсе програмист сам дурак по стандарту во всех спорных ситуациях)

_>// header.h
_>template<class T> void f(T);

_>//template<> void f(int);

_>inline void fi(int x) { f(x); }
_>

_>#include "header.h"

_>template<> void f(int x) {}
_>

// header.h
template<class T> void f(T);

//template<> void f(int);

inline void fi(int x) { f(x); }

/// @file impl_int.cpp
#include "header.h"

template<> void f(int x) {}

/// @file impl_float.cpp
#include "header.h"

template<> void f(float x) {}

void test()
{
  fi(1);
}

void f(int&);
void f(double&);
void f(short&);

template<class T>void f(T&);

_>void f(int&);
_>void f(double&);
_>void f(short&);
_>

/// @file header.h
template<class T, class FnF>
inline void fi(T& x, FnF&& f) { f(x); }

/// @file main.cpp
#include <iostream>

void f_int(int&)
{
  std::cout << "int\n";
}

int main()
{
  int i = 0;
  fi(i, f_int);

  float x = 1.f;
  fi(x, [](float& rX) { std::cout << "float " << rX << '\n';} );

  std::cout << "the end\n";
  return 0;
}

#include <iostream>
#include <string>

template <typename T>
void fi(T&& t)
{
    f(t); // вообще никакого предварительного объявления не требуется
}

namespace test
{
// А типы вместе с их функциями могут располагаться в разных пространствах имен
struct A
{
    std::string name;
};

void f(const A& a)
{
   std::cout << "A: " << a.name << std::endl;
}

} // namespace test

int main()
{
    fi(test::A{"RSDN"});
}

// header
struct A {
    template<class T>void f(T& t) { void ext_f(A*,T&); ext_f(this,t); }
};

// impl
#include <stdio.h>
#include <string>
using std::string;
void ext_f(A* self,char &v) { printf("char=%d\n",v); }
void ext_f(A* self,signed char &v) { printf("signed char=%d\n",v); }
void ext_f(A* self,unsigned char &v) { printf("unsigned char=%d\n",v); }
void ext_f(A* self,int &v)  { printf("int=%d\n",v); }
void ext_f(A* self,string &v)  { printf("string=%s\n",v.c_str()); }

int main(int argc, char const *argv[]) {
    A a[1]; char c=1; signed char cs=2; unsigned char cu=3; 
    int i=4; string s="string";
    a->f(c);
    a->f(cs);
    a->f(cu);
    a->f(i);
    a->f(s);
    return 0;
}

char=1
signed char=2
unsigned char=3
int=4
string=string

struct A {
  template<class... T> A& f(T&...t) { void ext_f(A*,T&...); ext_f(this,t...); return *this; }
};

_>C++ extension functions

_>struct A {
_>  template<class... T> A& f(T&...t) { void ext_f(A*,T&...); ext_f(this,t...); return *this; }
_>};
_>

#include <iostream>

struct A {

    template<class... T>
    A& f(T&&...t) { 
        ext_f(*this, t...);
        return *this;
    }
};

void ext_f(A&, int i)
{
    std::cout << "ext_f(A&, " << i << ")" << std::endl;
}

template <typename...T>
void ext_f(A&, T&&...t)
{
    ((std::cout << t << " "), ...);
}

int main()
{
    A a;
    a.f(42); // -> ext_f(A&, 42);
    a.f("Hello", 3.14, 'A'); // -> Hello 3.14 A
}