typedef void (*pfun)(int a, int b = 7); // error!

void f1(int a, int b);

void main(){
    pfun f = f1;
    f(1);
}

void f(int a=1){}

#include <type_traits>

void f(int a=1){}
typedef void tf(int);

static_assert(std::is_same<decltype(f),tf>::value,"");

int main() {}

void foo(int);
// и
void foo(int = 7);

#include <iostream>

int z = 0;

int foo(int x)
{
    return 2 * x;
}

int bar(int x, int y = foo(z))
{
    return x + y;
}

int main()
{
    z = 2;
    std::cout << bar(1) << std::endl;
    return 0;
}

template <typename F1, typename F2>
void zzz(F1, F2)
{
    std::cout << std::is_same<F1, F2>::value << std::endl;
}

void foo(int = 7);
void goo(int = 7);
void bar();
void zoo(int = 123, int = 234);

zzz(&foo, &bar); // ?
zzz(&zoo, &bar); // ?
zzz(&zoo, &foo); // ?
zzz(&zoo, &goo); // ?
...

void (*pf)(int a=0);

typedef void (*tf)(int a=0);

void (*pf)() throw(int); // OK
typedef void (*tf)() throw(int); // Error: declared with an exception specification

W>typedef void (*pfun)(int a, int b = 7); // error!

W>void f1(int a, int b);

W>void main(){
W>    pfun f = f1;
W>    f(1);
W>}
W>

struct pfun
{
  typedef void result_type; // для std::bind
  typedef result_type (*ptr_type)(int,int);
  ptr_type p;
  pfun(ptr_type p) : p(p) { assert(p); }
  result_type operator() (int a, int b=7) const { return (*p)(a,b); }
};

void f1(int,int);
void f2(int,int);

int main()
{
  void (*ff)(int,int) = (rand()%2 ? f1 : f2); // если мы захотим вызывать с 2 аргументами
  std::function<void(int)> f = std::bind(ff, _1, 7); // если захотим вызывать с 1 аргументом
  // если ff не нужен сам по себе - просто подставим его внутрь bind

  f(1);
  ff(1,2);
}

К>  void (*ff)(int,int) = (rand()%2 ? f1 : f2); // если мы захотим вызывать с 2 аргументами
К>  std::function<void(int)> f = std::bind(ff, _1, 7); // если захотим вызывать с 1 аргументом
К>  // если ff не нужен сам по себе - просто подставим его внутрь bind
К>

void f(int a,int b)
{
   cout << a << " " << b << endl;
}
int main()
{
   auto defaults = overload( []{f(1,2);}, bind(&f,_1,2) );
   defaults();
   defaults(3);
}

void f(int a,int b,int c)
{
   cout << a << " " << b << " " << c << endl;
}
int main()
{
    auto &&d=defaults(f,11,22,33);
    d();
    d(1);
    d(2,3);
    d(3,4,5);
}
{
    function<void(int,int,int)> general_case{f};
    auto &&d=defaults_n<3>(general_case,11,22,33);
    d();
    d(1);
    d(2,3);
    d(3,4,5);
}

11 22 33
1 22 33
2 3 33
3 4 5
11 22 33
1 22 33
2 3 33
3 4 5

#include <type_traits>
#include <functional>
#include <iostream>
#include <ostream>
#include <utility>

using namespace std;

template<bool condition,typename T>
using static_if = typename enable_if<condition,T>::type;

template<typename F> struct func_args;

template<typename Result,typename ...Params>
struct func_args<Result(&)(Params...)>
{
    enum{value=sizeof...(Params)};
};

template<unsigned TotalArgs,typename Func,typename Head,typename ...Tail>
class defaults_set: defaults_set<TotalArgs,Func,Tail...>
{
    typedef defaults_set<TotalArgs,Func,Tail...> parent;
    Head data;
public:
    template<typename F,typename Arg,typename ...Args>
    defaults_set(F &&f,Arg &&arg,Args&&... args)
        : parent{forward<F>(f),forward<Args>(args)...}, data{forward<Arg>(arg)}
    {}
    template<typename ...Args>
    auto operator()(Args&&... args) ->
        static_if
        <
            sizeof...(Tail)+1+sizeof...(Args) == TotalArgs,
            typename result_of<Func(Args&&...,Head,Tail...)>::type
        >
    {
        return parent::operator()(forward<Args>(args)...,data);
    }
    using parent::operator();
};

