Re: Splitting strings
On Nov 19, 12:59 pm, Alan Woodland <a...@aberystwyth.ac.uk> wrote:
I was looking for a clean, generic way to split strings around
a character using STL algorithms. The best I could manage was
this example, which isn't exactly great to say the least.
#include <cassert>
#include <vector>
#include <algorithm>
#include <string>
#include <sstream>
#include <iterator>
#include <iostream>
namespace {
template <typename T>
struct SplitHelper {
std::basic_ostringstream<typename T::value_type> next;
std::vector<T> result;
typename T::value_type match;
static bool test(SplitHelper& h, const typename T::value_type c) {
if (c == h.match) {
h.result.push_back(h.next.str());
h.next.str(T());
}
return c == h.match;
}
};
}
std::vector<T> split(const T& str, const typename T::value_type c='/') {
SplitHelper<T> h;
h.match = c;
h.result.reserve(std::count(str.begin(), str.end(), c));
std::remove_copy_if(str.begin(), str.end(),
std::ostream_iterator<typename T::value_type>(h.next),
std::bind1st(std::ptr_fun(&h.test), h));
h.result.push_back(h.next.str());
return h.result;
}
[...]
Is this really the tidiest way to do this using STL algorithms?
Certainly not. If it were, I don't think anyone would use the
STL. I haven't understood all of it, but I don't see why you
would need a stringstream, for example. Something as simple as:
std::vector< std::string >
split( std::string const& original, char separator = ':' )
{
std::vector< std::string >
result;
typedef std::string::const_iterator
TextIter;
TextIter end = original.end();
TextIter current
= std::find( original.begin(), end, separator );
result.push_back( std::string( original.begin(), current ) );
while ( current != end ) {
++ current;
TextIter next
= std::find( current, end, separator );
result.push_back( std::string( current, next ) );
current = next;
}
return result;
}
(This is just off the top of my head, so there may be some
issues with border conditions. For that matter, you haven't
really defined adequately what the function should do to be able
to write it correctly.)
Obviously it wouldn't be hard at all to do just using a for
loop and two pointers, but I was trying to do this 'the STL
way'.
The STL way is to use iterators (instead of pointers) and
algorithms. You still need the outer loop; you could probably
design a special iterator, based on std::string::const_iterator,
and returning an std::string when dereferences, then use
something like std::copy and a back inserter, but that's really
more complexity than you want. (If the standard iterators used
the GoF idiom, it would be very simple, but the STL idiom is
designed to make everything twice as complex as needs be.)
--
James Kanze