100% found this document useful (2 votes)

893 views

Visual CPP Template Library

This tutorial provides an overview of the Standard C++ Libraries as implemented in Microsoft(r) Visual C++ version 4.2, with an emphasis on The Standard Template Library. Upon completion of this tutorial, you will be able to: Identify the different components of the standard C++ library.

Uploaded by

api-3738664

Available Formats

Download as DOC, PDF, TXT or read online on Scribd

100% found this document useful (2 votes)

893 views

Visual CPP Template Library

Uploaded by

api-3738664

Available Formats

Download as DOC, PDF, TXT or read online on Scribd

You are on page 1/ 142

Visual C++ 4.

2 Standard Template
Library Tutorial
Kalindi Sanghrajka, Rick Troemel, Nevenka Subotic-Burina, and Linda Koontz

October 1996

CONTENTS

1. About This Tutorial

2. Introduction to the Standard C++ Library

3. C++ Template Overview

4. The Standard Template Library

5. Sequence Containers

6. Associative Containers

7. Iterators

8. Container Adapters

9. The C++ String Class

10. Function Objects

11. Standard Template Library Algorithms

12. Standard C++ Library Language Support

13. Exception Handling

14. Standard C++ Library Diagnostics

15. Appendix A: STL References and Further Reading

16. Appendix B: STL Container Class Definitions

17. Appendix C: STL Container Class Methods

18. Appendix D: Allocator Class

1. About This Tutorial
1.1 Objectives

This tutorial will provide an overview of the Standard C++ Libraries as implemented in
Microsoft® Visual C++® version 4.2, with an emphasis on the Standard Template
Library. Upon completion of this tutorial, you will be able to:

• Identify the different components of the Standard C++ Library.

• Write simple programs using Visual C++ version 4.2. that use the Standard
Template Library components.

• Understand the Standard C++ Library implementation of exception handling and

language support in Visual C++ version 4.2.

1.2 Prerequisites

This tutorial assumes that you understand basic C++ programming. It is also necessary to
have a good understanding of C++ templates.

2. Introduction to the Standard C++ Library

2.1 Introduction

Every C++ programmer has probably, at one time or another, written a linked list or set,
searching and sorting routines. Most likely, the programmer has re-invented the wheel for
every new user-defined data type. Design changes are not easy to implement in such
cases. Maintaining such code is not very easy, either.

If the common programming components were part of the C++ language, programmers
would not need to "re-invent the wheel."

Finally, the C++ language provides you with general purpose components for common
programming tasks through the Standard C++ Library. The Standard C++ Library
provides powerful and flexible containers, programmable algorithms, and other
components that are efficient and extensible.

The facilities provided by the Standard C++ Library are as follows:

• Language support: Provides common type definitions used throughout the

library such as characteristics of predefined types, functions supporting start and
termination of C++ programs, support for dynamic memory allocation, support
for dynamic type identification, support for exception processing, and other run-
time support.
• Diagnostics: Includes components for reporting several kinds of exceptional
conditions, components for documenting program assertions, and a global
variable for error number codes.

• General utilities: Includes components used in other elements of the Standard

C++ Library. These components may also be used by any C++ programs. This
category also includes components used by the Standard Template Library (STL)
and function objects, dynamic memory management utilities, and date/time
utilities. This category also includes memory management components from the C
library.

• Strings: Includes components for manipulating sequences of characters, where

characters may be of type char, w_char, or of a type defined in a C++ program.
The library provides a class template, basic_string, that defines the basic
properties of strings. The string and wstring types are predefined template
instantiations provided by the library.

• Localization: Includes internationalization support for character classification

and string collation; numeric, monetary, and date/time formatting and parsing; and
message retrieval.

• The Standard Template Library (STL): Provides a C++ program access to the
most widely used algorithms and data structures. STL headers can be grouped into
three major organizing concepts: containers, iterators, and algorithms. Containers
are template classes that provide powerful and flexible ways to organize data: for
example, vectors, lists, sets and maps. Iterators are the glue that pastes together
algorithms and containers. STL provides a large set of programmable algorithms
to handle sorting, searching, and other common tasks.

• Numerics: Includes components to perform seminumerical operations and

components for complex number types, numeric arrays, generalized numeric
algorithms, and facilities included from the ISO C library.

• Input/output: Includes components for forward declarations of iostreams,

predefined iostream objects, base iostream classes, stream buffering, stream
formatting and manipulators, string streams, and file streams.

The Standard C++ Library also incorporates the Standard C Library.

2.2 Using the Standard C++ Libraries in Visual C++ 4.2

Microsoft® Visual C++® version 4.2 provides the Standard C++ Library facilities
through included files and associated static and dynamic libraries.

A C++ program can use the different components of the Standard C++ Library by
including the required header and linking with the appropriate static or dynamic library.
Tables 1 and 2 list all the Standard C++ Library headers and the associated static and
dynamic libraries provided by Visual C++ 4.2.

Table 1. The Standard C++ Library Headers

ALGORITHM BITSET CASSERT CCTYPE

CERRNO CFLOAT CISO646 CLIMITS
CLOCALE CMATH COMPLEX CSETJMP
CSIGNAL CSTDARG CSTDDEF CSTDIO
CSTDLIB CSTRING CTIME CWCHAR
CWCTYPE DEQUE EXCEPTION FSTREAM
FUNCTIONAL IOMANIP IOS IOSFWD
IOSTREAM ISTREAM ITERATOR LIMITS
LIST LOCALE MAP MEMORY
NEW NUMERIC OSTREAM QUEUE
SET SSTREAM STACK STDEXCEPT
STREAMBUF STRING STRSTREAM TYPEINFO
UTILITY VALARRAY VECTOR XIOSBASE
XLOCALE XLOCINFO XLOCMON XLOCNUM
XLOCTIME XMEMORY XSTDDEF XSTRING
XTREE XUTILITY

Note The Standard C++ Library headers do not have an “.h” extension. This is in
accordance with the latest C++ working papers.

Visual C++ 4.2 includes the following static and dynamic libraries (in addition to the
Microsoft Class Library [MFC]):

• Basic C run-time library

• Standard C++ Library from Plum Hall

• Old iostream library

Note With Visual C++ 4.2, the iostream support has been pulled out of the C run-time
library and exists as an independent entity. Now Visual C++ has the following libraries:

Table 2. Static and Dynamic Libraries Included with Microsoft Visual C++ 4.2

Library types and Basic C run-time Standard C++ Old iostream

related compiler library Library library
switches
Single Threaded (ML) LIBC.LIB LIBCP.LIB LIBCI.LIB
Multithreaded (MT) LIBCMT.LIB LIBCPMT.LIB LIBCIMT.LIB
Multithreaded DLL MSVCRT.LIB MSVCPRT.LIB MSVCIRT.LIB
version (MD) (import library for (also uses (import library for
MSVCRT.DLL) MSVCRT.DLL) MSVCIRT.DLL)
Debug Single Threaded LIBCD.LIB LIBCPD.LIB LIBCID.LIB
(MLd)
Debug Multithreaded LIBCMTD.LIB LIBCPMTD.LIB LIBCIMTD.LIB
(MTd)
Debug Multithreaded MSVCRTD.LIB MSVCPRTD.LIB MSVCIRTD.LIB
DLL (MDd) (import library for (also uses (import library for
MSVCRTD.DLL) MSVCRTD.DLL) MSVCIRTD.DLL)

