I>void f(int);
I>void f(char const*);

I>void g(int);
I>void g(char const*);

I>void h(generic_function const& gf)
I>{
I>    gf(1);
I>    gf("!");
I>}

I>int main()
I>{
I>    h(make_generic_function(f));
I>    h(make_generic_function(g));
I>}
I>

void f(int);
void f(char const*);

auto h = [](auto gf) { gf(1); gf("!"); };

int main()
{
    h([](auto x){f(x);});
}

// самодостаточный
struct fs
{
  static void fun(int) { ... }
  static void fun(const char*) { ... }
};

// фасад к внешним функциям
struct gs
{
  template<class T> static void fun(T t) { g(t); }
};

template<class F> void h(F _ = F()) // аргумент - чтобы сработал вывод типов, а не только явно инстанцировать
{
  F::fun(1);
  F::fun("xxx");
}

struct IFun
{
  virtual void fun(int) const = 0;
  virtual void fun(const char*) const = 0;
};

void h(IFun& f)
{
  f.fun(123); f.fun("xxx");
}

typedef void (*FUN)(boost::any const&);

void h(FUN f)
{
  f(123); f((const char*)"xxx");
}

void fs(boost::any const& x)
{
  if(x.type() == typeid(int)) { f(boost::any_cast<int>(x)); } else
  if(x.type() == typeid(const char*) { f(boost::any_cast<const char*>(x)); } else
  throw bad_argument(); // или что-то ещё
  // эту цепочку можно раскрутить с помощью списка типов boost::mpl, но я не хочу сейчас накручивать ещё и mpl
}

I>void f(int);
I>void f(char const*);

I>void g(int);
I>void g(char const*);

I>void h(generic_function const& gf)
I>{
I>    gf(1);
I>    gf("!");
I>}

I>int main()
I>{
I>    h(make_generic_function(f));
I>    h(make_generic_function(g));
I>}
I>

#include <mml/inline_overloaded_fn/make_inline_overloaded_fn.hpp>

template <typename F>
void h(F const& gf)
{
    gf(1);
    gf("!");
}

// это приходится делать из-за неоднозначности имен
void(*f_int)(int) = &f;
void(*f_char)(char const*) = &f;

h(mml::make_inline_overloaded_fn(f_int, f_char));

// если вместо одного перегруженного имени f задать функциям различные имена, например f1 и f2, то все упростится до:
// h(mml::make_inline_overloaded_fn(f1, f2));

f_int = &g;
f_char = &g;

h(mml::make_inline_overloaded_fn(f_int, f_char));

#include <boost/functional/overloaded_function.hpp>

template <typename F>
void h(F const& gf)
{
    gf(1);
    gf("!");
}

void(*f_int)(int) = &f;
void(*f_char)(char const*) = &f;

h(boost::make_overloaded_function(f_int, f_char));

f_int = &g;
f_char = &g;

h(boost::make_overloaded_function(f_int, f_char));

#include <iostream>
#include <string>

template<typename F1, typename F2>
struct GenericFunctor2 : F1, F2
{
  using F1::operator();
  using F2::operator();
};

struct F1
{
  int operator() ( int i )
  {
    std::cout << "F1(int):" << i << std::endl;
    return i;
  }
};

struct F2
{
  void operator() ( const std::string& i )
  {
    std::cout << "F2(string):" << i << std::endl;
  }
};

typedef GenericFunctor2<F1,F2> ComplexFun;

template<typename F>
void test( F f )
{
  f(12);
  f("test");
}

int main()
{
  ComplexFun f;
  test(f);
  return 0;
}

void f(int);
void f(char const*);

void g(int);
void g(char const*);

struct PFun
{      typedef void (&t1)(int);
    t1 t1r;
    operator  t1  () { return g;}
        t2 t2r; 
    typedef void (&t2)(char const*);
    operator  t2  () { return t2r;}
} pf={f,g};

....
....
   pf("hkjhkjh");

void f(int);
void f(char const*);

void g(int);
void g(char const*);

void h(generic_function const& gf)
{
    gf(1);
    gf("!");
}

int main()
{
    h(make_generic_function(f));
    h(make_generic_function(g));
}

void f();
void f(int);

std::function<void()> fn = static_cast<void(*)()>(&f);

void f(int = 0);
 
std::function<void()> fn = std::bind(&f, 0);

std::function<void()> fn = []f;

void f(int = 0);
M>std::function<void()> fn = std::bind(&f, 0);

 functions.set( тут-указан-конкретный-вариант-из-перегрузок-функции-f );

void f();
void f(int);
std::function<void()> fn = static_cast<void(*)()>(&f);

double sqrt(double);
float sqrt(float);

std::vector<double> dvec;
std::vector<float> fvec;

for_each(double_vec, sqrt); // облом

template<class V1, class V2, class F>
void for_each2(V1& vec1, V2& vec2, F f)
{
  for_each( vec1, f );
  for_each( vec2, f );
}

for_each2( dvec, fvec, sqrt ); // облом

tuple< double, float > dft;
auto dft2 = for_each( dft, sqrt ); // облом