Здравствуйте, Аноним, Вы писали:

А>ATL есть, а STL точно нет. Пока больше склоняюсь к realloc-у. Хотя вариант записи в файл так же не исключаю

/**pod namespace - POD primitives. **/
namespace pod
{
  template <typename T> void copy ( T* dst, const T* src, size_t nelements)
  {
      memcpy(dst,src,nelements*sizeof(T));
  }
  template <typename T> void move ( T* dst, const T* src, size_t nelements)
  {
      memmove(dst,src,nelements*sizeof(T));
  }

  /** buffer  - in-memory dynamic buffer implementation. **/
  template <typename T>
    class buffer 
    {
      T*              _body;
      size_t          _allocated;
      size_t          _size;

      T*  reserve(size_t size)
      {
        size_t newsize = _size + size;
        if( newsize > _allocated ) 
        {
          _allocated = (_allocated * 3) / 2;
          if(_allocated < newsize) _allocated = newsize;
          T *newbody = new T[_allocated];
          copy(newbody,_body,_size);
          delete[] _body;
          _body = newbody;
        }
        return _body + _size;
      }

    public:

      buffer():_size(0)        { _body = new T[_allocated = 256]; }
      ~buffer()                { delete[] _body;  }

      const T * data()   
      {  
               if(_size == _allocated) reserve(1); 
               _body[_size] = 0; return _body; 
      }

      size_t length() const         { return _size; }

      void push(T c)                { *reserve(1) = c; ++_size; }
      void push(const T *pc, size_t sz) { copy(reserve(sz),pc,sz); _size += sz; }

      void clear()                  { _size = 0; }

    };

    typedef buffer<byte> byte_buffer; 
    typedef buffer<wchar_t> wchar_buffer; 
    typedef buffer<char> char_buffer; 
}

В моем примере подставь

pod::byte_buffer bytes_received;
...
bytes_received.push( buf, n_bytes_in_buf );

bytes_received.data();
bytes_received.length();

А html ты как/чем собрался прасить-то?