Frequently Asked Questions

about the SGI Standard Template Library

Is the STL Y2K compliant?
Yes. The STL does not store or manipulate dates in any way, so there
are no year 2000 issues.

Can I download this entire site for offline viewing?
Yes. From the home page, go to the Download
the STL page. You will find links
for downloading the entire STL documentation as a single zip,
tar, or tar.gz file.

The documentation is a collection of HTML files. It
does not exist in the form of a single text or
PostScriptTM document. The
Other Resources page lists
several books about the STL.

Which compilers are supported?
The STL has been tested on these compilers: SGI 7.1 and later, or 7.0
with the -n32 or -64 flag; gcc 2.8 or egcs 1.x; Microsoft 5.0 and
later. (But see below.) Boris Fomitchev distributes a
port for
some other compilers.

If you succeed in using the SGI STL with some other compiler, please let us know, and please tell us what
modifications (if any) you had to make. We expect that most of the
changes will be restricted to the <stl_config.h> header.

What about older SGI compilers?
Given the rate of improvement in C++ implementations, SGI strongly
recommends that you upgrade your compiler. If this is not possible,
you might try the version of the STL for older Borland and Microsoft
compilers (see the Download the STL page), or Boris Fomitchev's
port. Neither
of these is supported.

How do I install the SGI STL?
You should unpack the STL include files in a new directory, and then
use the -I (or /I) option to direct the compiler to
look there first. We don't recommend overwriting the vendor's include
files.

At present the SGI STL consists entirely of header files. You don't have
to build or link in any additional runtime libraries.

Are there any compatibility issues with Visual C++?
Visual C++ provides its own STL implementation, and some of the other
Microsoft C++ library headers may rely on that implementation. In
particular, the SGI STL has not been tested in combination with
Microsoft's new <iostream> header. It has been used
successfully with the older <iostream.h> header.

Is the SGI STL thread safe?
Yes. However, you should be aware that not everyone uses the
phrase "thread safe" the same way. See our
discussion of thread safety
for our design goals.

Why is list<>::size() linear time?
The size() member function, for list and
slist, takes time proportional to the number of elements
in the list. This was a deliberate tradeoff. The only way to get a
constant-time size() for linked lists would be to maintain an
extra member variable containing the list's size. This would require
taking extra time to update that variable (it would make
splice() a linear time operation, for example), and it would
also make the list larger. Many list algorithms don't require that
extra word (algorithms that do require it might do better with vectors
than with lists), and, when it is necessary to maintain an explicit
size count, it's something that users can do themselves.

This choice is permitted by the C++ standard. The standard says that
size() "should" be constant time, and
"should" does not mean the same thing as "shall".
This is the officially recommended ISO wording for saying that an
implementation is supposed to do something unless there is a good
reason not to.

One implication of linear time size(): you should never write

if (L.size() == 0)
...

Instead, you should write

if (L.empty())
...

Why doesn't map's operator< use the map's
comparison function?
A map has a notion of comparison, since one of its template
parameters is a comparison function. However, operator<
for maps uses the elements' operator< rather than that
comparison function. This appears odd, but it is deliberate and we
believe that it is correct.

At the most trivial level, this isn't a bug in our implementation
because it's what's mandated by the C++ standard. (The behavior of
operator< is described in Table 65, in section 23.1.)

A more interesting question: is the requirement in the standard correct,
or is there actually a bug in the standard?

We believe that the requirements in the standard are correct.

First, there's a consistency argument: operator< for a
vector (or deque, or list) uses
the element's operator<. Should map's
operator< do something else, just because there is another
plausible way to compare objects? It's reasonable to say, for all
containers, that operator< always means
operator<, and that if you need a different kind of
comparison you can explicitly use lexicographical_compare.

Second, if we did use the map's comparison function,
there would be a problem: which one do we use? There are two
map arguments, and, while we know that their comparison
functions have the same type, we don't know that they have the same
behavior. The comparison function, after all, is a function object,
and it might have internal state that affects the comparison. (You
might have a function object to compare strings, for example, with a
boolean flag that determines whether the comparison is
case-sensitive.)

