reserve, that’s it! Makes sense to follow that convention, I think.

I don’t really see why I would use a buffer over a vector if I needed a growable thing, but you may have a point.

std::string is often criticized for its excessively wide interface, so I was trying to save you from that ;-)

Another thing occurred to me: detach() sounds a lot like auto_ptr’s release(). I like detach better, but it feels like a Microsoftism–Their ATL library uses it consistently.

For what it’s worth,
- Kim

buffer b(128);
sock.receive(boost::asio::buffer(b));

Changing the underlying buffer type from char* to void* would make using the buffer much less convenient. For example, to get the pointer to the 10th byte, now we can write:

char* p = b.data () + 10;

If the underlying buffer type were void*, we would have had to write this instead:

void* p = static_cast (b.data ()) + 10;

Also note that char* will always implicitly convert to void* so if you want you can use the buffer class as if the underlying buffer type were void*:

void* p = b.data ();

std::vector v;
v.reserve(1024);

will give a vector of size 0 and of capacity 1024 (or greater). Strictly speaking, you still cannot access the underlying buffer because the vector is empty. Also, if later you do something like v.resize(1024) or v.insert(v.end(), data, data + size), all your data will be overwritten.

I agree the size() and capacity() modifiers are a bit unconventional. The alternatives would be to follow the std container/string naming and call them resize() and reserve(). I think it is a good idea to have both size and capacity; the buffer may contain only so much data (size) but you may want to allocate a larger chunk of memory than what is currently needed (capacity) in order to be able to grow without reallocations.

Regarding the find() redundancy, I disagree: b.find(’x') is terser than find(b.data(), b.data() + b.size(), ‘x’). Also std::string has find() even though you can use std::find() with it as well.

Regarding iterators, yes, I initially added them using the raw pointer as the iterator type. This may not be the preferred approach for std containers so it may have to be wrapped into a class-type. But I agree, iterators are a good idea.

Same about movable — the C++-0x version should definitely support this. I wonder if there is a portable way to detect the C++-0x mode at compile time?

how does this buffer class relate to the Asio buffer:

http://www.boost.org/doc/libs/1_47_0/boost/asio/buffer.hpp

it would be nice to have only one…

Cheers

Marco

The buffer data is not a sequence of characters. If anything it is a sequence/block of bytes.

I’ll suggest introducing a typedef to represent that, e.g.

class buffer
{
public:
typedef void * bufptr; // or bufdata or memdata or memptr or …
…

};

OK, it’s more text to write, but wouldn’t that give you an uninitialized buffer of size 1024?