HWND FindApplicationWindow()
{
    HWND foundHWnd = 0;
    DWORD procID = GetCurrentProcessId();
    EnumWindows([&foundHWnd,&procID](HWND hWnd, LPARAM lParam) -> BOOL
    {
        /*
         ********************************************
         */
        return TRUE;
    },
    0);
}

error C2664: 'EnumWindows' : cannot convert parameter 1 from '`anonymous-namespace'::<lambda0>' to 'WNDENUMPROC'

С>HWND FindApplicationWindow()
С>{
С>    HWND foundHWnd = 0;
С>    DWORD procID = GetCurrentProcessId();
С>    EnumWindows([&foundHWnd,&procID](HWND hWnd, LPARAM lParam) -> BOOL
С>    {
С>        /*
С>         ********************************************
С>         */
С>        return TRUE;
С>    },
С>    0);
С>}
С>

typedef int (*func)(int);

int foo(func f)
{
    return f(10);
}

int main()
{
    return foo([](int a) { return 2 * a; });
}

The closure type for a lambda-expression with no lambda-capture has a public non-virtual non-explicit const
conversion function to pointer to function having the same parameter and return types as the closure type’s
function call operator. The value returned by this conversion function shall be the address of a function
that, when invoked, has the same effect as invoking the closure type’s function call operator.

auto p = [](int a) -> int __stdcall { return a; }

std::function<int(int)> px(p);

#include <windows.h>
#include <stdio.h>

typedef unsigned __int32 uint32;
typedef unsigned __int16 uint16;
typedef unsigned __int8   uint8;

#include <PshPack1.h>
struct thunk
{
  uint16 a; uint8 b; uint32 c; void* param;
  uint8 d; void* pfn; uint16 e;
  //---------------------
  uint16 aa; uint8 bb; uint32 cc; void* paramm;
  uint8 dd; void* pfnn; uint16 ee;
};
#include <PopPack.h>

template<class ArgType1>
struct objCallback1
{
    void *f;
    ArgType1 a1;
    thunk &t;
    objCallback1(void *f, ArgType1 a1):f(f),t(*new thunk)
    {
        typedef char buf[sizeof(ArgType1) <= sizeof(void*) ? 1 : 0];
        objCallback1::a1 = a1;
    }
    template<class Ret_t>
    operator Ret_t *()
    {
        return join<Ret_t>();
    }
    template<class Ret_t>
    Ret_t * join()
    {
        t.a = 0x34FF; t.b = 0x24;  t.c = 0x042444C7;  t.param = (void*)a1;
        t.d = 0xB8; t.pfn = f; t.e = 0xE0FF;
        //------------------------
        t.aa = 0x34FF; t.bb = 0x24;  t.cc = 0x042444C7;  t.paramm = (void*)&t;
        t.dd = 0xB8; t.pfnn = free_join; t.ee = 0xE0FF;
        atexit((void(*)())((char*)&t + 18));
        return (Ret_t *)&t;
    }
    /*
     testlinkage.exe!objCallback1<unsigned int>::free_join(void * mem=0x00356d00)  Line 48    C++
     msvcr90d.dll!doexit(int code=0x00000000, int quick=0x00000000, int retcaller=0x00000000)  Line 591    C
     msvcr90d.dll!exit(int code=0x00000000)  Line 412 + 0xd bytes    C
     testlinkage.exe!__tmainCRTStartup()  Line 595    C
     testlinkage.exe!mainCRTStartup()  Line 399    C
     kernel32.dll!_BaseProcessStart@4()  + 0x23 bytes    
    */
    static void __stdcall free_join(void *mem)
    {
        delete mem;
    }
};

template<class ArgType1>
objCallback1<ArgType1> Join(void *f, ArgType1 a1)
{
    return objCallback1<ArgType1>(f, a1);
}

VOID CALLBACK 
MyTimerProc(void* userdata, HWND hwnd, UINT uMsg,  UINT idEvent,  DWORD dwTime)
{
    printf("User data @ 0x%p\n", userdata );
}

int main()
{
    SetTimer(0, 0, 1000, Join(MyTimerProc, 0xdeadc0de));

    MSG msg;
    int ecx = 0;
    while(ecx++ < 3 && GetMessage(&msg, NULL, 0, 0))
        DispatchMessage(&msg);
}

A>typedef int (*func)(int);

A>int foo(func f)
A>{
A>    return f(10);
A>}

