CS 101:

Computer Programming and

Utilization

Puru
with
CS101 TAs and Staff

Course webpage: https://www.cse.iitb.ac.in/~cs101/

Lecture 21: The C++ Standard Library

CS101 Autumn 2019 @ CSE IIT Bombay

 Object Oriented Programming

A methodology for designing programs

Chapter 17, 18

CS101 Autumn 2019 @ CSE IIT Bombay 2

The C++ structure
• Member variables
− Basic facility provided in C++ to conveniently gather together
information associated with an entity
− Inherited from the C language

• Member functions
− New feature introduced in C++
− Actions/operations that effect the entity

− User defined data type with variables and functions

CS101 Autumn 2019 @ CSE IIT Bombay 3

Objects As Software Components

• A software component can be built around a struct

• Just as a hardware component is useful for building big hardware

systems,
so is a software component for building large software systems

• A software component must be convenient to use, and also safe,

i.e., help in preventing programming errors

CS101 Autumn 2019 @ CSE IIT Bombay 4

The modern version of a struct

• Designer of the struct decides what happens during execution of

standard operations such as:
– Creation of the object
– Assignment
– Passing the object to a function
– Returning the object from a function
– Destroying the object when it is not needed

CS101 Autumn 2019 @ CSE IIT Bombay 5

C++ specifics of structures, classes and objects
• Constructors
• Copy Constructors
• Destructors
• Operator overloading
• Overloading the assignment operator
• Access control
• Classes
• Graphics and input/output classes

CS101 Autumn 2019 @ CSE IIT Bombay 6

Constructor for V3
struct V3{ • When defining v1, an argument is
double x,y,z; given
V3(){
• So the constructor taking a single
x = y = z = 0;
argument is called. Thus each
}
component of v1 is set to 5
V3(double a){
x = y = z = a;
• When defining v2, no argument is
}
given.
};
• So the constructor taking no
int main(); arguments gets called. Thus each
V3 v1(5), v2; component of v2 is set to 0
}

CS101 Autumn 2019 @ CSE IIT Bombay 7