template<unsigned TotalArgs,typename Func,typename Head>
class defaults_set<TotalArgs,Func,Head>
{
    typename conditional
    <
        is_function< typename remove_reference<Func>::type >::value,
        Func,
        typename remove_reference<Func>::type
    >::type  func;
    Head data;
public:
    template<typename F,typename Arg,typename ...Args>
    defaults_set(F &&f,Arg &&arg)
        : func{forward<F>(f)}, data{forward<Arg>(arg)}
    {}
    template<typename ...Args>
    auto operator()(Args&&... args) ->
        static_if
        <
            1+sizeof...(Args) == TotalArgs,
            decltype(func(forward<Args>(args)...,data))
        >
    {
        return func(forward<Args>(args)...,data);
    }
    template<typename ...Args>
    auto operator()(Args&&... args) ->
        static_if
        <
            sizeof...(Args) == TotalArgs,
            decltype(func(forward<Args>(args)...))
        >
    {
        return func(forward<Args>(args)...);
    }
};

template<typename Func,typename ...Args>
defaults_set<func_args<Func>::value,Func,Args...>  defaults(Func &&f,Args&&... args)
{
    return {forward<Func>(f),forward<Args>(args)...};
}

template<unsigned TotalArgs,typename Func,typename ...Args>
defaults_set<TotalArgs,Func,Args...> defaults_n(Func &&f,Args&&... args)
{
    return {forward<Func>(f),forward<Args>(args)...};
}

// _________________________________________________ //

void f(int a,int b,int c)
{
   cout << a << " " << b << " " << c << endl;
}

int main()
{
    {
        auto &&d=defaults(f,11,22,33);
        d();
        d(1);
        d(2,3);
        d(3,4,5);
    }
    {
        function<void(int,int,int)> general_case{f};
        auto &&d=defaults_n<3>(general_case,11,22,33);
        d();
        d(1);
        d(2,3);
        d(3,4,5);
    }
}

W>typedef void (*pfun)(int a, int b = 7); // error!

W>void f1(int a, int b);

W>void main(){
W>    pfun f = f1;
W>    f(1);
W>}
W>

typedef void (*pfun1)(int a, int b = 1);
typedef void (*pfun2)(int a, int b = 2);

void f3(int a, int b = 3);

pfun1 p1 = f3; //???
pfun2 p2 = p1; //???

void f(int x, int y = 5)
{
}

void a()
{
    void f(int x, int y = 2);
    f(1);
}

void b()
{
    void f(int x, int y = 7);
    f(1);
}

EP>void f(int a,int b,int c)
EP>{
EP>   cout << a << " " << b << " " << c << endl;
EP>}
EP>int main()
EP>{
EP>    auto &&d=defaults(f,11,22,33);
EP>    d();
EP>    d(1);
EP>    d(2,3);
EP>    d(3,4,5);
EP>}
EP>{
EP>    function<void(int,int,int)> general_case{f};
EP>    auto &&d=defaults_n<3>(general_case,11,22,33);
EP>    d();
EP>    d(1);
EP>    d(2,3);
EP>    d(3,4,5);
EP>}
EP>

auto&& d = defaults(f, mandatory, mandatory, ondemand( []()->int { foo()+bar() } )); // первые два обязательные, третий вычисляется каждый раз

К>auto&& d = defaults(f, mandatory, mandatory, ondemand( []()->int { foo()+bar() } )); // первые два обязательные, третий вычисляется каждый раз
К>

struct Data
{
    int v[16];
};
 
Data &f(Data &&d=Data())
{
    return d;
}
 
void use(Data &d)
{
    d.v[0]=1;//...
}
 
int main()
{
    use(f());
}

К>>auto&& d = defaults(f, mandatory, mandatory, ondemand( []()->int { foo()+bar() } )); // первые два обязательные, третий вычисляется каждый раз
К>>

struct the_defaults
{
  function<Data&(int,Data&&)> fun;
  function<int()> make_arg1;
  function<Data()> make_arg2;

  Data& operator() ( int i, Data&& d ) { fun(i,d); }
  Data& operator() ( int i, storage<Data> s = uninitialized ) { s.init(make_arg2()); return fun(i, s.get<0>()); }
  Data& operator() ( storage<int,Data> s = uninitialized ) { s.init(make_arg1(), make_arg2()); return fun(s.get<0>(), s.get<1>()); }
};
// где storage - это кортеж, чьи элементы конструируются не сразу, а во второй фазе;
// в роли storage<...> может пойти optional<tuple<...>>

int main()
{
  the_defaults d = { foo, []()->int{return rand();}, []()->Data{return Data(1,2,3);} };
  use(d());
}

d(1,2);
d(1,2,3);

1 111 2
1 2 3