Re: std::string bad design????
Ivan Vecerina wrote:
You're not.
It is a fact that experts have identified several flaws when
looking back at the specification of std::string in C++98,
and unfortunately it is very difficult if not impossible
to change things now.
It is not possible to change std::string now but it is possibly to
create a new immutable string class.
In my opinion the two main flaws are:
- Lack of a "const string", whose contents cannot be modified.
std::string was initially thought to use reference-counting
and copy-on-write. However, this prove to be excessively
difficult to implement efficiently, especially in a multi-
threaded environment. As a result, several std::string
implementations have given up on using reference-counting.
Lack of a standard layout in my opinion is a major flaw. That means
that I can't write library function to return a std::string if the
other end is not using the same implementation of STL that I am using.
Most other languages use non-mutable strings (where one
cannot directly modify a char within the string), which are
easier to optimize (no baggage related to COW or reserved
capacity). [ Kevlin Henney once wrote a full article about
this in CUJ, if I remember correctly... ]
The language could still have one, it just wouldn't be std::string.
- Excessive number of member functions: std::string has
more members than any other standard library class. Yet it
is far from being complete or satisfactory (e.g. novices
commonly look for trim, split, toupper, etc functions found
in other libraries or languages). The STL has set a nice
precedent by separating algorithms from containers. The
same could have been done with std::string: provide
non-member functions to perform any non-fundamental
string manipulations. This would have set a precedent
allowing uniform extensibility of std::string: for example
we could add a header that provides all internationalization-
related functions, etc. And for basic uses std::string
would remain leader. Now we have a bulky class, and
a dichotomy between a set of member functions and the rest
of the world. This in turn leads many novices to think that
they need to subclass std::string to add operations that
they miss.
They miss two things, a converter to upper/lower (can be done with
std::transform) and a comparison function that is case insensitive
(could be done with an external predicate). You would expect to find
these perhaps in std::locale but they're not there.
I would like a swap between std::basic_string<E> and std::vector<E>. I
would like a proper efficient char_traits for any primitive integral
type. I would like to be able to get a writable buffer for a
std::string so you wouldn't have to fiddle around with vector<char> in
the first place.
(split that you suggest is missing, is surely just substr(), by the way
?)
back() is also a strangely missing member function. (back() looks a lot
neater than *rbegin() )
Actually saying that std::string is broken remains a matter
of opinion (same as for iostream+stream_buf). But I am sure
that if the first C++ standard was being (re)written today,
std::string would not be the same...
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]