Case 1. Consider the following sample C++ program where test.cpp uses the Standard
C++ Library iostream to print "Hello World".

// test.cpp
#include <iostream>
void main()
{
cout << "Hello World" << endl ;
}

Building test.cpp using Will cause test.cpp to link with

cl /ML /GX test.cpp LIBC.LIB, LIBCP.LIB
cl /MLd /GX test.cpp LIBCD.LIB, LIBCPD.LIB
cl /MT /GX test.cpp LIBCMT.LIB, LIBCPMT.LIB
cl /MTd /GX test.cpp LIBCMTD.LIB, LIBCPMTD.LIB
cl /MD /GX test.cpp MSVCRT.LIB, MSVCPRT.LIB
cl /MDd /GX test.cpp MSVCRTD.LIB, MSVCPRTD.LIB

In Case 1, test.cpp used the Standard C++ Library input/output component to print "Hello
World." The program just includes the Standard C++ Library header <iostream>. When
compiling the program, specify a run-time library option: /ML[d],/MT[d], or /MD[d]. The
program will then link with a basic run-time library (for example, LIBC.LIB with the
/ML option) and a Standard C++ Library (for example, LIBCP.LIB with the /ML option).
The /GX option enables exception handling. Exception handling must be enabled for any
programs that use the Standard C++ Library.

It is important to remember that starting with Visual C++ 4.2, a C++ program, depending
on the run-time library compiler option specified (/ML[d],/MT[d], or /MD[d]), will
always link with one Basic C run-time library and, depending on headers included, will
link with either a Standard C++ Library (as in the case 1), an old iostream library (as in
Case 3), or neither (as in Case 2).

Case 2. Consider the following sample program:

// test.cpp
void main()
{
}

Building test.cpp using Will cause test.cpp to link with

cl /ML test.cpp LIBC.LIB
cl /MLd test.cpp LIBCD.LIB
cl /MT test.cpp LIBCMT.LIB
cl /MTd test.cpp LIBCMTD.LIB
cl /MD test.cpp MSVCRT.LIB
cl /MDd test.cpp MSVCRTD.LIB

Case 3. Consider the following sample program:

// test.cpp
#include <iostream.h>
void main()
{
}

Building test.cpp using Will cause test.cpp to link with

cl /ML test.cpp LIBC.LIB, LIBCI.LIB
cl /MLd test.cpp LIBCD.LIB, LIBCID.LIB
cl /MT test.cpp LIBCMT.LIB, LIBCIMT.LIB
cl /MTd test.cpp LIBCMTD.LIB, LIBCIMTD.LIB
cl /MD test.cpp MSVCRT.LIB, MSVCIRT.LIB
cl /MDd test.cpp MSVCRTD.LIB, MSVCIRTD.LIB

3. C++ Template Overview

3.1 Introduction

Many C++ programs use common data structures such as stacks, queues, and lists.
Imagine a program that requires a queue of customers and a queue of messages. You
could easily implement a queue of customers, and then take the existing code and
implement a queue of messages. If the program grows and there is a need for a queue of
orders you could take the queue of messages and convert it to a queue of orders. But what
if you need to make some changes to the queue implementation? This would not be a
very easy task because the code has been duplicated in many places. Re-inventing source
code is not an intelligent approach in an object-oriented environment that encourages re-
usability. It seems to make more sense to implement a queue that can contain any
arbitrary type rather than duplicating code. How does one do that? The answer is to use
Type Parameterization, more commonly referred to as Templates.

C++ templates allow one to implement a generic Queue<T> template that has a T type
parameter. T can be replaced with actual types. For example, if the type parameter is
<Customers>, C++ will generate the class Queue<Customers>. Therefore, changing the
implementation of the Queue becomes relatively simple. In our example, once the
changes are implemented in the template Queue<T>, they are immediately reflected in
the classes Queue<Customers>, Queue<Messages>, and Queue<Orders>.

Templates are very useful when implementing generic constructs such as vectors, stacks,
lists, and queues that can be used with any arbitrary type. C++ templates provide a way to
reuse source code, as opposed to inheritance and composition, which provide a way to
reuse object code.

C++ provides two types of templates: class templates and function templates. Use
function templates to write generic functions: for example, searching and sorting routines
that can be used with arbitrary types. The Standard Template Library generic algorithms
have been implemented as function templates and the containers have been implemented
as class templates.
3.2 Class Templates

3.2.1 Implementing a class template

A class template definition looks like a regular class definition, except it is prefixed by
the keyword template. For example, here is the definition of a class template for a stack:

template <class T>

class Stack

{
public:
Stack(int = 10) ;
~Stack() { delete [] stackPtr ; }
int push(const T&);
int pop(T&) ;
int isEmpty()const { return top == -1 ; }
int isFull() const { return top == size - 1 ; }
private:
int size ; // number of elements on Stack.
int top ;
T* stackPtr ;
} ;

T is any type parameter, for example, Stack<Tokens>, where Token is a user defined
class. T does not have to be a class type as implied by the keyword class. For example,
Stack<int> and Stack<Message*> are valid instantiations, even though int and
Message* are not classes.

3.2.2 Implementing class template member functions

Implementing template member functions is somewhat different than implementing the

regular class member functions. The declarations and definitions of the class-template
member functions should all be in the same header file. Why do the declarations and
definitions need to be in the same header file? Consider the following:

//B.h // B.cpp //main.cpp

template <class t> #include “B.h” #include “B.h”
class b template <class t> void main()
{ b<t>::b() {
public: { b<int> bi ;
b() ; } b <float> bf ;
~b() ; template <class t> }
} ; b<t>::~b()
{
}
When compiling B.cpp, the compiler has both the declarations and the definitions
available. At this point, the compiler does not need to generate any definitions for
template classes, since there are no instantiations. When the compiler compiles main.cpp,
there are two instantiations: template classes B<int> and B<float>. At this point, the
compiler has the declarations but no definitions!

While implementing class-template member functions, the definitions are prefixed by the
keyword template. Here is the complete implementation of the Stack class template:

//stack.h
#pragma once

template <class T>

class Stack

{
public:
Stack(int = 10) ;
~Stack() { delete [] stackPtr ; }
int push(const T&);
int pop(T&) ; // pop an element off the stack
int isEmpty()const { return top == -1 ; }
int isFull() const { return top == size - 1 ; }
private:
int size ; // Number of elements on Stack
int top ;
T* stackPtr ;
} ;

//Constructor with the default size 10

template <class T>

Stack<T>::Stack(int s)

{
size = s > 0 && s < 1000 ? s : 10 ;
top = -1 ; // initialize stack
stackPtr = new T[size] ;
}

//Push an element onto the Stack.

template <class T>

int Stack<T>::push(const T& item)

{
if (!isFull())
{
stackPtr[++top] = item ;
return 1 ; // push successful
}
return 0 ; // push unsuccessful
}

//Pop an element off the Stack.

template <class T>

int Stack<T>::pop(T& popValue)

{
if (!isEmpty())
{
popValue = stackPtr[top--] ;
return 1 ; // pop successful
}
return 0 ; // pop unsuccessful
}

3.2.3 Using a class template

Using a class template is very easy. Create the required classes by plugging in the actual
type for the type parameters. This process is commonly known as instantiating a class.
Here is a sample driver class that uses the Stack class template:

