Re: Need Container for Large Binary String

floobles wrote:

> I need to manipulate large binary strings.

> The STL string class would be ideal, except that all its functions
> expect a '\0' as the end of the string

This is not true. There *are* functions that use 0 as a terminator (they are useful for interfacing with the "rest of the world"), but not all of them have this property. There are many string member functions that use iterators or have explicit length/size parameter. Look for them, learn them, use them.

 > my binary string will have
 > lots of '/0'...

With just a bit of care, having a std::string with embedded zeros is not a problem.

> Next ideal would be the STL vector, but it doesn't seem like there is
> an efficient way in initializing the vector with my binary data (i.e.
> the constructors don't take a char* and length as parameters .\_/. )

But it takes iterators:

char buf[1000]; // just for presentation std::vector<char> v(&buf[0], &buf[1000]); // no problem

or

char *begin = &buf[0];
std::vector<char> v(begin, begin + 1000); // no problem

> Is it possible to do a memcpy-type initialization? But this would
> rely on the implementation (and not the interface) of the vector...

Yes, but this very internal property of std::vector (the fact that it stores its data in a contiguous block) is part of its interface:

std::vector<char> v(1000);
memcpy(&v[0], buf, 1000); // no problem

However, the memcpy approach has absolutely no advantage over the iterator-style (see above) initialization. Interestingly, iterator-style initialization may be faster, because it is a single-phase action instaed of two-phase (create a vector of given size and then memcpy).

> The MFC arrays

Forget them. ;)

> I would appreciate some suggestions on which class to use. At this
> point, I'm most likely going with the STL vector, using a for-loop to
> initialize my bytes...(ugh)

Use iterator-style initialization. The vector will do the looping for you.

You may also have to think a bit before you choose between string and vector<char>. Both are powerful, but only vector guarantees the contiguous memory layout, so if you need to interface with some external API that expects this, then vector<char> may be the only option. On the other hand, string has a big family of find* and replace*-like functions, which means you may prefer string for this kind of processing.

-- 
Maciej Sobczak : http://www.msobczak.com/
Programming    : http://www.msobczak.com/prog/

      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated.    First time posters: Do this! ]