class thread_adapter
{
public:
    thread_adapter(void (*func)(void*), void* param)
        : _func(func), _param(param)
    {
    }
    void operator()() const { _func(_param); }
private:
    void (*_func)(void*);
    void* _param;
};

    phil p[] = { phil(0), phil(1), phil(2), phil(3), phil(4) };
    boost::thread thrd_phil0(thread_adapter(&phil::do_thread, &p[0]));
    boost::thread thrd_phil1(thread_adapter(&phil::do_thread, &p[1]));
    boost::thread thrd_phil2(thread_adapter(&phil::do_thread, &p[2]));
    boost::thread thrd_phil3(thread_adapter(&phil::do_thread, &p[3]));
    boost::thread thrd_phil4(thread_adapter(&phil::do_thread, &p[4]));


    thrd_phil0.join();
    thrd_phil1.join();
    thrd_phil2.join();
    thrd_phil3.join();
    thrd_phil4.join();

#include <iostream>
#include <boost/thread/xtime.hpp>
#include <boost/thread/thread.hpp>

//для SetConsoleCtrlHandler ...
#include <windows.h>

class MSK {
public:
    MSK() : is_running(false)
    {

    }

    void run()
    {
        is_running = true;
        while(is_running)
        {
            std::cout << "PnP run...\n";

            // приостанавливаем поток на 10 секунд
            boost::xtime xt;
            boost::xtime_get(&xt, boost::TIME_UTC);
            xt.sec += 10;
            boost::thread::sleep(xt);
        }
        std::cout << "[run] ok\n";
    }

    void stop()
    {
        is_running = false;
    }

    static void do_thread(void* param)
    {
        static_cast<MSK*>(param)->run();
    }

private:
    bool is_running;
};

class thread_adapter
{
public:
    thread_adapter(void (*func)(void*), void* param)
        : _func(func), _param(param)
    {
    }
    void operator()() const { _func(_param); }
private:
    void (*_func)(void*);
    void* _param;
};

MSK msk;

BOOL WINAPI stop_handler(DWORD ctrl_type)
{
    switch (ctrl_type)
    {
    case CTRL_C_EVENT:
    case CTRL_BREAK_EVENT:
    case CTRL_CLOSE_EVENT:
    case CTRL_SHUTDOWN_EVENT:
        std::cout << "waiting to stop...\n";
        msk.stop();
        return TRUE;
    default:
        return FALSE;
    }
}

int main()
{
    std::cout << "[start]\n";

    boost::thread msk_thrd(thread_adapter(&MSK::do_thread, &msk));

    SetConsoleCtrlHandler(&stop_handler, TRUE);

    msk_thrd.join();

    std::cout << "[stop]\n";

    return 0;
}

tm_isdst =  0 // DST нет
tm_isdst =  1 // DST есть
tm_isdst = -1 // определить есть ли DST для этого времени

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

DWORD CALLBACK ThreadProc(void*)
{
 Sleep(INFINITE);
 return 0;
}

int __cdecl main(int argc, const char* argv[])
{
int i;
 for (i = 0; i < 100000; i++) {
  DWORD id;
  //HANDLE h = CreateThread(NULL, 0, ThreadProc, NULL, 0, &id);
    HANDLE h = CreateThread(NULL, 4096, ThreadProc, NULL,
               STACK_SIZE_PARAM_IS_A_RESERVATION, &id);
  if (!h) break;
  CloseHandle(h);
 }
 printf("Created %d threads\n", i);
 return 0;
}

X(Red, "red")
X(Green, "green")

enum Colours {
#define X(a, b) a,
#include "colours.def"
#undef X
    ColoursCount
};

char const* const colours_str[] = {
#define X(a, b) #b,
#include "colours.def"
#undef X
    0
};

int main()
{
    std::cout << colours_str[Green] << "\n";
    return 0;
}