#include <iostream>
#include “stack.h”
void main()
{
typedef Stack<float> FloatStack ;

typedef Stack<int> IntStack ;

FloatStack fs(5) ;
float f = 1.1 ;
cout << "Pushing elements onto fs" << endl ;
while (fs.push(f))
{
cout << f << ' ' ;
f += 1.1 ;
}
cout << endl << "Stack Full." << endl
<< endl << "Popping elements from fs" << endl ;
while (fs.pop(f))
cout << f << ' ' ;
cout << endl << "Stack Empty" << endl ;
cout << endl ;
IntStack is ;
int i = 1.1 ;
cout << "Pushing elements onto is" << endl ;
while (is.push(i))
{
cout << i << ' ' ;
i += 1 ;
}
cout << endl << "Stack Full" << endl
<< endl << "Popping elements from is" << endl ;
while (is.pop(i))
cout << i << ' ' ;
cout << endl << "Stack Empty" << endl ;
}

Here is the output:

Pushing elements onto fs

1.1 2.2 3.3 4.4 5.5
Stack Full.
Popping elements from fs
5.5 4.4 3.3 2.2 1.1
Stack Empty
Pushing elements onto is
1 2 3 4 5 6 7 8 9 10
Stack Full
Popping elements from is
10 9 8 7 6 5 4 3 2 1
Stack Empty

In the above example we defined a class template Stack. In the driver program we
instantiated a Stack of float (FloatStack) and a Stack of int(IntStack). Once the
template classes are instantiated, you can instantiate objects of that type (for example, fs
and is.)

A very good programming practice is to use typedef while instantiating template classes.
Then throughout the program, one can use the typedef name. There are two advantages:

• typedefs are very useful when “templates of templates” are used. For example,
when instantiating an int STL vector, you could use:
• typedef vector<int, allocator<int> > INTVECTOR ;
• If the template definition changes, simply change the typedef definition.

This practice is especially helpful when using STL components. There are many
implementations of STL available, some of which are incompatible. The implementation
in Visual C++ 4.2 may change in future versions. For example, currently the definition of
the vector required you to specify an allocator parameter:

typedef vector<int, allocator<int> > INTVECTOR ;

INTVECTOR vi1 ;

In a future version, the second parameter may not be required, for example,

typedef vector<int> INTVECTOR ;

INTVECTOR vi1 ;

Imagine how many changes would be required if there was no typedef!

3.3 Sharing Data Using Static Members

Each instantiation of a class template has it’s own static members that are shared with
other objects of that instantiation. This is true of static data members and static member
functions.

3.4 Function Templates

To perform identical operation for each type of data compactly and conveniently, use
function templates. You can write a single function template definition. Based on the
argument types provided in calls to the function, the compiler automatically instantiates
separate object code functions to handle each type of call appropriately. The STL
algorithms are implemented as function templates.

Function templates are implemented like regular functions, except they are prefixed with
the keyword template. Using function templates is very easy; just use them like regular
functions. Here is a sample with a function template:

#include <iostream>
//max returns the maximum of the two elements
template <class T>
T max(T a, T b)
{
return a > b ? a : b ;
}
void main()
{

cout << "max(10, 15) = " << max(10, 15) << endl ;
cout << "max('k', 's') = " << max('k', 's') << endl ;
cout << "max(10.1, 15.2) = " << max(10.1, 15.2) << endl ;
}

Here is the output:

max(10, 15) = 15
max('k', 's') = s
max(10.1, 15.2) = 15.2

3.5 Template Specialization

In some cases it is possible to override the template-generated code by providing special

definitions for specific types. This is called template specialization. For example:

#include <iostream.h>
//max returns the maximum of the two elements of type T, where T is a
//class or data type for which operator> is defined.
template <class T>
T max(T a, T b)
{
return a > b ? a : b ;
}
void main()
{
cout << "max(10, 15) = " << max(10, 15) << endl ;
cout << "max('k', 's') = " << max('k', 's') << endl ;
cout << "max(10.1, 15.2) = " << max(10.1, 15.2) << endl ;
cout << "max(\"Aladdin\", \"Jasmine\") = " << max("Aladdin",
"Jasmine") << endl ;
}

Here is the output:

max(10, 15) = 15
max('k', 's') = s
max(10.1, 15.2) = 15.2
max("Aladdin", "Jasmine") = Aladdin

Not quite the expected results! Why did that happen? The function call max(“Aladdin”,
“Jasmine”) causes the compiler to generate code for max(char*, char*), which compares
the addresses of the strings! To correct special cases like these or to provide more
efficient implementations for certain types, one can use template specializations. The
above example can be rewritten with specialization as follows:

#include <iostream.h>
#include <string.h>
//max returns the maximum of the two elements
template <class T>
T max(T a, T b)
{
return a > b ? a : b ;
}
// Specialization of max for char*
char* max(char* a, char* b)
{
return strcmp(a, b) > 0 ? a : b ;
}
void main()
{

cout << "max(10, 15) = " << max(10, 15) << endl ;
cout << "max('k', 's') = " << max('k', 's') << endl ;
cout << "max(10.1, 15.2) = " << max(10.1, 15.2) << endl ;
cout << "max(\"Aladdin\", \"Jasmine\") = " << max("Aladdin",
"Jasmine") << endl ;
}

Here is the output:

max(10, 15) = 15
max('k', 's') = s
max(10.1, 15.2) = 15.2
max("Aladdin", "Jasmine") = Jasmine

3.6 Templates and Friends

Friendship can be established between a class template and a global function, a member
function of another class (possibly a template class), or even an entire class (possibly a
template class). Table 3 lists the results of declaring different kinds of friends of a class:

Table 3. Friend Declarations

Class Template Friend declaration in class Result of giving

template X friendship
template class <T> class friend void f1() ; makes f1() a friend of all
X instantiations of template
X. For example, f1() is a
friend of X<int>, X<A>,
and X<Y>.
template class <T> class friend void f2(X<T>&) ; For a particular type T for
X example, float, makes
f2(X<float>&) a friend of
class X<float> only.
f2(x<float>&) cannot be a
friend of class X<A>.
template class <T> class friend A::f4() ; makes A::f4() a friend of
X all instantiations of
// A is a user defined template X. For example,
class A::f4() is a friend of
X<int>, X<A>, and X<Y>.
//with a

//member function f4() ;

template class <T> class friend C<T>::f5(X<T>&) ; A particular type T (for
X example, float) makes
// C is a class C<float>::f5(X<float>&)
a friend of class X<float>
// template only.
C<float>::f5(x<float>&)
// with a member cannot be a friend of class
X<A>.
// function f5
template class <T> class friend class Y ; makes every member
X function of class Y a friend
of every template class
produced from the class
template X.
template class <T> class friend class Z<T> ; when a template class is
X instantiated with a
particular type T, such as a
float, all members of class
Z<float> become friends
of template class X<float>.

3.7 Class Templates and Nontype Parameters

The Stack class template, described in the previous section, used only type parameters in
the template header. It is also possible to use nontype parameters. For example, the
template header could be modified to take an int elements parameter as follows:

template <class T, int elements>

class Stack ;

Then, a declaration such as:

Stack<float, 100> mostRecentSalesFigures ;

could instantiate (at compile time) a 100 element Stack template class named
mostRecentSalesFigures (of float values); this template class would be of type
Stack<float, 100>.

3.8 Default Template Parameters

Let us look at the Stack class template again:

template <class T, int elements> Stack { ....} ;

