Многопоточный чат с использованием пула потоков

class ClassMaster
{
    typedef std::set<SOCKET> ClientList_t;
    typedef std::map<SOCKET, boost::thread*> HandlerProcessThread_t;
public:
    void Dispatch(bool &bWork)
    {
        
        while(bWork)
        {
            //std::cout<<"dispatch" <<std::endl;
            if(!_Clients.empty())
            {
                //std::cout<<"Clients not empty" << std::endl;
                fd_set ReadSet;
                fd_set WriteSet;
                fd_set ExceptSet;
                FD_ZERO(&ReadSet);
                FD_ZERO(&WriteSet);
                FD_ZERO(&ExceptSet);
                ClientList_t::iterator Iter = _Clients.begin();
                for(int i = 0; Iter != _Clients.end() && i < FD_SETSIZE; ++Iter, ++i)
                {
                    ReadSet.fd_array[i] = *Iter;
                }
                ReadSet.fd_count = _Clients.size();
                memcpy(&ExceptSet, &ReadSet, sizeof(fd_set));
                ClientList_t::iterator MaxFdIter = --_Clients.end();
                timeval tm;
                tm.tv_usec = 10;
                tm.tv_sec = 0;
                int Fds = select(*MaxFdIter + 1, &ReadSet, &WriteSet, &ExceptSet, &tm);
                if(Fds == -1)
                {
                    std::cout<<"Select error: " << h_errno << std::endl;
                }
                //std::cout<<"Fds = " << Fds << std::endl;
                for(unsigned int i = 0; i < ReadSet.fd_count; i++)
                {
                    SOCKET sock = ReadSet.fd_array[i];
                    //std::cout<<"Read ready socket" << sock << std::endl;
                    ProcessRead(sock);
                }
                while(!_ClosedSocket.empty())
                {
                    Disconnect(_ClosedSocket.front());
                    _ClosedSocket.erase(_ClosedSocket.begin());
                }
 
            }
            //boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
        }
        
    }
    void AddClient(const SOCKET & sock)
    {
        _Clients.insert(sock);
        boost::thread * New = new boost::thread(&ClassMaster::ProcessWrite, boost::ref(*this), sock);
        _Threads.insert(std::make_pair(sock, New));
        //std::
    }
    void DeleteClient(const SOCKET & sock)
    {
        ClientList_t::iterator Iter = _Clients.begin();
        for(; Iter != _Clients.end(); ++Iter)
        {
            if(*Iter == sock)
            {
                _Clients.erase(Iter);
                break;
            }
        }
        if(_Threads.find(sock) != _Threads.end())
        {
            if(_Threads[sock]->joinable())
            {
                _Threads[sock]->detach();
            }
 
            delete _Threads[sock];
            _Threads.erase(sock);
        }
    }
    void ProcessRead(SOCKET sock)
    {
        char msg[1024];
        int n = 0;
        n = recv(sock, msg, 1024,0);
        
 
        int SockError = 0;
        int Len = sizeof(SockError);
        if(n <= 0)
        {
            Disconnect(sock);
        }
        else
        {
            std::cout<< "Remote said: ";
            for(int i = 0; i < n; i ++)
            {
                std::cout<< msg[i]<<"";
            }
            std::cout << std::endl;
        }
    }
    void ProcessWrite(SOCKET sock)
    {
        char msg[1024];
        std::string mes;
        while(1)
        {
            getline(std::cin,mes);
            if(mes == "q")
            {
                break;
            }
            int n = 0;
            n = send(sock, mes.c_str(), mes.length(),0);
        }
        _ClosedSocket.push_back(sock);
    }
    void Disconnect(const SOCKET &sock)
    {
        DeleteClient(sock);
        closesocket(sock);
        std::cout << "Client has disconnected." << std::endl;
    }
private:
    ClientList_t _Clients;
    HandlerProcessThread_t _Threads;
    std::list<SOCKET> _ClosedSocket;
};
 
SOCKET CreateServerSocket(SOCKET & ServerSocket)
{
    ServerSocket = socket(AF_INET, SOCK_STREAM, 0);
    if(ServerSocket == INVALID_SOCKET)
    {
        std::cout << "Error of creating socket: code " << h_errno << std::endl;
        return false;
    }
    sockaddr_in ServerAddress;
    memset(&ServerAddress,0,sizeof(ServerAddress));
    ServerAddress.sin_family = AF_INET;
    //ServerAddress.sin_addr.s_addr=INADDR_ANY;
    /*ServerAddress.sin_addr.S_un.S_un_b.s_b1 = 192;
    ServerAddress.sin_addr.S_un.S_un_b.s_b2 = 168;
    ServerAddress.sin_addr.S_un.S_un_b.s_b3 = 133;
    ServerAddress.sin_addr.S_un.S_un_b.s_b4 = 85;*/
    ServerAddress.sin_addr.s_addr = inet_addr("192.168.133.85");
    ServerAddress.sin_port=htons(17000);
    if(bind(ServerSocket, (sockaddr *)&ServerAddress,sizeof(ServerAddress)))
    {
        std::cout << "Error of binding socket: code " << h_errno << std::endl;
        return false;
    }
    if(listen(ServerSocket, 10))
    {
        std::cout << "Error of going listened socket: code " << h_errno << std::endl;
        return false;
    }
    return true;
}
 
int _tmain(int argc, _TCHAR* argv[])
{
    WSAData WsaData;
    WSAStartup(MAKEWORD(2,0),&WsaData);
    SOCKET ServerSocket = 0;
    if(!CreateServerSocket(ServerSocket))
    {
        system("pause");
        return 0;
    }
    sockaddr_in ClientAddress;
    int ClientAddressSize = sizeof(ClientAddress);
    memset(&ClientAddress,0,sizeof(ClientAddress));
    SOCKET ClientSocket;
    ClassMaster Master;
    bool bWork = true;
    boost::thread ThreadDispatcher(&ClassMaster::Dispatch, boost::ref(Master), boost::ref(bWork));
    while(1)
    {
        ClientSocket = accept(ServerSocket, (sockaddr*)&ClientAddress, &ClientAddressSize);
        if(ClientSocket == INVALID_SOCKET)
        {
            std::cout << "Error of accept socket: code " << h_errno << std::endl;
        }
        std::cout<<"Has connection!"<<std::endl;
        std::cout<<"Client: " << (int)ClientAddress.sin_addr.S_un.S_un_b.s_b1 <<"." << 
            (int)ClientAddress.sin_addr.S_un.S_un_b.s_b2 << "." << (int)ClientAddress.sin_addr.S_un.S_un_b.s_b3 << "." <<
            (int)ClientAddress.sin_addr.S_un.S_un_b.s_b4 << ":" << ClientAddress.sin_port <<std::endl;
        Master.AddClient(ClientSocket);
    }
    /*boost::thread tr(Func);
    boost::this_thread::sleep_for(boost::chrono::milliseconds(3000));
    tr.interrupt();
    */
    bWork = false;
    ThreadDispatcher.join();
    system("pause");
    return 0;
}

ProcessRead(sock);