Copy Constructor of Queue
struct Queue{
int elements[N], nWaiting, front;

Queue(const Queue &source){ // Copy constructor

front = source.front;
nWaiting = source.nWaiting;

for(int i=front, j=0; j<nWaiting; j++){

elements[i] = source.elements[i];
i = (i+1) % N;
}

};

CS101 Autumn 2019 @ CSE IIT Bombay 8

Destructor Example
struct Queue{
int elements[N], nWaiting, front;
. . .

~Queue(){ //Destructor
if(nWaiting>0) cout << “Warning:”
<<“ non-empty queue being destroyed.”
<< endl;
}

};

CS101 Autumn 2019 @ CSE IIT Bombay 9

Operator Overloading
• In Mathematics, arithmetic operators are used with numbers, but
also other objects such as vectors
• Something like this is also possible in C++!

• An expression such as x @ y where @ is any “infix” operator is

considered by C++ to be equivalent to
x.operator@(y) in which operator@ is a member function

• If the member function operator@ is defined, then that is called to

execute x @ y

CS101 Autumn 2019 @ CSE IIT Bombay 10

Example: Arithmetic on V3 objects
struct V3{
double x, y, z;
V3(double a, double b, double c){
x=a; y=b; z=c;
}

V3 operator+(V3 b){ // adding two V3s

return V3(x+b.x, y+b.y, z+b.z); // constructor call
}

V3 operator*(double f){ // multiplying a V3 by f

return V3(x*f, y*f, z*f); // constructor call
}
};

CS101 Autumn 2019 @ CSE IIT Bombay 11

Using V3 Arithmetic

int main(){
V3 u(1,2,3), a(4,5,6), s;
double t=10;
s = u*t + a*t*t*0.5;
cout << s.x <<‘ ‘<< s.y << ‘ ‘<< s.z << endl;
}

CS101 Autumn 2019 @ CSE IIT Bombay 12

Pointers to Structures
• Disk d1={{2,3},4}, *dptr;

• *dptr is defined to have type Disk, so dptr is a pointer to a variable

of type Disk

• Normal pointer operations are allowed on structure pointers

• dptr = &d1;
• (*dptr).radius = 5; //changes the radius of d1

• Operator ->
– (*x).y is same as x->y
• dptr->radius = 5; // same effect as above

CS101 Autumn 2019 @ CSE IIT Bombay 13

Pointers as Structure Members

struct Disk2{
double radius;
Point *centerptr;
}

Point p={10,20};
Disk2 d;
d.centerptr = &p;
cout << d.centerptr->x << endl; // will print 10.

CS101 Autumn 2019 @ CSE IIT Bombay 14

The this Pointer
• So far, we have not provided a way to refer to the receiver itself inside the
definition of a member function.

• Within the body of a member function, the keyword this points to the receiver
i.e., the struct on which the member function has been invoked.

• Trivial use: write this->member instead of member directly

struct V3{
double x, y, z;
double length(){
return sqrt(this->x * this->x
+ this->y * this->y
+ this->z * this->z);
}
}

• More interesting use later.

CS101 Autumn 2019 @ CSE IIT Bombay 15

Overloading The Assignment Operator
• Normally if you assign one struct to another, each member of the
rhs is copied to the corresponding member of the lhs

• You can change this behaviour by defining member function

operator= for the struct

• A return type must be defined if you wish to allow chained

assignments, i.e., v1 = v2 = v3; which means v1 = (v2 = v3);
– The operation must return a reference to the left hand side
object

CS101 Autumn 2019 @ CSE IIT Bombay 16

Example
struct Queue{
...

Queue& operator=(Queue &rhs){

front = rhs.front;
nWaiting = rhs.nWaiting;

for(int i=0; i<nWaiting; i++){

elements[i] = rhs.elements[i];
i = (i+1) % N;
}
return *this;
}

};
// only the relevant elements are copied

CS101 Autumn 2019 @ CSE IIT Bombay 17

Access Control

• It is possible to restrict access to members or member functions of

a struct
• Members declared public: no restriction
• Members declared private: Can be accessed only inside the
definition of the struct
• Typical strategy
Declare all data members to be private, and
some subset of function members to be public

CS101 Autumn 2019 @ CSE IIT Bombay 18

Access Control Example

struct Queue{
private:
int elements[N], nWaiting, front;

public:
Queue(){ … }
bool insert(int v){
..
}
bool remove(int &v){
..
}
};

CS101 Autumn 2019 @ CSE IIT Bombay 19

Remarks
• public:, private: : access specifiers

• An access specifier applies to all members defined following it,

until another specifier is given

• Thus elements, nWaiting, front are private, while Queue(),

insert, remove are public

CS101 Autumn 2019 @ CSE IIT Bombay 20

Remarks
• The default versions of the constructor, copy constructor,
destructor, assignment operator are public

• If you specify any of these as private, then they cannot be invoked

outside of the struct definition

• Thus if you make the copy constructor of a struct X private, then

you will get an error if you try to pass a struct of type X by value

• Thus, as a designer of a struct, you can exercise great control over

how the struct gets used

CS101 Autumn 2019 @ CSE IIT Bombay 21

Classes
• A class is essentially the same as a struct, except:
– Any members/member functions in a struct are public by
default
– Any members/member functions in a class are private by
default

CS101 Autumn 2019 @ CSE IIT Bombay 22

Classes
• Example: A Queue class

class Queue{
int elements[N], nWaiting, front;
public:
Queue(){…}
bool remove(int &v){…}
bool insert(int v){…}
};

• The members - elements, nWaiting and front will be private.

CS101 Autumn 2019 @ CSE IIT Bombay 23

Function definition and declaration (with class)
class V3{ class V3{
double x,y,z; double x,y,z;
V3(double v){ V3(double v);
x = y = z = v; double X();
} };
double X(){
return x; //implementations
} V3::V3(double v){
}; x = y = z = v;
}
double V3::X(){
return x;
}

CS101 Autumn 2019 @ CSE IIT Bombay 24

Example (with struct)
struct V3{ struct V3{
double x,y,z; double x,y,z;
V3(double v){ V3(double v);
x = y = z = v; double X();
} };
double X(){
return x; //implementations
} V3::V3(double v){
}; x = y = z = v;
}
double V3::X(){
return x;
}

CS101 Autumn 2019 @ CSE IIT Bombay 25

Concluding Remarks
• The notion of a packaged software component is important.
• Making data members private
– hiding the implementation from the user
• Making some member functions public:
– providing an interface using which the object can be used

• Separation of the concerns of the developer and the user

– The specification of the function must be clearly written down
(analogous to interface)
– The user should not worry about how the function does its
work (analogous to hiding data members)

CS101 Autumn 2019 @ CSE IIT Bombay 26

The C++ Standard (Template) Library

Chapter 22

CS101 Autumn 2019 @ CSE IIT Bombay 27

The C++ Standard Library
• Comes with every C++ distribution
• Contains many functions and classes that you are likely to need in
day to day programming
• The classes have been optimized and debugged thoroughly
• If you use them, you may be able to write programs with very little
work
• Highly recommended that you use functions and classes form the
standard library whenever possible

• Files, Strings, Maps, Vectors, Sets, Lists,

Queues …

CS101 Autumn 2019 @ CSE IIT Bombay 28

Input Output Classes (stdin/stdout/files)

• cin, cout : objects of class istream, ostream resp. predefined in C++

• <<, >> : operators defined for the objects of these classes

• ifstream: another class like istream

• You create an object of class ifstream and associate it with a file on

your computer

• Now you can read from that file by invoking the >> operator!

• ofstream: a class like ostream, to be used for writing to files

• Must include header file <fstream> to uses ifstream and ofstream

CS101 Autumn 2019 @ CSE IIT Bombay 29

Example of File i/o
#include <fstream>
#include <simplecpp>
int main(){
ifstream infile(“f1.txt”);
// constructor call.
// object infile is created and associated
// with f1.txt, which must be present in the current directory

ofstream outfile(“f2.txt”);
// constructor call. Object outfile is created and associated
// with f2.txt, which will get created in the current directory

repeat(10){
int v;
infile >> v;
outfile << v;
}
// f1.txt must begin with 10 numbers. These will be read and
// written to file f2.txt
}

CS101 Autumn 2019 @ CSE IIT Bombay 30

ifstream /ofstream member functions
• open, close, is_open

• >> , <<, !

• get, getline, peek, read

• put, write

CS101 Autumn 2019 @ CSE IIT Bombay 31

“String theory”
• Iterative computations are demonstrated well on arrays

• strings … the system manages the array space for us

• string message; // a character string

• Can assign and append to strings

• Can read a position: cout << message[px]
• Can write a position: message[px] = ‘q’

CS101 Autumn 2019 @ CSE IIT Bombay 32

Strings without string
• character arrays!
char str[5] = {‘h’, ‘e’, ‘l’, ‘l’, ‘o’} ;

• why string then?

• the dreaded NULL character

• null character => character with ASCII value 0
• require null-terminated character array to represent end
of string
• no end of string can lead to chaos!

CS101 Autumn 2019 @ CSE IIT Bombay 33

Challenge with char arrays!
char str[6] = {‘e’, ‘a’, ‘r’, ‘t’, ‘h’} ;

cout << str; // early takeoff of space shuttle

str[5] = ‘\0’;
cout << str; // back to earth!

• Have to ensure null-termination at all points

• Character array sizing has to be managed (via copies

etc.) explicitly

• Not objects!
CS101 Autumn 2019 @ CSE IIT Bombay 34
the string class
string str = “earth”;

cout << str; // stay on earth!

• can use indexing as in arrays

• other member functions
– size, clear, empty,
– + , = , +=, >>, <<
– push_back, pop_back, append
– insert, erase, find, substr

CS101 Autumn 2019 @ CSE IIT Bombay 35

Printing a string in reverse
string message;
getline(cin, message);
int mx = message.size()-1;
while (mx >= 0) { Character at
cout << message[mx]; position mx in
--mx; string message
}

• mx updated in a predictable way

• Ideal candidate to write as for loop

CS101 Autumn 2019 @ CSE IIT Bombay 36

Finding needles in a haystack
• Given two strings, needles and haystack
• needles has no repeated characters
• haystack may repeat characters
• How many characters in needles appear in haystack at
least once?
• needles = “bat”, haystack = “tabla”  3
• needles = “tab”, haystack = “bottle”  2

CS101 Autumn 2019 @ CSE IIT Bombay 37

One needle in a haystack
• Subproblem: given one character ch and a string
find if ch appears in string at least once
char ch;
cin >> ch;
string haystack;
cin >> haystack;

int ans = 0; // will change to 1 if found

for (int hx = 0; hx < haystack.size(); ++hx) {
if (ch == haystack[hx]) {
++ans;
break; // quit on first match
}
}
CS101 Autumn 2019 @ CSE IIT Bombay 38
Many needles: nested loop
main() {
string needles, haystack;
getline(cin, needles); getline(cin, haystack);

int ans = 0;
for (int nx=0; nx < needles.size(); ++nx) {
char ch = needles[nx];
for (int hx = 0; hx < haystack.size(); ++hx) {
if (ch == haystack[hx]) {
++ans;
break; // quit on first match
}
} // ends haystack loop Generalize to work in
} // ends needles loop case needles can also
}
have repeated
characters
CS101 Autumn 2019 @ CSE IIT Bombay 39
Duplicate needles

• needles = “bat”, haystack = “tabla”  3

• needles = “tab”, haystack = “bottle”  2
• needles = “bata”, haystack = “tabla”  3

• Two approaches
– Dedup needles before executing earlier code (reducing
to known problem)
– Dedup needles “on the fly” (inside the nx loop)

CS101 Autumn 2019 @ CSE IIT Bombay 40

Strings and member functions (example)
#include <string>
string v = “abcdab”;
string w(v);

v[2] = v[3]; // indexing allowed. v becomes “abddab”

cout << v.substr(2) << v.substr(1,3) << endl;

// substring starting at v[2] (“ddab”)
// substring starting at v[1] of length 3 (“bdd”)

int i = v.find(“ab”); // find occurrence of “ab” in v

// and return index
int j = v.find(“ab”,1); // find from index 1

cout << i << “, “ << j << endl; // will print out 0, 4.

CS101 Autumn 2019 @ CSE IIT Bombay 41

Template functions
• Function templates (Sec 12.5 in book)
• Consider these three functions: same body, different types
int Abs(int x) float Abs(float x) double Abs(double x)
{ { {
if (x < 0) if (x < 0) if (x < 0)
return -x; return -x; return -x;
else return x; else return x; else return x;
} } }

template<typename T>
A common template to unite T Abs(T x) {
them all.... if (x < 0)
return -x;
else return x;
}
CS101 Autumn 2019 @ CSE IIT Bombay 42
Template Class
• Like function templates, create class with templates.
template <class T> main () {
class Queue { Queue<V3> q;
int front, nWaiting; Queue<int> r;
T elements[100]; }
public:
bool insert(T value)
{...}
bool remove(T &val)
{...}
};

CS101 Autumn 2019 @ CSE IIT Bombay 43

Vectors
• Friendlier, more versatile version of arrays
• Must include header file <vector> to use it

• vectors of any type by supplying the type as an argument to the

template
• Indexing possible like arrays

• Possible to extend length, or even insert in the middle

CS101 Autumn 2019 @ CSE IIT Bombay 44

vector examples
#include <vector> // needed

vector<int> v1; //empty vector. Elements will be int

vector<float> v2; //empty vector. Elements will be
float
vector<short> v3(10); // vector of length 10.
// Elements are of type short

vector<char> v4(5,’a’); // 5 elements, all ‘a’

cout << v3.size() << endl; // prints vector length, 10
// v3.length() is same

v3[6] = 34; // standard indexing

CS101 Autumn 2019 @ CSE IIT Bombay 45

vector examples (continued)
#include <vector> // needed
...

v3.push_back(22); // append 22 to v3.

// Length increases
vector<char> w;
w = v5; // element by element copy

v1.resize(9); // change length to 9

v2.resize(5, 3.3); // length becomes 5, all
// values become 3.3
vector<string> s; // vector of string

vector<vector<int> > vv; // allowed!

CS101 Autumn 2019 @ CSE IIT Bombay 46

size_t
• The member function size returns a value of type size_t
• size_t is an unsigned integer type; it is meant specially for storing
array indices
• When going through array elements, use size_t for the index
variable
vector<double> v(10); // initialize v
for(size_t i=0; i<v.size(); i++)
cout << v[i] << endl;
• If i were declared int, then the compiler would warn about the
comparison between i and v.size()
– comparison between signed and unsigned int, which is tricky
as discussed in Section 6.8.
– By declaring i to be size_t, the warning is suppressed.

CS101 Autumn 2019 @ CSE IIT Bombay 47

Multi-dimensional vectors

vector<vector <int> > vv;

// each element of vv is itself a vector of int
// we must supply two indices to get to int
// Hence it is a 2d vector!
// Currently vv is empty

vector<vector <int> > vv1(5, vector<int>(10,23));

// vv1 has 5 elements
// each of which is a vector<int>
// of length 10,
// having initial value 23

CS101 Autumn 2019 @ CSE IIT Bombay 48

Multi-dimensional vectors usage
• Note that the syntax is not new/special
• It is merely repeated use of specifying the length and initial value:
vector<type> name(length, value)
• Two dimensional arrays can be accessed by supplying two indices,
i.e., vv1[4][6] and so on
• Write vv1.size() and vv1[0].size() to get number of rows and
columns

CS101 Autumn 2019 @ CSE IIT Bombay 49

Creating a 5x5 identity matrix

vector<vector<double>> m(5, vector<double>(5,0));

// m = 5x5 matrix of 0s
// elements of m can be accessed
// by specifying two indices
for(int i=0; i<5; i++)
m[i][i] = 1;
// place 1’s along the diagonal

CS101 Autumn 2019 @ CSE IIT Bombay 50

Ch. 22 (22.2.7) Remarks

• The book discusses a matrix class which internally uses vector

of vectors
• This class is better than two dimensional arrays because it can
be passed to functions by value or by reference, with the
matrix size being arbitrary

CS101 Autumn 2019 @ CSE IIT Bombay 51

Sorting a vector
• C++ provides a built-in facility to sort vectors and also arrays
• You must include <algorithm> to use this

vector<int> v(10);
// somehow initialize v

sort(v.begin(), v.end());

• That’s it! v is sorted in non decreasing order

• begin and end are “iterators” over v. Think of them as

abstract pointers to the beginning and the end.

CS101 Autumn 2019 @ CSE IIT Bombay 52

Sorting an array

• The algorithms in header file <algorithm> can also sort

arrays as follows

double a[100];
// somehow initialize a

sort(a, a+100); // sorted!

// second argument is name+length

• More variations in the book

CS101 Autumn 2019 @ CSE IIT Bombay 53

The Map Template Class
• A vector or an array give us an element when we supply an
index
– Index must be an integer
• Sometimes we may want to use indices which are not
integers, but strings
– Given the name of a country, we may want to find out its
population, or its capital
– This can be done using a map
– (a.k.a) key-value store
– keys and values can be of data types other than integers

CS101 Autumn 2019 @ CSE IIT Bombay 54

The Map
• General form:
map<indextype, valuetype> mapname;

• Examples:
map<string,double> population;
Indices will have type string (country names), and elements
will have type double (population)

map<string, vector<string>> dictionary;

Maps words to their meanings expressed as a vector of other

words.

CS101 Autumn 2019 @ CSE IIT Bombay 55

Map usage
map<string,double> population;

population[“India”] = 1.21;
// in billions. Map entry created
population[“China”] = 1.35;
population[“USA”] = 0.31;

cout << population[“China”] << endl;

// will print 1.35

population[“India”] = 1.22;
//update allowed

CS101 Autumn 2019 @ CSE IIT Bombay 56

Checking index validity
string country;
cout << “Give country name: “;
cin >> country;

if(population.count(country)>0) {
// true if element with index = country
// was stored earlier
// count is a known member function
cout << population[country] << endl;
}
else cout << “Not known.\n”;

CS101 Autumn 2019 @ CSE IIT Bombay 57

Remarks

• A lot goes on behind the scenes to implement a map

• Basic idea is discussed in Chapter 24 of our book

• If you wish to print all entries stored in a map, you will need

to use iterators, discussed next

CS101 Autumn 2019 @ CSE IIT Bombay 58

Iterators
• A map can be thought of as holding a sequence of pairs, of the
form (index, value)
• For example, the population map can be considered to be the
sequence of pairs
[(“China”,1.35), (“India”,1.21), (“USA”, 0.31)]
• You may wish to access all elements in the map, one after another,
and do something with them
• For this, you can obtain an iterator, which points to (in an abstract
sense) elements of the sequence

CS101 Autumn 2019 @ CSE IIT Bombay 59

Iterators (continued)
An iterator points to (in an abstract sense) elements of the sequence

• An iterator can be initialized to point to the first element of the

sequence
• In general, given an iterator which points to some element,
you can ask if there is any element following the element, and
if so make the iterator point to the next element

• An iterator for a map<index,value> is an object with type

map<index,value>::iterator

CS101 Autumn 2019 @ CSE IIT Bombay 60

Using iterators
• An iterator points to elements in the map; each element is a
struct with members first and second

• We can get to the members by using dereferencing

• Note that this simply means that the dereferencing operators

are defined for iterators

• If many elements are stored in an iterator, they are arranged

in (lexicographically) increasing order of the key

CS101 Autumn 2019 @ CSE IIT Bombay 61

Example
map<string,double> population;
population[“India”] = 1.21;

map<string,double>::iterator mi;
mi = population.begin();
// population.begin() : constant iterator
// points to the first element of population
// mi points to (India,1.21)

cout << mi->first << endl; // or (*mi).first << endl;

// will print out India

cout << mi->second << endl;

// will print out 1.21

CS101 Autumn 2019 @ CSE IIT Bombay 62

Example
map<string,double> population;
population[“India”] = 1.21;
population[“China”] = 1.35;
population[“USA”] = 0.31;

for(map<string,double>::iterator
mi = population.begin();
mi != population.end(); mi++)

// population.end() : constant iterator

// marking the end of population
// ++ sets mi to point to the
// next element of the map
// loop body

CS101 Autumn 2019 @ CSE IIT Bombay 63

Example
map<string,double> population;
population[“India”] = 1.21;
population[“USA”] = 0.31;
population[“China”] = 1.35;

for(map<string,double>::iterator
mi = population.begin();
mi != population.end();
mi++)
{
cout << (*mi).first << “: “ << (*mi).second << endl;
// or cout << mi->first << “: “ << mi->second << endl;
}
// will print out countries and population in
alphabetical order

CS101 Autumn 2019 @ CSE IIT Bombay 64

Remarks

• Iterators can work with vectors and arrays too

• Iterators can be used to find and delete elements from maps
and vectors.

map<string,double>::iterator
mi = population.find("India");

population.erase(mi);

CS101 Autumn 2019 @ CSE IIT Bombay 65

Maps with user-defined class as index
• Any class used as indextype on a map must implement
the "<" operator.
• Example, the following code will not work because "<" is
not defined on V3.
• class V3 {public: double x,y,z};
• map<V3, string> vec2string;
• A correct implementation of V3 may be something like:
class V3 {
public:
double x,y,z;
bool operator<(const V3& a) const {
if (x < a.x) return true;
if (x == a.x && y < a.y) return true;
if (x==a.x && y == a.y && z < a.z) return true;
return false;
}
};
CS101 Autumn 2019 @ CSE IIT Bombay 66
 Sets

• Sets are containers that store unique elements following a specific

order
• The value of the elements in a set cannot be modified once in the
container (the elements are always const), but they can be
inserted or removed from the container
• Internally, the elements in a set are always sorted following a
specific ordering criterion indicated by its internal comparison
object

CS101 Autumn 2019 @ CSE IIT Bombay 67