C++ allows you to specify a default template parameter, so the definition could now look
like:

template <class T = float, int elements = 100> Stack { ....} ;

Then a declaration such as:

Stack<> mostRecentSalesFigures ;

would instantiate (at compile time) a 100 element Stack template class named
mostRecentSalesFigures (of float values); this template class would be of type
Stack<float, 100>.
If you specify a default template parameter for any formal parameter, the rules are the
same as for functions and default parameters. Once a default parameter is declared, all
subsequent parameters must have defaults.

3.9 Member Templates

The following example demonstrates member templates. When you define a class
template or a function template as a member of a class, it is called a member template.
Visual C++ 4.2 does not support member templates.

class MyAllocator
{
int size ;
template class<T> class types; // member class template
template class<T> print(T type) ; // member function template
} ;

4. The Standard Template Library

4.1 Introduction

The Standard Template Library is a part of the Standard C++ Library. Every C++
programmer at one time or another has implemented common data structures such as a
list or queue, and common algorithms such as binary search, sort, and so on. Through
STL, C++ gives programmers a set of carefully designed generic data structures and
algorithms. The generic data structures and algorithms are parameterized types
(templates) that require only plugging in of actual types to be ready for use. Finally, STL
brings to C++ the long promised dream of re-usable software components.

The STL components are well crafted solutions, which are efficient in code space and
execution time.

4.2 STL Components

• Containers are objects that hold other objects.

The sequential containers include vector, list, and deque.

The associative containers include map, multimap, set, and multiset.

• Algorithms are generic functions that handle common tasks such as searching,
sorting, comparing, and editing.

Find, search, merge, count, reverse, and sort, are some of the algorithms provided
by STL. For a complete list of algorithms refer to the documentation.
• Iterators are generalized pointers and act as the glue between containers and
algorithms. STL algorithms are written in terms of iterator parameters, and STL
containers provide iterators that can be plugged into the algorithms.

STL provides the following iterators: input, output, forward, bidirectional and
random access, ostream_iterator, and istream_iterator.

• Function objects are objects of any class or struct that overload the function call
operator(). Most STL algorithms accept a function object as a parameter that can
change the default behavior of the algorithm.

STL defines function objects for basic arithmetic operations such as addition,
subtraction, multiplication, and division. The associated function object types are
plus, minus, times, and divides.

STL also provides function objects for built-in operations such as unary, logical,
bitwise, and comparison operators. The associated function object types are
modulus, negate, equal_to, not_equal_to, greater, less, greater_equal,
less_equal, logical_and, logical_or, and logical_not.

• Adapter is a component that modifies the interface of another component. For

example, reverse_iterator is a component that adapts an iterator type into a new
type of iterator with all the capabilities of the original, but with the same direction
of traversal reversed. STL provides three kind of adapters: Container Adapter,
Iterator Adapter, and Function Adapters.

• Container adapters provided by STL include stack, queue, and priority_queue.

• Iterator adapters provided by STL include reverse iterators,

reverse_bidirectional_iterator, back_insert_iterator, front_insert_iterator, and
insert_iterator.

• Function adapters provided by STL include not1, not2, bind1st, and bind2nd.

These very general components are designed to "plug together" in myriad different useful
ways to produce the kind of larger and more specialized components required by
programs.

4.3 General Rules About STL and User-Defined Data Types

• When an object is used with an STL container, it is copied (the copy constructor is
called) first and the copy is what is actually inserted into the container.

This means an object held by an STL container must have a copy constructor.
• When an object is removed from an STL container, the object is destroyed (the
destructor is called).

• When an STL container is destroyed, it destroys all objects it currently holds.

• Many STL components rely on making comparisons of the objects they hold (<,
<=, >, >=, ==, !=).

This means the comparison operators must be defined for objects used with an
STL component.

• Some STL components modify the value of an object. This is accomplished using
the assignment operator.

This means the assignment operator ( = ) must be defined for objects used with an
STL component.

The header file <utility> defines global versions of the <=, >, >=, and != operators, which
are all defined in terms of the < and ==. Therefore, if only the < and == operators are
defined, the rest are defined "for free" (if any of the rest are explicitly defined for an
object, the explicit definition will override the global definition).

In general, it is assumed that objects to be used with STL containers have at least the
following:

• A copy constructor.

• An assignment operator ( = ).

• An equality comparison operator ( == ).

• A less than comparison operator ( < ).

5. Sequence Containers
Sequence containers store and retrieve their data in a sequential fashion. There are three
different sequence containers defined in STL: vector, deque and list.

5.1 Vector
#include <vector>
vector<class TYPE, allocator<class TYPE> >

A vector is similar to a normal C array, except that it can change size automatically as
needed. Data access or modification is random and can be accomplished via operator[].
Insertion or erasure is efficient at the end only. Insertion or erasure of data at the
beginning or in the middle requires shifting the entire array. Therefore, insertion or
erasure anywhere but at the end is a linear operation, meaning that the time to execute the
operation is a function of the number of elements that must be shifted right or left.
Insertion or erasure at the end is a constant operation, meaning that the time to execute
the operation will remain unchanged regardless of how many (or how few) elements are
in the array.

The following function declares a vector of 10 ints, fills the vector with the values 0 - 9,
and then prints the values.

typedef vector<int, allocator<int> > INTVECT;

void somefunct()
{
// declare an INTVECT with slots for 10 ints
INTVECT myVector(10);
int i;

for(i = 0; i < 10; i++) // fill myVector with the values 0 - 9

myVector[i] = i;

for(i = 0; i < 10; i++) // print the values in myVector

cout << myVector[i] << ", ";
cout << endl;
}

Output of somefunct:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9,

See APPENDIX B for the vector class definition.

See APPENDIX C for a table of vector methods.

See APPENDIX D for an explanation of the allocator class (second template parameter
above).

5.2 Deque
#include <deque>
deque<class TYPE, allocator<class TYPE> >

A deque is similar to a vector, except that insertion or erasure is efficient at either the
beginning or the end. Like a vector, data access or modification is random and can be
accomplished via operator[]. Insertion or erasure at either the beginning or the end is a
constant operation, meaning that the time to execute the operation will remain the same,
regardless of how many elements are in the array. Insertion or erasure anywhere in the
middle is a linear operation, meaning that the time to execute the operation is a function
of the number of items that must be shifted right or left. A deque will generate larger,
slower code than a vector. In general, a vector should be used if efficient insertion/erasure
at the beginning of the array is not required and a deque should be used if it is.

The following function declares a deque of ints, fills the deque with the values 0-9,
inserting each new value at the beginning, then prints the values.

typedef deque<int, allocator<int> > INTDQ;

void somefunct()
{
INTDQ myDeque; // declare a deque of ints
int i;
for(i = 9; i >= 0; i--)
myDeque.push_front(i);

for(i = 0; i < 10; i++)

cout << myDeque[i] << ", ";
cout << endl;
}

Output of somefunct:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9,

• See APPENDIX B for the deque class definition.

• See APPENDIX C for a table of deque methods.

• See APPENDIX D for an explanation of the allocator class (second template

parameter above).

5.3 List
#include <list>
list<class TYPE, allocator<class TYPE> >

