template <class _Data_t>
struct THREAD_PARAM
{
    FARPROC pfnGetModuleHandle;
    FARPROC pfnGetProcAddress;
    _Data_t data;
};

typedef void (*MyFunc)(void*);

struct THREAD_PARAM_PARENT
{
    FARPROC pfnGetModuleHandle;
    FARPROC pfnGetProcAddress;
};

template <class _Data_t>
struct THREAD_PARAM:
    public THREAD_PARAM_PARENT
{
    _Data_t data;
};

typedef void (*MyFunc)(THREAD_PARAM_PARENT*);

struct MY_DATA
{
...
};

DWORD __stdcall MyProc(THREAD_PARAM<MY_DATA>* pParam)
{
...
}

> Это все понятно, но это — "в обход".

> Хорошо, "предположим, что задача решена". Мне хочется, чтобы "пользователь" шаблона мог действовать примерно так:

> struct MY_DATA
> {
> ...
> };
>
> DWORD __stdcall MyProc(THREAD_PARAM<MY_DATA>* pParam)
> {
> ...
> }
>

void my_thread_fun(int a, int b, int c);
// ...
boost::thread(boost::bind(my_thread_fun, 1, 2, 3));

typedef boost::function<void()> thread_fun;

DWORD WINAPI thread_thunk(void* arg)
{
     std::auto_ptr<thread_fun> f(static_cast<thread_fun*>(arg));
     (*f)();
     return 0;
}

void create_thread(thread_fun const& f)
{
     std::auto_ptr<thread_fun> arg(new thread_fun(f));
     CreateThread(..., thread_thunk, arg.get(), ...);
     arg.release();
}

void my_thread_fun(int a, int b, int c);
// ...
create_thread(boost::bind(my_thread_fun, 1, 2, 3));

typedef void (* PFN)(PARAM_конкретизированный_все_равно_чем* pParam);

template <class _Data_t>
struct PARAM
{
    int x;
    char c;
    _Data_t data;
};

struct MY_DATA { ... };
struct YOUR_DATA { ... };

void MyProc(PARAM<MY_DATA>* pParam) { ... }
void YourProc(PARAM<YOUR_DATA>* pParam) { ... }

SDB>Безусловно. Но! — вот эти две функции шаблонными не являются, насколько я понимаю:

SDB>template <class _Data_t>
SDB>struct PARAM
SDB>{
SDB>    int x;
SDB>    char c;
SDB>    _Data_t data;
SDB>};

SDB>struct MY_DATA { ... };
SDB>struct YOUR_DATA { ... };

SDB>void MyProc(PARAM<MY_DATA>* pParam) { ... }
SDB>void YourProc(PARAM<YOUR_DATA>* pParam) { ... }
SDB>

template <typename Data>
struct param_helper
{
    typedef void (*type)(PARAM<Data> *);
};

// Использование

param_helper<MY_DATA>::type fun1 = &MyProc;
param_helper<YOUR_DATA>::type fun2 = &YourProc;

template <class _Data_t>
struct THREAD_PARAM
{
    FARPROC pfnGetModuleHandle;
    FARPROC pfnGetProcAddress;
    _Data_t data;
};

// interface

template <class _Data_t, DWORD(__stdcall* _Proc)(THREAD_PARAM<_Data_t>*)>
class CRemoteProc
{
// construction/destruction
public:
    CRemoteProc(HANDLE hProcess, int cbMaxCode = 4096);
    ~CRemoteProc(void);

// copying/assignment - disabled and thus not implemented
private:
    CRemoteProc(const CRemoteProc& rhs);
    CRemoteProc& operator=(const CRemoteProc& rhs);

// type conversion
public:
    operator LPTHREAD_START_ROUTINE(void) const;

// attributes
private:
    HANDLE m_hProcess;
    void* m_codePtr;
};

// implementation

template <class _Data_t, DWORD(__stdcall* _Proc)(THREAD_PARAM<_Data_t>*)>
inline CRemoteProc<_Data_t, _Proc>::CRemoteProc(HANDLE hProcess, int cbMaxCode):
m_hProcess(hProcess),
m_codePtr(NULL)
{
    m_codePtr = ::VirtualAllocEx(hProcess, NULL, cbMaxCode, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    ::WriteProcessMemory(m_hProcess, m_codePtr, _Proc, cbMaxCode, NULL);
}

template <class _Data_t, DWORD(__stdcall* _Proc)(THREAD_PARAM<_Data_t>*)>
inline CRemoteProc<_Data_t, _Proc>::~CRemoteProc(void)
{
    ::VirtualFreeEx(m_hProcess, m_codePtr, 0, MEM_RELEASE);
    m_codePtr = NULL;
}

template <class _Data_t, DWORD(__stdcall* _Proc)(THREAD_PARAM<_Data_t>*)>
inline CRemoteProc<_Data_t, _Proc>::operator LPTHREAD_START_ROUTINE(void) const
{
    return (reinterpret_cast<LPTHREAD_START_ROUTINE>(m_codePtr));
}

DWORD __stdcall MyProc(THREAD_PARAM<некий_тип>* pParam) { ... }