Re: std::string bad design????
James Kanze wrote:
You should try the iterators-state-in-the-container model. Everyone I
have met who has experience the pleasure of not having to create an
iterator to go with a container has raved about it, from students to
colleagues. It's addictive, and especially attractive when you are
iterating over a container that is 3-levels deep inside nested
containers.
It's easier for the author of the container, yes.
Everyone who has used my containers have said they prefer them over
STL. And I am the last person to try to push my code on someone else.
One of these people was a long-time friend of mine who had become so
accustomed to using mine over STL, that we almost soured our
relationship because he would not accept that I would not allow him to
continue using them after working for a company where there would be a
conflict of interest. The same has been true for my students.
Frankly, I am picky about my own code, but I would prefer that people
using things that are standard, but apparently, for them, it makes a
difference too, enough that they would abandon that which they had
already learned, STL.
On the other
hand, I've never found a user who had to use one who didn't end
up cursing the author of the container for it. How do you
maintain several iterators into the container, for example.
One you have the address of an element in the container, it is a simply
matter relocating that element in the container. Most of my containers
(non-tree) have indexing operations using unsigned int as the index, so
those could be used to, which O(n) being what one would expect for
conventional implementations.
These are two of the reasons I do not use STL containers.
That's sort of biting off your nose to spite your face, isn't
it. The standard provides a number of eminently usable
containers, which have the enormous advantage of being standard
(and thus, by definition, known to anyone knowing the language).
I have found that "being standard" does not carry as much weight as one
might expect. Even the venerable std::string is often forsaken for
something else. With STL, I see people using vector, list, map, maybe
a couple of other containers, and that's it. And as I mentioned above,
if you show someone something that makes them feel better as they are
using it, they will abandon that which they know if the change in mood
is significant enough. So , in a way, it might be the case that, in
getting so carried away with the mix-and-match philosophy of algorithms
and containers, STL shot itself in the foot.
Obviously, they don't do everything, but no other alternative
would, either. If I need something really special, I write it,
but most of the time, std::vector, std::string and std::deque do
the job more than adequately, regardless of what I might thing
concerning some of the details of the design. Similarly, I make
rather intensive use of std::map, even though if I had to write
my own, I'd use a hash table.
It's a mood thing I guess. I use containers so much in my code, the
thought of having to create an iterator every single time would be a
distraction.
-Le Chaud Lapin-
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]