A list, like a vector or a deque, is an extensible array. Lists are implemented as doubly
linked lists. Therefore, insertion or erasure at any point in the array is a constant
operation, meaning that the time to execute the operation will remain the same, regardless
of how many elements are in the list. The penalty for using a list instead of a vector or a
deque is paid in data access. There is no random access (no operator[]) for a list, meaning
that accessing the nth object in a list requires "surfing" from the beginning of the list
through N-1 objects. The following function declares a list of ints, fills the list with the
values 0-9, inserting each new value at the beginning, and then prints the values.

typedef list<int, allocator<int> > INTLIST;

void somefunct()
{
INTLIST myList; // declare a list of ints
INTLIST::iterator myListPtr; // and an iterator
int i;
for(i = 9; i >= 0; i--)
myList.push_front(i);

for(myListPtr = myList.begin(); myListPtr != myList.end();

myListPtr++)
cout << *myListPtr << ", ";
cout << endl;
}

Output of somefunct:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9,

• See APPENDIX B for the list class definition.

• See APPENDIX C for a table of list methods.

• See APPENDIX D for an explanation of the allocator class (second template

parameter above).

6. Associative Containers
Associative containers store and retrieve their objects according to an association with
each other. In other words, the data is stored and retrieved in a sorted order. Therefore,
associative containers rely heavily upon comparison operators. There are four different
associative containers defined in the STL. They are: set, multiset, map and multimap.

6.1 Set and Multiset

#include <set>
set<TYPE, PREDICATE, ALLOCATOR>

A set is optimized for fast associative lookup. For lookup purposes, objects are matched
using operator==. Objects are ordered within the set according to the user-defined
comparator object (the second template argument). The comparator object is typically
"less<TYPE>", which causes the data to be sorted in ascending order. Each object in a set
has a unique value, as duplicate objects are not allowed. A multiset is similar to a set,
except that a multiset can contain objects with duplicate values.

The following function declares a set of ints, fills it with 10 random values, then prints
them:

typedef set<int, less<int>, allocator<int> > INTSET;

void somefunct()
{
INTSET mySet; // declare a set of ints
INTSET::iterator mySetPtr; // and an iterator for
the set
int tmpVal;

srand(13); // seed the rand function

// fill the set with 10 random ints - print them as they are
added.
for(int i = 0; i < 9; i++){
tmpVal = rand();
cout << tmpVal << ", ";
mySet.insert(tmpVal);
}
cout << endl;

// print the contents of the set (note the values are

sorted)
for(mySetPtr = mySet.begin(); mySetPtr != mySet.end();
mySetPtr++)
cout << *mySetPtr << ", ";

cout << endl;

}

Output of somefunct:

81, 16376, 24096, 20348, 11872, 30076, 16059, 26999, 28493,

81, 11872, 16059, 16376, 20348, 24096, 26999, 28493, 30076,

• See APPENDIX B for the set and multiset class definitions.

• See APPENDIX C for a table of set and multiset methods.

• See APPENDIX D for an explanation of the allocator class (third template

parameter above).

6.2 Map and Multimap

#include <map>
map<KEY, TYPE, PREDICATE, ALLOCATOR>

A map holds a set of ordered key/value pairs. The pairs are ordered by key, based upon
the user-defined comparator object (3rd template parameter). A map defines a one-to-
one relationship, allowing only one value to be associated with a particular key; a
multimap defines a one-to-many relationship, allowing many values to be associated with
a particular key.

The following declares a map of ints to strings, fills it with 10 key/value pairs and prints
them:

typedef map<int, string, less<int>, allocator<string> > INT2STRING;

void somefunct()
{
INT2STRING myMap;
INT2STRING::iterator i2sPtr;

// Fill myMap with the digits 9 - 0 in reverse order,

// each mapped to its character string counterpart
myMap.insert(INT2STRING::value_type(9,"Nine"));
myMap.insert(INT2STRING::value_type(8,"Eight"));
myMap.insert(INT2STRING::value_type(7,"Seven"));
myMap.insert(INT2STRING::value_type(6,"Six"));
myMap.insert(INT2STRING::value_type(5,"Five"));
myMap.insert(INT2STRING::value_type(4,"Four"));
myMap.insert(INT2STRING::value_type(3,"Three"));
myMap.insert(INT2STRING::value_type(2,"Two"));
myMap.insert(INT2STRING::value_type(1,"One"));
myMap.insert(INT2STRING::value_type(0,"Zero"));

// Now print the pairs - note they are now sorted

// into ascending order...
for(i2sPtr = myMap.begin(); i2sPtr != myMap.end();
i2sPtr++)
cout << "(" << (*i2sPtr).first << ", "
<< (*i2sPtr).second << “)” << endl;
}

Output of somefunct:

(0, Zero)
(1, One)
(2, Two)
(3, Three)
(4, Four)
(5, Five)
(6, Six)
(7, Seven)
(8, Eight)
(9, Nine)

• See APPENDIX B for the map and multimap class definitions

• See APPENDIX C for a table of map and multimap methods

• See APPENDIX D for an explanation of the allocator class (fourth template

parameter above)

7. Iterators
Iterators are generalized pointers that may be used to traverse the contents of a sequence
(for example, an STL container or a C++ array).

• Iterators provide data access for both reading and writing data in a sequence.

• A C++ pointer is an iterator, but an iterator is not necessarily a C++ pointer.

• Iterators, like pointers can be dereferenced, incremented and decremented.

• At any point in time, an iterator is positioned at exactly one place in one

collection, and remains positioned there until explicitly moved.

7.1 Types of Iterators

7.1.1 Table of iterator categories

There are five categories of iterators. With the exception of input and output iterators, the
relationship between each category of iterator is hierarchical: each iterator inherits the
characteristics and behavior of the previous type, as Table 4 illustrates:

Table 4. Iterator Categories and Characteristics

Iterator category Characteristics

input Can read one item at a time; can only move forward (increment)
output Can write one item at a time; can only move forward (increment)
forward Multiply derived from input and output iterators; combines their
characteristics (read or write)
bidirectional Derived from forward iterator; adds ability to move backwards
(decrement)
random access Derived from bidirectional; adds ability to jump forward or
backward by an arbitrary distance

In classical C++ terms, input and output iterator classes are base classes, the forward
iterator class is doubly derived from both the input and output iterator classes, the
bidirectional iterator class is derived from the forward iterator class, and the random
access iterator class is derived from the bidirectional iterator class. This hierarchy implies
the following:

• An algorithm that requires only input or output iterators can also be used with
forward, bidirectional, or random access iterators.

• An algorithm that can be used with forward iterators can also be used with
bidirectional or random access iterators.

• An algorithm that can be used with bidirectional iterators can also be used with
random access iterators.
It should also be noted that regular C++ pointers fit the characteristics of a random access
iterator (and in fact can be used as a random access iterator for STL operations that
support random access iterators).

7.2 Iterator Interface Requirements

Different iterator types are required to have a minimum set of interface functions defined,
which conform to the behaviors described below. For the following, the value type T is
understood to be the data type of the underlying container that the iterator is interfacing
with (for example, for a vector<int, allocator<int> >, T = int).

7.2.1 Input iterator interface requirements

A class or built-in data type X can be used as an input iterator for the value type T if and
only if the following expressions are defined for X and meet the behavioral requirements
stated below. For Table 5, assume a and b are values of type X, r is a reference of type X,
and t is a value of type T.

Table 5. Input Iterator Required Behaviors

Operator/function Required behavior

Copy Constructor X(a) == a

X b(a) must result in a == b

