_>// 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
}