> std::string mySocket::recive()
> {
>    int i_ret = 0;
>    char *buf[100];
>    std::string result;
>
>    while(true)
>    {
>       i_ret = ::recv(this->sock, buf, sizeof(buf),0);
>       if(i_ret == 0)
>       {
             //throw(SocketExeption("Connection has been gracefully closed"));
             // здесь, наверное, не нужно бросать исключение,
             // так как это нормальная и ожидаемая ситуация.
             // получение 0 из recv означает EOF - конец файла.
             // ты же не станешь бросать исключение, когда прочитаешь файл до конца?
             return result;
>       }
>       if(i_ret == SOCKET_SRROR)
>       {
>           throw(SocketExeption("recv error"));
>       }
>       //result += buf;
         // здесь серьезная ошибка - recv - не ориентирована на C-строки
         // и не добавляет 0 в конце считанных данных,
         // считанный поток может содержать 0 и ты потеряешь все данные после первого 0
         result->append(buf, i_ret);
>    }
>    return result;
> }
>

> std::string TcpSocket::recive()
> {
> u_long avail_bytes = 0;//количество байт для приема, находящихся на сокете
> int i_ret = 0;
> while (!avail_bytes)
> {
> i_ret = ioctlsocket(sock, FIONREAD, &avail_bytes);
> if(i_ret == SOCKET_ERROR)
> {
> throw(SocketExeption("ioctlsocket() error"));
> }
> }
>

>     std::string TcpSocket::recive()
>     {
>         u_long avail_bytes = 0;//количество байт для приема, находящихся на сокете
>         int i_ret = 0;
>         //Узнаем сколько байт надо считать из сокета
>         //Если не было ошибки, то в avail_bytes будет содержаться количество байт для считывания из сокета
>         //Для датаграммных сокетов возвращается также кол-во доступных, но считывать придётся по-"датаграммно".
>         //Система сама будет возвращать данные таким образом, к тому что, за один раз пару датаграмм не считать

             // причем здесь датаграммы??? у тебя TCP сокет

>         while (!avail_bytes)
             // получил (спин) блокировку
             // зачем это городить, если можно просто сделать блокирующий вызов read()???
             // или вернуть пустую строку, если в буфере пусто
>         {
>             i_ret = ioctlsocket(sock, FIONREAD, &avail_bytes);
>             if(i_ret == SOCKET_ERROR)
>             {
>                 throw(SocketExeption("ioctlsocket() error"));
>             }
>         }
>
>
>         std::cout << "avail_bytes: " << avail_bytes << std::endl;
>         //char *buf = new char [avail_bytes+1];//выделяем память для получения данных из сокета
             // лучше возьми vector - так у тебя гарантировано не будет утечек
             std::vector<char> buf(avail_bytes);

>         i_ret = ::recv(sock, &buf[0], avail_bytes, 0);//получаем данные
>         if(i_ret == 0)
>             throw(SocketExeption("Connection has been gracefully closed"));
>         if(i_ret == SOCKET_ERROR)
>             throw(SocketExeption("recv() error"));

             return std::string(&buf[0], buf.size());
>     }
>

ME>
• Считать весь поток (пока recv не вернет 0) - я думал, что recv возвращает 0 только тогда, когда удаленная сторона разорвет соединение, я не прав?
  ME>
• Считать N байт - вариант неплохой... но кто знает сколько их там? если полтьзователь класса укажет считать 100 байт, а их там 50... программа приостановит выполнение, т.к. recv блокирующая...
  ME>
• Читать в течение N секунд
  ME>
• Считать до конца строки/символа/условия
  ME>

> std::vector<char> TcpSocket::recive()
>     {
>         //ждем пока сокет будет готов для чтения, т.е. пока на него придут данные
>         fd_set read_s;//множество
>         FD_ZERO(&read_s);//обнуляем множество
>         FD_SET(this->sock, &read_s);//заносим в него наш сокет
>         int i_ret = 0;
>         i_ret = ::select(read_s.fd_count, &read_s, NULL, NULL, NULL);//последний параметр - таймаут, не задан...
>         if((i_ret == SOCKET_ERROR) || (i_ret == 0))//i_ret = 0 при истечении таймаута
>         {
>             throw(SocketExeption("select() error"));
>         }
>
>         //получаем количество байт, пришедших в буфер сокета
>         u_long avail_bytes = 0;//количество байт для приема, находящихся на сокете
>         //Узнаем сколько байт надо считать из сокета
>         //Если не было ошибки, то в avail_bytes будет содержаться количество байт для считывания из сокета
>         //Для датаграммных сокетов возвращается также кол-во доступных, но считывать придётся по-"датаграммно".
>         //Система сама будет возвращать данные таким образом, к тому что, за один раз пару датаграмм не считать
>         i_ret = ioctlsocket(sock, FIONREAD, &avail_bytes);
>         if(i_ret == SOCKET_ERROR)
>         {
>             throw(SocketExeption("ioctlsocket() error"));
>         }
>
>             //выделяем буфер под данные
>         char *buf = new char [avail_bytes+1];//выделяем память для получения данных из сокета
>         
>         //получаем данные
>         i_ret = ::recv(sock, buf, avail_bytes, 0);//получаем данные
>         if(i_ret == 0)
>         {
>             delete [] buf;//освобождаем память
>             connected = false;//соединение разорвано
>             throw(SocketExeption("Connection has been gracefully closed"));
>         }
>
>         if(i_ret == SOCKET_ERROR)
>         {
>             delete [] buf;//освобождаем память
>             throw(SocketExeption("recv() error"));
>         }
>
>         if(i_ret > 0)
>         {
>             buf[i_ret]='\0';
>         }
>         
>         std::vector<char> v_result;
>         std::copy(&buf[0], &buf[i_ret], std::back_inserter(v_result));//копируем буфер в std::vector<char>
>
>         delete [] buf;//освобождаем память
>         return v_result;
>     }
>

_>TcpSocket sock;
_>sock.connect("pop.mail.ru", 110);
_>sock.recive();//куда-то все выводим, только вот сервер не успевает мне отправить данные, до вызова recive...
/* а вы используйте блокирующие сокеты, тогда recv подождёт (тогда весь мир подождёт :)*/
_>sock.send("text");
_>

_>int i_ret;
_>char ch;
_>std::vector<char> v_recv;
_>while(true)
_>{
_>    i_ret = ::recv(sock, &ch, 1, 0);
_>    if(i_ret == SOCKET_ERROR)
_>    {
_>         throw(SocketExeption("recv() error"));
_>    }
_>    if(i_ret == 0)
_>    {
/* 
    сюда вы попадёте только в одном случае, когда противоположная сторона закроет соединение
    и вы прочитаете все данные, которые она послала.
*/
_>         throw(SocketExeption("соеднение прервано удаленной стороной"));//как вот с этим быть?
_>    }
_>    v_recv.push_back(ch);
_>}
_>

_>>TcpSocket sock;
_>>sock.connect("pop.mail.ru", 110);
_>>sock.recive();//куда-то все выводим, только вот сервер не успевает мне отправить данные, до вызова recive...
B>/* а вы используйте блокирующие сокеты, тогда recv подождёт (тогда весь мир подождёт :)*/
_>>sock.send("text");
_>>

_>>int i_ret;
_>>char ch;
_>>std::vector<char> v_recv;
_>>while(true)
_>>{
_>>    i_ret = ::recv(sock, &ch, 1, 0);
_>>    if(i_ret == SOCKET_ERROR)
_>>    {
_>>         throw(SocketExeption("recv() error"));
_>>    }
_>>    if(i_ret == 0)
_>>    {
B>/* 
B>    сюда вы попадёте только в одном случае, когда противоположная сторона закроет соединение
B>    и вы прочитаете все данные, которые она послала.
B>*/
_>>         throw(SocketExeption("соеднение прервано удаленной стороной"));//как вот с этим быть?
_>>    }
_>>    v_recv.push_back(ch);
_>>}
_>>

_>>>int i_ret;
_>>>char ch;
_>>>std::vector<char> v_recv;
_>>>while(true)
_>>>{
_>>>    i_ret = ::recv(sock, &ch, 1, 0);
_>>>    if(i_ret == SOCKET_ERROR)
_>>>    {
_>>>         throw(SocketExeption("recv() error"));
_>>>    }
_>>>    if(i_ret == 0)
_>>>    {
B>>/* 
B>>    сюда вы попадёте только в одном случае, когда противоположная сторона закроет соединение
B>>    и вы прочитаете все данные, которые она послала.
B>>*/
_>>>         throw(SocketExeption("соеднение прервано удаленной стороной"));//как вот с этим быть?
_>>>    }
_>>>    v_recv.push_back(ch);
_>>>}
_>>>

ME>std::vector<char> buf(avail_bytes);
ME>i_ret = ::recv(sock, &buf[0], buf.size(), 0);
ME>