operator= X b = a and a = b both must result in a == b
operator== The return type must be convertible to bool and ‘==’ must be an
equality relation (such as reflexive, transitive, or associative.)
operator!= The return type must be convertible to bool and a != b must be the
same as !(a == b)
operator* The return type must be convertible to T. If a == b then *a == *b.
Dereferencing an input stream returns a read-only reference of type
T. This means that operator* can only appear on the right-hand side
of an assignment statement (is an rvalue). t = *a results in t being
assigned a value through a.
operator++ The return type must be convertible to type const X&. It is also
(prefix) assumed that the return type is dereferenceable or is the “past-the-
end” value of the container.
operator++(int) The return must be convertible to type const X&. The result must be
(postfix) identical to
{X tmp = r; ++r; return tmp; }.

7.2.2 Output iterator interface requirements

A class or built-in data type X can be used as an output iterator for the value type T if and
only if the following expressions are defined for X and meet the behavioral requirements
stated below. For Table 6, assume a and b are values of type X, r is a reference of type X,
and t is a value of type T.

Table 6. Output Iterator Required Behavior

Operator/function Required behavior

Copy Constructor *a = t and *X(a) = t. The result of X b(a) is that b is a copy of a
(Note that equality and inequality are not necessarily defined for
output iterators).
operator= The result of X b = a is that b is a copy of a.
operator* *a = t results in the value of t being written to the location referenced
by a. The return value of the operation is meaningless. Note that the
only valid use of operator* on output iterators is on the left-hand
side of an assignment (as an lvalue).
operator++ The return type must be convertible to type const X&. It is also
(prefix) assumed that the return type is dereferenceable or is the “past-the-
end” value of the container.
operator++(int) The return type must be convertible to type const X&. The result
(postfix) must be identical to:
{X tmp = r; ++r; return tmp; }

7.2.3 Forward iterator interface requirements

A class or built-in data type X can be used as a forward iterator for the value type T if and
only if the following expressions are defined for X, and meet the behavioral requirements
stated below. For Table 7, assume a and b are values of type X, t is a value of type T, and
r and s are references of type X.

Table 7. Forward Iterator Required Behavior

Operator/function Required behavior

Default X() and X a both create an iterator whose position is undefined
Constructor
Copy Constructor X(a) == a and X b(a) must result in a == b
operator= X b = a and a = b must result in a == b
operator== The return type must be convertible to bool, and ‘==’ must be an
equality relation (reflexive, transitive, associative, etc.)
operator!= The return type must be convertible to bool, and a != b must be the
same as !(a == b)
operator* The return type must be convertible to T. If a == b, then *a == *b. If
X is mutable (writable), then *a = t is valid and results in the value
of t being written to the location referenced by a.
operator++ The return type must be convertible to type const X&. It is also
(prefix) assumed that the return type is dereferenceable or is the “past-the-
end” value of the container. In addition, r == s implies that ++r ==
++s.
operator++(int) The return type must be convertible to type const X&. The result
(postfix) must be identical to:
{X tmp = r; ++r; return tmp; }

7.2.4 Bidirectional iterator interface requirements

A class or built-in data type X can be used as a bidirectional iterator for the value type T
if and only if X conforms to the requirements of a forward iterator and defines the
following expressions, which meet the behavioral requirements stated below. For Table 8,
assume r and s are references of type X.

Table 8. Bidirectional Iterator Required Behavior

Operator/function Required behavior

operator-- The return type must be convertible to type const X&. In addition,
(prefix) the following properties must hold: --(++r) == r, and r == s implies
that --r == --s.
operator--(int) The return type must be convertible to type const X&. The result
(postfix) must be identical to:
{X tmp = r; --r; return tmp;}
7.2.5 Random Access Iterator Interface Requirements

A class or built-in data type X can be used as a random access iterator for the value type
T if and only if X conforms to the requirements of a bidirectional iterator and defines the
following expressions, which meet the behavioral requirements stated below. For Table 9,
assume a and b are values of type X, r is a reference of type X, and n is an int.

Table 9. Random Access Iterator Required Behavior

Operator/function Required behavior

operator+= The return type must be convertible to X&. The result of r += n must
be the same as computing ‘r++’ n times if n > 0 or ‘r--‘ abs(n) times
if n < 0 (trivially, r+=0 == 0).
operator+ The return type must be convertible to X. The result of a + n must be
identical to:
{X tmp = a; return tmp += n; }. The result of n + a must be the same
as a + n (reflexive).
operator-= The return type must be convertible to X&. The result of r -= n must
be the same as the result of r += (-n)
operator- The result of a - n must be convertible to X, and identical to {X tmp =
a;
return tmp -= n; }. The result of a - b must be convertible to an
integral type that can describe the difference between two locations
(difference_type). If a - b = n, then:
a + n = b;
operator[] The return type must be convertible to T. The result of a[n] must be
identical to *(a + n).
operator< The return type must be convertible to bool and operator< must be a
total ordering relation
operator> The return type must be convertible to bool. The result of a > b must
be identical to:
a < b.
operator>= The return type must be convertible to bool. The result of a >= b
must be identical to:
!(a < b).
operator<= The return type must be convertible to bool. The result of a <= b
must be identical to:
!(a > b).
Note STL provides global definitions of ">," ">=," "<=," and "!=" defined in terms of
"==" or "<". This means that any object which defines "==" and "<" gets the rest “for
free.”

7.3 Categories of Iterators Associated With STL Containers

The description of each STL container class includes the category of iterator types they
provide. Table 10 lists the various STL containers and the iterators associated with each:

Table 10. STL Containers and Iterators

STL container Type of iterator

vector random access
deque random access
list bidirectional
multiset bidirectional
set bidirectional
multimap bidirectional
map bidirectional

It is not necessary to remember which type of iterator works with which container. Each
container, C<T>, supplies typedefs for iterators:

• iterator (mutable)

• const_iterator (nonmutable)

To declare an iterator, simply use the syntax C<T>::iterator or C<T>::const_iterator (see

example below).

The following example illustrates how to declare an iterator for a vector of ints and use
that iterator to display the values:

#include <vector>
#include <iostream>
typedef vector<int, allocator<int> > INTVECT;
void main()
{
INTVECT myVector(5); // declare a vector of 5 ints
INTVECT::iterator myIter; // declare an iterator for the vector
for(int iv = 0; iv < 5; iv++)
myVector[iv] = iv; // fill the vector with values
for(myIter = myVector.begin(); myIter != myVector.end(); myIter++)
cout << *myIter << “, “;
cout << endl;
}

Output:

0, 1, 2, 3, 4,

Note that the termination condition for the "for loop" was “myIter != myVector.end()”
instead of “myIter < myVector.end()”. In the above example, the < operator would have
worked because the iterator supplied by a vector is a random access iterator. If our
container had been a list, the < operator would not have worked, as the < operator is not
defined for the bidirectional iterator that list supplies. The moral of the story is that in
such a situation, using != will give the same result and you don’t have to remember
which kind of iterator a particular container is supplying.

7.4 Stream Iterators

One of the reasons input and output iterators are defined separately is so that they can be
associated with I/O streams.

7.4.1 Istream iterators

STL provides a predefined iterator class called istream_iterator. The istream_iterator

class is an input iterator. In Visual C++ version 4.2, istream_iterator<Value_Type,
Char_Type, Traits_Type> is derived from the base class iterator<Value_Type,
Char_Type, Traits_Type> and conforms to the requirements of an input iterator as
described above. istream_iterator provides two constructors, one that takes an input
stream as an argument (and ties the iterator to that stream). The other takes no arguments,
and is used to provide an end-of-stream marker for several algorithms.