 Populating and Traversing a Set
#include <set> // set class library
...
set<int> set1; // create a set object,
// specifying its content as int
// the set is empty
int ar[]={3,2,4,2};
for (int i = 0; i < 4; i++) {
set1.insert(ar[i]); // add elements to the set.
}
for (set<int>::iterator iter = set1.begin(); iter !=
set1.end(); iter++) {
cout << *iter << " ";
} // prints 2 3 4
CS101 Autumn 2019 @ CSE IIT Bombay 68
 Application of Set
Given N students where each student has a list of courses that they have
taken.
Create group of all students that have taken exactly the same set of courses.

map<set<string>, vector<int>> study_group;

// key of the map is the set of courses.
// value is vector of student roll-numbers of students
who have taken this course.
cin >> N;
for(int i = 0; i < N; i++) {
int roll, int n;
cin >> roll >> n;
set<string> subjects;

CS101 Autumn 2019 @ CSE IIT Bombay 69

 Application of Set (continued)
for (int j = 0; j < n; j++) {
string s; cin >> s;
subjects.insert(s);
}
study_group[subjects].push_back(rollno);
}

CS101 Autumn 2019 @ CSE IIT Bombay 70

 List
• Implements a classic list data structure
• Supports a dynamic bidirectional linear list
• Unlike a C++ array, the objects the STL list contains cannot be
accessed directly (i.e., by subscript)
• Is defined as a template class, meaning that it can be customized to
hold objects of any type
• Responds like an unsorted list (ie. the order of the list is not
maintained). However, there are functions available for sorting the
list

CS101 Autumn 2019 @ CSE IIT Bombay 71

 Populating and Traversing a List
#include <list> // list class library
...
list <int> list1; // create a list object,
// specifying its content as int
// the list is empty
for (i=0; i<5; i++)
list1.push_back (i); // add at the end of the list
...
while (list1.size() > 0)
{ cout << list1.front(); // print the front item
list1.pop_front(); // discard the front
item
}
CS101 Autumn 2019 @ CSE IIT Bombay 72
Concluding Remarks
• Standard Library contains other useful classes, e.g. queue, list, set
etc.
• The Standard Library classes use heap memory, however this
happens behind the scenes and you don’t have to knowabout it

• The library classes are very useful. Get some practice with them

More details on the web.

Example:http://www.cplusplus.com/reference/stl/

CS101 Autumn 2019 @ CSE IIT Bombay 73