[34.1] Why should I use container classes rather than simple arrays?
Because arrays are evil.
Let's assume the best case scenario: you're an experienced C programmer, which
almost by definition means you're pretty good at working with arrays. You
know you can handle the complexity; you've done it for years. And you're
smart — the smartest on the team — the smartest in the whole company. But
even given all that, please read this entire FAQ and think very
carefully about it before you go into "business as usual" mode.
Fundamentally it boils down to this simple fact: C++ is not C. That means
(this might be painful for you!!) you'll need to set aside some of your hard
earned wisdom from your vast experience in C. The two languages simply are
different. The "best" way to do something in C is not always the same as the
"best" way to do it in C++. If you really want to program in C, please do
yourself a favor and program in C. But if you want to be really good at C++,
then learn the C++ ways of doing things. You may be a C guru, but if you're
just learning C++, you're just learning C++ — you're a newbie. (Ouch; I
know that had to hurt. Sorry.)
Here's what you need to realize about containers vs. arrays:
- Container classes make programmers more productive. So if you
insist on using arrays while those around are willing to use container
classes, you'll probably be less productive than they are (even if you're
smarter and more experienced than they are!).
- Container classes let programmers write more robust code. So if
you insist on using arrays while those around are willing to use container
classes, your code will probably have more bugs than their code (even if
you're smarter and more experienced).
- And if you're so smart and so experienced that you
can use arrays as fast and as safe as they can use container classes, someone
else will probably end up maintaining your code and they'll probably
introduce bugs. Or worse, you'll be the only one who can maintain your code
so management will yank you from development and move you into a full-time
maintenance role — just what you always wanted!
Here are some specific problems with arrays:
- Subscripts don't get checked to see if they are out of bounds.
(Note that some container classes, such as std::vector, have methods to
access elements with or without bounds checking on subscripts.)
- Arrays often require you to allocate memory from the heap (see
below for examples), in which case you must manually make sure the allocation
is eventually deleted (even when someone throws an exception). When you
use container classes, this memory management is handled automatically, but
when you use arrays, you have to manually write a bunch of code (and
unfortunately that code is often subtle and
tricky) to deal with this. For example, in addition to writing the code
that destroys all the objects and deletes the memory, arrays often also
force you you to write an extra try block with a catch clause that
destroys all the objects, deletes the memory, then re-throws the exception.
This is a real pain in the neck, as shown here.
When using container classes, things are much
- You can't insert an element into the middle of the array, or even
add one at the end, unless you allocate the array via the heap, and even then
you must allocate a new array and copy the elements.
- Container classes give you the choice of passing them by reference
or by value, but arrays do not give you that choice: they are always passed by
reference. If you want to simulate pass-by-value with an array, you have to
manually write code that explicitly copies the array's elements (possibly
allocating from the heap), along with code to clean up the copy when you're
done with it. All this is handled automatically for you if you use a
- If your function has a non-static local array (i.e., an "auto"
array), you cannot return that array, whereas the same is not true for objects
of container classes.
Here are some things to think about when using containers:
- Different C++ containers have different strengths and weaknesses,
but for any given job there's usually one of them that is better — clearer,
safer, easier/cheaper to maintain, and often more efficient — than an array.
- You might consider a std::map instead of manually writing code
for a lookup table.
- A std::map might also be used for a sparse array or sparse
- A std::vector is the most array-like of the standard container
classes, but it also offers various extra features such as bounds checking via
the at() member function, insertions/removals of elements, automatic memory
management even if someone throws an exception, ability to be passed both by
reference and by value, etc.
- A std::string is almost always
better than an array of char (you can think of a std::string as a
"container class" for the sake of this discussion).
- Container classes aren't best for everything, and sometimes
you may need to use arrays. But that should be very rare, and if/when it
- Please design your container class's public interface in such a
way that the code that uses the container class is unaware of the fact that
there is an array inside.
- The goal is to "bury" the array inside a container class. In other
words, make sure there is a very small number of lines of code that directly
touch the array (just your own methods of your container class) so everyone
else (the users of your container class) can write code that doesn't depend on
there being an array inside your container class.
To net this out, arrays really are evil. You may not
think so if you're new to C++. But after you write a big pile of code that
uses arrays (especially if you make your code leak-proof and exception-safe),
you'll learn — the hard way. Or you'll learn the easy way by believing
those who've already done things like that. The choice is yours.