Note Books Online says that istream_iterator takes two template parameters,
Value_Type and Distance_Type, and is derived from input_iterator<Value_Type,
Distance_Type>. The classes were modified to the structure stated above for Visual C++
4.2 to overcome some compiler limitations. A future version of Visual C++ will return to
the structure and hierarchy reflected in the Books Online. The STL is an emerging
standard and will undoubtedly be changed again in the future. In order to minimize the
impact these types of changes will have on existing code, the use of typedefs is highly
recommended when declaring a particular instantiation of any STL component.

The following fills a vector of strings from an input stream using the copy algorithm in
conjunction with an istream_iterator:

// STRING_INPUT is an istream iterator for objects of type string

typedef istream_iterator<string, char, char_traits<char> > STRING_INPUT;
// STRVECTOR is a vector which holds objects of type string
typedef vector<string, allocator<string> > STRVECTOR;
void main()
{
string FileName;
STRVECTOR theStrings;
cout << "Enter Input File Name: ";
cin >> FileName;
ifstream ifs(FileName.c_str()); // Open the file read only
// read to eof, storing each string in theStrings.
copy(STRING_INPUT(ifs),STRING_INPUT(),back_inserter(theStrings));
}

See section 7.6.1 for more information on the back inserter class.

7.4.2 Ostream iterators

STL provides a predefined iterator class called ostream_iterator. The ostream_iterator

class is an output iterator. In Visual C++ version 4.2, ostream_iterator<Value_Type,
Char_Type, Traits_Type> is derived from the base class iterator<Value_Type,
Char_Type, Traits_Type> and conforms to the requirements of an output iterator as
described above. ostream_iterator provides two constructors, one which takes an output
stream as an argument (and ties the iterator to that stream). The other takes two
arguments, an output stream (with the same effect as the one argument ctor) and a
delimiting character, which will be inserted into the stream after each object.

The following is the sample from the istream_iterator section with a new addition. Now,
the program prints the strings it has read to stdout, each on a new line. It accomplishes
this by again calling the copy algorithm, this time in conjunction with the string
container, and sends its output to an ostream_iterator object associated with cout:

// STRING_INPUT is an istream_iterator for objects of type string

typedef istream_iterator<string, char, char_traits<char> > STRING_INPUT;
// STRING_OUTPUT is an ostream_iterator for objects of type string
typedef ostream_iterator<string, char, char_traits<char> >
STRING_OUTPUT;
// STRVECTOR is a vector which holds objects of type string
typedef vector<string, allocator<string> > STRVECTOR;
void main()
{
string FileName;
STRVECTOR theStrings;
cout << "Enter Input File Name: ";
cin >> FileName;
ifstream ifs(FileName.c_str()); // Open the file read only
// read to eof, storing each string in theStrings.
copy(STRING_INPUT(ifs),STRING_INPUT(),back_inserter(theStrings));
// print the contents of theStrings to cout,
// using copy and STRING_OUTPUT
copy(theStrings.begin(), theStrings.end(),
STRING_OUTPUT(cout,"\n"));
}
7.5 Iterator Adapters

An adapter in STL is a wrapper class that takes an existing class and provides it with a
new interface. There are two adapters provided by the STL for iterators: reverse iterators
and insert iterators.

7.5.1 Reverse iterators

Reverse iterator adapters transform their iterators to traverse a collection from back to
front. There are two adapters supplied by the STL: reverse_bidirectional_iterator,
which transforms bidirectional iterators, and reverse_iterator, which transforms random
access iterators. Each container, C<T>, supplies typedefs for reverse iterators:

• reverse_iterator (mutable)

• const_reverse_iterator (nonmutable)

to declare an iterator, simply use the syntax C<T>::reverse_iterator or

C<T>::const_reverse_iterator (see example below).

The following example illustrates how to declare a reverse iterator for a vector of ints and
use that iterator to display the values in reverse order:

#include <vector>
#include <iostream>
typedef vector<int, allocator<int> > INTVECT;
void main()
{
INTVECT myVector(5); // declare a vector of 5 ints
// declare a reverse iterator for the vector
INTVECT::reverse_iterator myIter;
for(int iv = 0; iv < 5; iv++)
myVector[iv] = iv; // fill the vector with values
for(myIter = myVector.rbegin(); myIter != myVector.rend();
myIter++)
cout << *myIter << “, “;
cout << endl;
}

Output:

4, 3, 2, 1, 0,

Note the use of rbegin and rend in the above example. Just as each type of STL
container supplies begin and end member functions (which return regular iterators), each
also supplies rbegin and rend member functions (which return reverse iterators).

When reverse iterators are passed to a generic algorithm, they make the algorithm work
in reverse. Consider the sort algorithm:
sort(myVector.begin(), myVector.end());

Sorts the contents of myVector into ascending order, and:

sort(myVector.rbegin(), myVector.rend());

Sorts the contents into ascending order as seen from back to front, which results in the
contents being sorted into descending order.

7.6 Insert Iterators

Insert iterators put an algorithm into insert mode. The most useful effect of this is that
insert iterators use insert operations (which expand allocated memory as needed) instead
of assignment operations (which assume the space is available) to add objects to a target
container. This is done via a redefinition of operator*, so that *i = … calls one of the
container’s insert functions instead of operator=. Consider the following use of the copy
algorithm to copy the objects from a deque to a vector:

// v1 is and empty vector

vector<int, allocator<int> > v1;
// d1 holds 100 1’s
deque<int, allocator<int> > d1(100, 1);
// causes an error
copy(d1.begin(), d1.end(), v1.begin());

The call to copy above will cause a run-time error (probably a GPF) when *(v1.begin())
= *(d1.begin()) is called, because v1 does not have any memory allocated for itself.
Replacing v1.begin() with an insert iterator, such as back_inserter will solve the
problem as follows:

copy(d1.begin(), d1.end(), back_inserter(v1)); // executes correctly

Now, (v1.begin()) = (d1.begin()) (and all subsequent assignments) map to

vector::push_back instead of vector::operator=. STL provides three insert adapters:
back_inserter, front_inserter, and inserter.

7.6.1 back_inserter iterators

As noted above, back_inserter iterators call the push_back method of the container
instead of operator= when the iterator’s operator* method is invoked as an l-value. This
means that back_inserter iterators can only be used with containers that support the
push_back method (vector, deque, list). The following illustrates a declaration of a
back_inserter iterator to be associated with a vector:

// declare a vector of ints

vector<int, allocator<int> > iV;
// declare a back_inserter iterator associated with iV
back_inserter iVPtr(iV);
7.6.2 front_inserter iterators

Because front_inserter iterators call the push_front method of the container instead of
operator= when the iterator’s operator* method is invoked as an l-value, front_inserter
iterators can only be used with containers that support the push_front method (deque,
list). The following illustrates a declaration of a front_inserter iterator to be associated
with a list:

// declare a list of ints

list<int, allocator<int> > iL;
// declare a front_inserter iterator associated with iL
front_inserter iLPtr(iL);

7.6.3 Inserter iterators

Inserter iterators call the insert method of the container instead of operator= when the
iterator’s operator* method is invoked as an l-value. This means that inserter iterators
can be used with all the STL containers, even the sorted associative containers, as they all
support an insert method. The following illustrates a declaration of an inserter iterator to
be associated with a set that inserts its objects beginning at the second item in the set.

