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