A>int main()
A>{
A>    return foo([](int a) { return 2 * a; });
A>}
A>

    EnumWindows([](HWND hwnd,LPARAM lParam) -> BOOL __stdcall 
    {

С>HWND FindApplicationWindow()
С>{
С>    HWND foundHWnd = 0;
С>    DWORD procID = GetCurrentProcessId();
С>    EnumWindows([&foundHWnd,&procID](HWND hWnd, LPARAM lParam) -> BOOL
С>    {
С>        /*
С>         ********************************************
С>         */
С>        return TRUE;
С>    },
С>    0);
С>}
С>

BOOL CALLBACK enumwindows_thunk(HWND hwnd, LPARAM arg)
{
  return (*(const function<BOOL(HWND)>*)arg)(hwnd);
}

LPARAM enumwindows_arg(const function<BOOL(HWND)>& fun)
{
  return (LPARAM)&fun;
}

.......
EnumWindows(
  enumwindows_thunk,
  enumwindows_arg(
    [&foundHWnd,&procId](HWND hwnd) -> BOOL
    {
      .....
    }
  )
);
.....

J>    template<class Ret_t>
J>    Ret_t * join()
J>    {
J>        t.a = 0x34FF; t.b = 0x24;  t.c = 0x042444C7;  t.param = (void*)a1;
J>        t.d = 0xB8; t.pfn = f; t.e = 0xE0FF;
J>        //------------------------
J>        t.aa = 0x34FF; t.bb = 0x24;  t.cc = 0x042444C7;  t.paramm = (void*)&t;
J>        t.dd = 0xB8; t.pfnn = free_join; t.ee = 0xE0FF;
J>        atexit((void(*)())((char*)&t + 18));
J>        return (Ret_t *)&t;
J>    }

//CC G++
//G++-FLAGS -Xdebug -O0 -std=gnu++0x -- -lstdc++
#include <windows.h>
#include <iostream>
#include <string>

template<class LAMBDA>
BOOL CALLBACK EnumWindowsLambda(HWND hwnd, LPARAM lParam)
{
    return (*reinterpret_cast<LAMBDA*>(lParam))(hwnd);
}

template<class LAMBDA>
BOOL EnumWindows(LAMBDA lpEnumLambda)
{
    return EnumWindows(&EnumWindowsLambda<LAMBDA>, reinterpret_cast<LPARAM>(&lpEnumLambda));
}

int main()
{
    std::string title = "HWND:";
    EnumWindows([&](HWND hwnd) -> BOOL {
        std::cout << title << std::hex << hwnd << std::endl;
        return TRUE;
    });
}

BOOL EnumWindows(std::function<BOOL(HWND)> const& cb)
{
    typedef std::function<BOOL(HWND)> cbtype;
    struct cbwrap {
        static BOOL CALLBACK cb(HWND hwnd, LPARAM lParam)
        {
            return (*reinterpret_cast<cbtype*>(lParam))(hwnd);
        }
    };
    return EnumWindows(&cbwrap::cb, reinterpret_cast<LPARAM>(&cb));
}

int main()
{
    std::string title = "HWND:";
        //это сработает, тк. параметры лямбды полностью совпадают
    EnumWindows([&](HWND hwnd) -> BOOL {
        std::cout << title << std::hex << hwnd << std::endl;
        return TRUE;
    });
        //это не сработает, тк. параметры лямбды не совпадают
    EnumWindows([&](HWND hwnd) -> std::string {
        return "aaaa";
    });
}

void foo()
{
  ...
  struct args
  {
    HWND& found; DWORD procid;
    static BOOL CALLBACK ewp(HWND w, LPARAM p) { return (*(args*)p)->ewp(w); }
    BOOL ewp() { ..... }
  } a;
  EnumWindows(args::ewp, &a);
  ...
}

template<class CB> struct callback;

template<class F> struct callback_base
{
  typedef function<F> closure_type;
  static LPARAM param(closure_type const& f) { return (LPARAM)&f; }
};

template<class R> struct callback<R (CALLBACK*)(LPARAM)> : callback_base<R(LPARAM)>
{
  static R CALLBACK thunk(LPARAM p) { return (*(closure_type*)p)(); }
};
template<class R, class A1> struct callback<R (CALLBACK*)(A1, LPARAM)> : callback_base<R(A1,LPARAM)>
{
  static R CALLBACK thunk(A1 a1, LPARAM p) { return (*(closure_type*)p)(a1); }
};
template<class R, class A1, class A2> struct callback<R (CALLBACK*)(A1, A2, LPARAM)> : callback_base<R(A1,A2,LPARAM)>
{
  static R CALLBACK thunk(A1 a1, A2 a2, LPARAM p) { return (*(closure_type*)p)(a1,a2); }
};
.....

.....
  EnumWindow(
    callback<ENUMWINDOWPROC>::thunk,
    callback<ENUMWINDOWPROC>::param( [](HWND)->BOOL { ..... } )
  );
.....