#include <functional>
#include <iostream>

template <typename T>
void f(std::function<void(T)> g)
{
    std::cout << "1 arg:";
    g(1);
}

template <typename T1, typename T2>
void f(std::function<void(T1 t1,T2 t2)> g)
{
    std::cout << "2 args:";
    g(1,2);
}

int main(int argc, char* argv[])
{
    auto func1 = [](int x) { std::cout << x << std::endl; };
    auto func2 = [](int x, int y) { std::cout << x << y << std::endl; };

    f(func1);
    f(func2);

    return 0;
}

int main(int argc, char* argv[]) { 
    std::function<void(int)> func1 = [](int x) { std::cout << x << std::endl; }; 
    std::function<void(int,int)> func2 = [](int x, int y) { std::cout << x << y << std::endl; }; 
    f(func1); 
    f(func2); 
    return 0; 
}

//template <typename ClassType, typename ReturnType, typename... Args>
//struct function_traits<ReturnType(ClassType::*)(Args...) const>

template <typename ClassType, typename ReturnType, typename Arg1>
struct function_traits<ReturnType(ClassType::*)(Arg1) const> { static const unsigned arity = 1;... }

template <typename ClassType, typename ReturnType, typename Arg1, typename Arg2>
struct function_traits<ReturnType(ClassType::*)(Arg1, Arg2) const> { static const unsigned arity = 2; ... }

...

function<int(int,int)> sum = [](int a, int b) { return a + b; };

auto sum = [](int a, int b) { return a + b; };

template<typename G>
void f(G g)
{
    ....
    g();
}

void g1(int);
void g2(int, int);

f(std::bind(&g1, 1));
f(std::bind(&g2, 1, 2));

void f(std::function<void(int)> g)
    f(func1);

template <typename T>
std::function<T> cvt(T &x) {return x;}

    auto func1 = cvt([](int x) { std::cout << x << std::endl; });

PM>Я бы отказался от поддержки старых компиляторов и требовал С++11

class value 
{
public:
  value( int i );
  value( double f );
  value( string s );
  value( std::function<value(unsigned int argc, const value* argv)> func ); // value-function 

  template<typename T> T get() const;
};

   // 
   template<typename R,typename P0>
      inline value vfunc( std::function<R(P0)> func )
      {
        return value([func](unsigned int argc, const value* argv) -> value { 
          R r = func(argc >= 1? argv[0].get<P0>(): P0() ); 
          return value(r); }); 
      }
    template<typename R,typename P0,typename P1>
      inline value vfunc( std::function<R(P0,P1)> func )
      {
        return value([func](unsigned int argc, const value* argv) -> value { 
          R r = func(argc >= 1? argv[0].get<P0>(): P0(),
                     argc >= 2? argv[1].get<P1>(): P1() ); 
          return value(r); }); 
      }

    ...

value local_func = vfunc( []{ int a, int b } { return a + b; } );

std::function<int(int,int)> t = []{ int a, int b } { return a + b; };
value local_func = vfunc( t );

CS>template <typename T>
CS>void f(std::function<void(T)> g)

CS>template <typename T1, typename T2>
CS>void f(std::function<void(T1 t1,T2 t2)> g)

CS>int main(int argc, char* argv[])
CS>{
CS>    auto func1 = [](int x) { std::cout << x << std::endl; };
CS>    auto func2 = [](int x, int y) { std::cout << x << y << std::endl; };

CS>    f(func1);
CS>    f(func2);

CS>    return 0;
CS>}
CS>

template <G> void f1(G g) {...}
template <G> void f2(G g) {...}

auto func1 = [](int x) { std::cout << x << std::endl; };
auto func2 = [](int x, int y) { std::cout << x << y << std::endl; };
f1(func1);
f2(func2);