There's also a related question, incidentally: how should
operator== behave for sets? A set's comparison
function induces an equivalence relation, so, just as you can use the
set's comparison function for lexicographical ordering, you
could also use it for a version of equality. Again, though, we define
operator==(const set&, const set&) so that it just
calls the elements' operator==.

Why does a vector expand its storage by a factor of two
when it performs a reallocation?
Expanding a vector by a factor of two is a time-space tradeoff;
it means that each element will (on average) be copied twice
when you're building a vector one element at a time, and that
the ratio of wasted to used space is at most 1. (In general,
if the exponent for expansion is r, the worst case wasted/used ratio is
r - 1 and the number of times an element is copied approaches
r/(r - 1). If r = 1.25, for example, then elements are copied
five times instead of twice.)

If you need to control vector's memory usage more finely,
you can use the member functions capacity() and
reserve() instead of relying on automatic reallocation.

Why do the pop member functions return void?
All of the STL's pop member functions (pop_back in
vector, list, and deque;
pop_front in list, slist, and
deque; pop in stack,
queue, and priority_queue) return void,
rather than returning the element that was removed. This is for the
sake of efficiency.

If the pop member functions were to return the element
that was removed then they would have to return it by value rather
than by reference. (The element is being removed, so there wouldn't
be anything for a reference to point to.) Return by value, however,
would be inefficient; it would involve at least one unnecessary copy
constructor invocation. The pop member functions return
nothing because it is impossible for them to return a value in a way
that is both correct and efficient.

If you need to retrieve the value and then remove it, you can perform
the two operations explicitly. For example:

std::stack<T> s;
...
T old_value = s.top();
s.pop();

How do I sort a range in descending order instead of ascending?

sort(first, last, greater<T>());

(Note that it must be greater, not greater_eq. The
comparison function f must be one such that f(x, x)
is false for every x.)

Why am I getting uninitialized memory reads from PurifyTM?
We believe that the uninitialized memory read (UMR) messages in STL
data structures are artifacts and can be ignored.

There are a number of reasons the compiler might generate reads from
uninitialized memory (e.g. structure padding, inheritance from
empty base classes, which still have nonzero size). Purify tries to
deal with this by distinguishing between uninitialized memory reads
(UMR) and uninitialized memory copies (UMC). The latter are not
displayed by default.
The distinction between the two isn't completely clear, but appears to
be somewhat heuristic. The validity of the heuristic seems to depend
on compiler optimizations, etc. As a result, some perfectly
legitimate code generates UMR messages. It's unfortunately often hard
to tell whether a UMR message represents a genuine problem or just an
artifact.

Why does Bounds CheckerTM say that I have memory leaks?
This is not an STL bug. It is an artifact of certain kinds of leak detectors.

In the default STL allocator, memory allocated for blocks of small
objects is not returned to malloc. It can only be reused by
subsequent allocate requests of (approximately) the same
size. Thus programs that use the default may appear to leak memory
when monitored by certain kinds of simple leak detectors. This is
intentional. Such "leaks" do not accumulate over time. Such
"leaks" are not reported by garbage-collector-like leak
detectors.

The primary design criterion for the default STL allocator was to make
it no slower than the HP STL per-class allocators, but potentially
thread-safe, and significantly less prone to fragmentation. Like the
HP allocators, it does not maintain the necessary data structures to
free entire chunks of small objects when none of the contained small
objects are in use. This is an intentional choice of execution time
over space use. It may not be appropriate for all programs. On many
systems malloc_alloc may be more space efficient, and can be
used when that is crucial.

The HP allocator design returned entire memory pools when the entire
allocator was no longer needed. To allow this, it maintains a count of
containers using a particular allocator. With the SGI design, this
would only happen when the last container disappears, which is
typically just before program exit. In most environments, this would
be highly counterproductive; free would typically have to
touch many long unreferenced pages just before the operating system
reclaims them anyway. It would often introduce a significant delay on
program exit, and would possibly page out large portions of other
applications. There is nothing to be gained by this action, since the
OS reclaims memory on program exit anyway, and it should do so
without touching that memory.

In general, we recommend that leak detection tests be run with
malloc_alloc. This yields more precise results with GC-based
detectors (e.g. Pure Atria's PurifyTM),
and it provides useful results even with detectors that simply count
allocations and deallocations.