// declare a set of ints

set<int, less<int>, allocator<int> > iS;
// declare an inserter iterator associated with iS
inserter(iS, iS.begin() + 1);

8. Container Adapters
An adapter in STL is a wrapper class that takes an existing class and provides it with a
new interface. There are three adapters provided by the STL for containers: stack, queue,
and priority_queue.

8.1 Stack

A stack adapts any STL container that supports the push_back and pop_back member
functions. It implements a container that performs as stack (Last In, First Out). A stack
may be used to adapt the behavior of a vector, deque or list (as all three support
push_back and pop_back). The deque is the most commonly used container with a
stack.

Note In most implementations of the STL, deque is the default value for the second
template parameter of a stack (the second template parameter specifies the stored
container type). In Visual C++ 4.2, the default argument is not defined due to compiler
limitations.

The following declares a stack of ints, pushes nine values onto the stack, and then pops
each one after printing it:
typedef allocator<int> IALLOC;
typedef deque<int, IALLOC> IDQ;
typedef stack<int, IDQ, IALLOC> ISTACK;
void somefunct(void)
{
ISTACK MyStack;
for(int i = 1; i < 10; i++)
MyStack.push(i);
while(MyStack.size()){
cout << MyStack.top() << ", ";
MyStack.pop();
}
cout << endl;
}

Output:

9, 8, 7, 6, 5, 4, 3, 2, 1,

• See APPENDIX B for the stack class definition

• See APPENDIX C for a table of stack methods

• See APPENDIX D for an explanation of the allocator class (typedef’d as

IALLOC above)

8.2 Queue

A queue adapts any STL container that supports the push_back and pop_front member
functions. It implements a container that performs as a queue (First In First Out). A
queue may be used to adapt the behavior of a deque or list (as both support push_back
and pop_front). The deque is the most commonly used container with a queue.

Note In most implementations of the STL, deque is the default value for the second
template parameter of a queue (the second template parameter specifies the stored
container type). In Visual C++ version 4.2, the default argument is not defined due to
compiler limitations.

The following declares a queue of ints, pushes nine values onto the queue, and then pops
each one after printing it:

typedef allocator<int> IALLOC;

typedef deque<int, IALLOC> IDQ;
typedef queue<int, IDQ, IALLOC> IQUEUE;
void somefunct(void)
{
IQUEUE MyQueue;
for(int i = 1; i < 10; i++)
MyQueue.push(i);
while(MyQueue.size()){
cout << MyQueue.front() << ", ";
MyQueue.pop();
}
cout << endl;
}

Output:

1, 2, 3, 4, 5, 6, 7, 8, 9,

• See APPENDIX B for the queue class definition

• See APPENDIX C for a table of queue methods

• See APPENDIX D for an explanation of the allocator class (typedef as IALLOC

above)

8.3 Priority_Queue

A priority_queue adapts any STL container that has a random access iterator to maintain
a sorted collections of items. A priority_queue may be used to adapt the behavior of a
vector or a deque (as both are associated with a random access iterator and support
operator[]). The vector is the most commonly used container with a priority_queue.

Note In most implementations of the STL, vector is the default value for the second
template parameter of a priority_queue (the second template parameter specifies the
stored container type). In Visual C++ 4.2, the default argument is not defined due to
compiler limitations.

The third template parameter allows you to specify the comparator used to sort the items.
The following declares a priority_queue of ints, fills it with 10 random values and prints
them in sorted order:

typedef allocator<int> IALLOC;

typedef vector<int, IALLOC> IV;
typedef priority_queue<int, IV, less<int>, IALLOC> PQUEUE;
void somefunct(void)
{
PQUEUE MyQueue;
for(int i = 1; i < 10; i++)
MyQueue.push(rand() % 10);
while(MyQueue.size()){
cout << MyQueue.top() << ", ";
MyQueue.pop();
}
cout << endl;
}

Output:

9, 8, 8, 7, 4, 4, 2, 1, 0,
• See APPENDIX B for the priority_queue class definition

• See APPENDIX C for a table of priority_queue methods

• See APPENDIX D for an explanation of the allocator class (typedef to IALLOC

above)

9. The C++ String Class

9.1 Introduction

How often have C++ programmers wished they could add two strings using an obvious
syntax like s1 + s2? Or add characters to a string using a syntax like s1 + “Hi”? Even
Microsoft Basic allows that syntax.

The Standard C++ Library provides C++ programmers with a powerful string class. The
string class is based on the basic_string class template.

Standard C++ declares two type definitions, string and wstring, based on basic_string:

typedef basic_string<char, char_traits<char>, allocator<char> > string;

typedef basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t>
> wstring;

The basic_string has been defined in the header <xstring>.

The C++ string class is very easy to use. Table 11 describes all the member functions in
brief and the sample in the following section demonstrates the C++ string class.

Table 11. String Class Member Functions

Member function Description

string& append(const char *s); Appends the sequence specified by *s to the
end of the sequence controlled by *this, then
returns *this.
string& append(const char *s, Appends n characters of the sequence
size_type n); specified by *s to the end of the sequence
controlled by *this, then returns *this.
string& append(const string& str, Appends n characters of the sequence
size_type pos, specified by str starting at position pos to the
size_type n); end of the sequence controlled by *this, then
returns *this.
string& append(const string& str); Appends the sequence specified by str to the
end of the sequence controlled by *this, then
returns *this.
string& append(size_type n, char c); Appends n copies of the character specified
by c to the end of the sequence controlled by
*this, then returns *this.
string& append(const_iterator first, Appends the sequence specified by [first,
const_iterator last); last) to the end of the sequence controlled by
*this, then returns *this.
string&assign(const char *s); Replaces the sequence controlled by *this
with the sequence specified by *s, then
returns *this.
string& assign(const char *s, size_type Replaces the sequence controlled by *this
n); with n characters of the sequence specified
by *s, then returns *this.
string& assign(const string& str, Replaces the sequence controlled by *this
size_type pos, with n characters of the sequence specified
size_type n); by str, starting at position pos, then returns
*this.
string& assign(const string& str); Replaces the sequence controlled by *this
with the sequence specified by str, then
returns *this.
string& assign(size_type n, char c); Replaces the sequence controlled by *this
with n copies of the character specified by c,
then returns *this.
string& assign(const_iterator first, Replaces the sequence specified by [first,
const_iterator last); last) to the end of the sequence controlled by
*this, then returns *this.
const_reference at(size_type pos) const; Returns a reference to the element of the
reference at(size_type pos) ; controlled sequence at position pos, or
reports an out-of-range error.
const_iterator begin() const; Returns a random-access iterator that points
iterator begin(); at the first element of the sequence (or just
beyond the end of an empty sequence).
const char *c_str() const; Returns a pointer to a nonmodifiable C
string constructed by adding a terminating
null element (traits_type:: eos()) to the
controlled sequence. Calling any non-const
member function for *this can invalidate the
pointer.
size_type capacity() const; The member function returns the storage
currently allocated to hold the controlled
sequence, a value at least as large as size().
int compare(const string& str) const; Compares elements of the controlled
sequence, if these arguments are not
supplied, to the sequence specified by str.
The function returns:

· a negative value if the first differing

element in the controlled sequence compares
less than the corresponding element in str ,
or if the two have a common prefix but str is
longer.