Chapter 20

Overview of Standard Template Library

20.1  INTRODUCTION TO STL

We have studied about the template that enables us to do generic programming. Generic functions or classes support all data types. The standard template library is an advance application of templates. It contains several in-built functions and operators that help the programmer develop complex programs. The programmer only needs to include an appropriate header file to use the function or operator from the file, such as library functions. The STL library helps write a bug-free program. In case any bug presents, it is easy to debug it. For example, if a programmer wants to create a link list, he/she may require to write a program that may be of 40 to 50 lines. However, using STL functions (list algorithm), it is a task of a few minutes.

The Standard Template Library (STL) is a new feature of C++ language. All famous compiler vendors provide the STL as a feature of their compilers. STL is vast and heterogeneous collection of reusable container classes. It consists of vectors, lists, queues, and stacks. The STL is portable with various operating systems.

The Meng Lee and Alexander Stepanov of Hewlett-Packard introduced the STL and accepted it in 1994 as an addition to the customary C++ library. The STL provides well-coded and compiled data structures and functions that are helpful in generic programming; and it is reusable. The STL topics are very vast; hence, their complete description is beyond the scope of this book. Only major features are explained. STL contents are defined in the namespace std. It is essential to write the statement using namespace std at the beginning of the program.

20.2  STL PROGRAMING MODEL

The STL is divided into three parts. They are containers, algorithms, and iterators. All these three parts can be used for different programming problems, and are closely associated with one another.

• Containers: A container is an object that contains data or other objects. The standard C++ library has a number of container classes that allows the programmer to perform common tasks. These containers support generic programming and can be used for handling the data of different data types. All STL container classes are declared in namespace std; There are two types of containers, as shown in Figure 20.1: sequence container and associative container. Sequence containers are created to allow sequential and random access to members. Associative containers allow access to their elements through a key.
• Algorithms: An algorithm is a technique that is useful to handle the data stored in containers. The STL comprises approximately 60 standard algorithms that give support to perform frequent and primary operations such as copying, finding, sorting, merging, and initializing. The standard algorithms are defined in the header file <alogrithm>.
• Iterators: An iterator is an object. It behaves exactly similar to a pointer. It indicates or points to the data element in a container. It is utilized to move between the data items of containers. Iterators can be incremented or decremented similar to pointers. They link algorithms with containers and handle the data stored in the containers.

20.3  CONTAINERS

The standard C++ library has a sequence of container classes. The container classes are robust and support C++ programmers to control common programming operations. There are three types of STL container classes. They are sequence, associative, and derived containers. Sequence containers are developed to allow sequential and random access to all the members. Associative containers are expanded to get their elements by values. Derived containers such as stacks, queues, and priority queues can be created from various sequence containers. Containers are shown in Figure 20.1.

Fig. 20.1 Classification of containers

20.4  SEQUENCE CONTAINERS

The STL sequence containers allow controlled sequential access to elements. Sequence containers hold data elements in a linear series, as observed in Figure 20.2. Every element is associated by its location within the series. All these elements enlarge themselves to enable the insertion of elements. These elements also allow various operations, such as copying and finding.

Fig. 20.2 Data items in sequence container.

The STL has three types of sequence containers:

• vectors
• lists
• deques

Iterators are used to get the elements in all these containers. All these containers have a different speed.

• Vectors

  We know that an array is used to store similar data elements. Elements of the array are stored in successive memory locations and are accessed in order from element number 0 onward. The vector class exactly acts similar to an array. This class is more secure and efficient than arrays.

  It is used to insert or delete an element. All the elements are accessed randomly; that is, they support random access to individual elements.

  A vector container class is accelerated to enable quick access to its elements in sequence. It is defined in the header file <vector>. A vector is able to enlarge itself. For example, if a vector declared for 5 elements is assigned 6 elements, then the vector automatically develops its size so that it can hold the 6th element. The vector class is declared in the following manner:

   

  Declaration of Vector class

   

  template <class TE>, class B =allocator <TE> class vector

  Here, the class TE is the type of element in the vector; the class B is an allocator class. M_allocators are responsible for the allocation and release of memory. By default, the new() and delete() operators are also used for the allocation and release of memory. The default constructor of the class TE is invoked to produce a new element. This allows the entry of another parameter in order to define a default constructor for the user defined classes. The vectors that hold integers and floats are declared as follows:

   

  Vector declaration for int and float data

   

  vector<int> vi   // for integer elements

  vector <float> vf // for float elements

  To declare a vector of 15 items, a constructor can be declared as follows:

  vector<item> sale(15);

  The compiler allocates memory for 15 elements. Here, the default constructor item :: item() is used.

• Lists

  The list container enables the programmer to perform the usual deletion and insertion of items. A list is also a sequence that can be accessed bi-directionally. It is defined in header file <list>. It acts as a double-linked list. Every node has a connection to both back and front nodes in the list. The iterator is used to transverse the link. The list class supports all the member functions of the vector class. The elements in the linked list are accessed using pointers. The list container has a technique known as an iterator, which is used to access the elements of the list container. An iterator is similar to a pointer. The iterator can be referenced similar to pointers to access elements.

• Deques

  A deque is similar to a multiple-ended vector. Similar to the vector class, it has the ability to perform sequential read and write operations. The deque class allows improved front-end and back-end operations. Deques are perfectly appropriate for the operation that contains insertion and deletion at one or both ends and where sequential access is essential.

20.5  ASSOCIATIVE CONTAINERS

The associative container allows fast access to the object in the container. These containers are useful for huge dynamic tables in which we can search for an element randomly and sequentially. These containers use tree-like structures of elements instead of linked lists. These structures allow quick random update and retrieval operations. Associative containers are non-sequential and allow direct access to elements; these containers are divided into four categories:

1. sets
2. multisets
3. maps
4. multimaps

All the containers listed above hold data elements in a structure called a tree. The tree provides quick finding, deletions, and insertions. These containers perform very slowly in random access operations and are inappropriate for sorting operations.

Container sets and multisets store data elements. They also allow various operations to manage them. The variable name is used as a key name. Suppose a set contains objects of the player class. It can be sorted in ascending order using the names as keys. The multiset may have multiple sets of elements; that is, it permits duplicate data elements. The set does not allow duplicate elements.

Containers map and multimap stores both key names and values. The values are associated with key names. The values can be handled using key names. The values are also called mapped values. Multimaps allow various keys. Map containers permit single keys.

20.6  ALGORITHMS

Algorithms are independent template functions. They are not members or friend functions. They enable the programmer to manipulate the data stored in various containers. Algorithms carry out operations on containers by dereferencing iterators. Each container has its functions for performing common operations. An algorithm is nothing but a function template with arguments of iterator type. Algorithms receive iterators as arguments. The iterator informs the algorithm regarding the object of the container on which the operation is to be carried out. In addition, the STL contains approximately 60 standard algorithms. These functions enable quick operations in complicated and large operations. Including the <algorithm> header file, we can use these functions. The programmer reuses all these container classes.

Table 20.1 gives non-mutating sequence operations (algorithms).

 

Table 20.1 Non-mutating sequence operation

Operators	Use
search_n( )	Searches a sequence of a given number of same elements.
find_if( )	Searches first equivalent of a predicate in a sequence.
search( )	Searches sub-sequence in other sequence.
find_first_of( )	Searches a value from one sequence in another.
find( )	Searches first presence of a value in a sequence.
find_end( )	Searches last occurrence of a value in a sequence.
adjecent_find( )	Searches contiguous pair of objects that are identical.
mismatch( )	Searches element for which two sequences vary.
count( )	Calculate presence of a value in a sequence.
count_if( )	Calculate elements that similar a predicate
equal( )	True if two series’ are the identical.
for_each( )	Performs a operation with each element.

Non-mutating sequence algorithms enable operations that do not alter the elements in a sequence. For example, the operators for_each(), find(), search(), and count(). The following program explains how to use the for_each() algorithm:

 

Explanation: The operator() is overloaded in the class show. The showvalue is an object of the class show. A vector vi is created, which can hold four elements. Using the first for loop, 0 to 3 numbers are inserted in the vector. While reading numbers from the vector instead of using the for loop, the operator for_each() is used. The first argument of in for_each() operator (vi.begin()) gives the reference of the first element. The second argument gives the reference of the last element of the vector, and the third argument (showvalue) is a function object. Thus, using the for_each() operator, members of the vector can be accessed.

 

Explanation: This program is similar to the previous one. In addition, the algorithm fill() is used. The fill() is a mutating algorithm, because it changes the elements of the vector. The following statements are used to fill the element in the vector:

   fill(vi.begin(),vi.begin() + 2,5);

The above statement fills the first 2 elements with the value 5. The function begin() gives a beginning reference, and begin() + 2 gives a reference for the second.

      fill(vi.begin()+2,vi.begin() + 4,6);

The above statement fills the value 6 at the third and fourth locations of the vector. Here also, the begin() function is used.

       fill(vi.begin()+4,vi.end(),7);

The above statement fills the value 7 from location number 5 to the end. Table 20.2 describes sorting operations (algorithms).

 

Table 20.2 Sorting operations

Operators	Use
binery_search( )	Performs a binary search on an indexed sequence
equal( )	Searches whether two sequences are equal
equal_range( )	Searches a sub-range of elements with a specified value
includes( )	Searches if a sequence is a sub-sequence of another sequence
inplace merge( )	Combines two successive sorted sequences
lexicographical_compare( )	Compares in ascending order one sequence with other
lower_bound( )	Searches the first occurrence of a given value
make_heap( )	Makes a heap from a sequence
max( )	Returns greatest of two values
max_element( )	Returns the highest elements inside a sequence
merge( )	Combines two sorted sequences
min( )	Returns smallest of two values
min_element( )	Returns the smallest number of a sequence
mismatch( )	Searches the mismatch among the elements of two sequence
nth_elements( )	Places given elements in its appropriate places
partial_sort( )	Sorts a portion of a sequence
partial_sort_copy( )	Sorts a portion of a sequence and copies
pop_heap( )	Erases the uppermost elements
push_heap( )	Appends or adds an element to heap
set_difference( )	Builds a sequence that is the variance of two ordered sets
set_intersection( )	Makes a sequence that holds the intersection of ordered sets
set_symmetric_difference( )	Yields a set that is the symmetric variance between two ordered sets
set_union( )	Yields sorted union of two ordered sets
sort( )	Sorts the sequence container
sort_heap( )	Sorts a heap
stable_partion( )	Puts elements matching an estimate first matching relative order
stable_sort( )	Sorts arranging order of similar elements
upper_bound( )	Searches the last occurrence of a given value

Table 20.3 describes mutating sequence operations (algorithms).

 

Table 20.3 Mutating sequence operations

Operators	Use
swap_ranges( )	Exchange two sequences
generate( )	Substitutes all elements with the result of an operation
copy_backward( )	Duplicate (copies) a sequence from the ends
fill( )	Fill up a series with a given value
reverse( )	Opposites (reverse) the order of elements
fill_n( )	Fill up first n elements with a given value
copy( )	Duplicates (copies) a sequence
unique( )	Erases similar contiguous elements
generate n( )	Substitutes first n elements with the result of an operation
iter_swap( )	Exchanges elements pointed to by iterator
random_shuffle( )	Inserts elements in random order
remove( )	Erases elements of a given value
replace( )	Substitutes elements with a specified value
replace_if( )	Substitute elements matching a predicate
remove_copy_if( )	Duplicates (copies) a sequence subsequently removing elements matching a predicate
unique_copy( )	Copies after removing similar contiguous elements
rotate( )	Rotates (turns) elements
remove if( )	Erases elements matching a predicate
remove copy( )	Duplicates (copies) a sequence subsequently removing a given value
replace copy( )	Duplicates (copies) a sequence substituting elements with a specified value
transform( )	Applies an action to all elements
replace_copy_if( )	Duplicates (copies) a sequence substituting elements matching a predicate
rotate_copy( )	Issues a sequence into rotate sequence
swap( )	Exchange two elements
reverse_copy( )	Copies a sequence into opposite direction

Numeric algorithms are provided in Table 20.4

 

Table 20.4 Numeric operations

Operators	Use
Inner_product( )	Collects the details of operation on a pair of sequence
Adjacent_difference( )	Creates a sequence from another sequence
Accumulate( )	Collects the return values of operation on a sequence
partial_sum( )	Creates a sequence by applying an operation on a pair of sequence

20.7  ITERATORS

Iterators acts as pointers. They are used for accessing contents of container classes. They allow movement from one element to another element, and this is known as iterating. Each container type supports one kind of iterator according to the container’s necessity. The types are input, output, forward, bi-directional, and random access. The hierarchy of iterators is shown in Figure 20.3 and described in Tables 20.5 and 20.6.

Fig. 20.3 Iterator hierarchy

Table 20.5 Operation of container classes

Table 20.6 Iterator status

Iterator status	Meaning
singular	The value of iterator does not dereference in any container.
Past-the-end	The iterator addresses to the object past the last object in the container.
dereferenceable	The iterator addresses the legal object in the container.

Iterators are used by the algorithms to carry out operations. Iterators are smart pointers. They are allowed to contain values that indicate one of the statuses of iterators as described in Table 20.10. Each iterator type supports all the attributes listed in Table 20.9 and shown in Figure 20.3. Iterators can be incremented, decremented, and their limits are up to the capacity of the containers. Containers have member functions that return iterators.

 

Explanation: In the above program, num is an object of type num_list. The member function push_back() adds a number in the list. In the for loop, the statement num_list::const_iterator ls = num.begin(); declares an iterator ls and initializes with the beginning reference of the list (reference of the first element). The second statement ls! = num.end() continues the loop until the ls points to the last element of the list. The statement ++ls dereference the iterator so that successive numbers are accessed.

20.8  VECTORS

A vector is a more useful container. Similar to an array, it also stores elements in neighboring memory locations. Each element can be directly accessed using the operator[]. A vector is able to enlarge its size if an extra element is assigned to it. A class vector has various constructors that can be used to create vector objects.

The vector class supports various functions and they are listed in Table 20.7.

 

Table 20.7 Functions of vector class

Function	Use
swap( )	Swap the elements in the given two vector
size( )	Provides the number of elements
resize( )	Changes the size of the vector
push_back( )	Appends an element to the end
pop_back( )	Erases the last elements
insert( )	Inserts items (elements) in the vector
erase( )	Erases given elements
end( )	Provides reference to the end of the vector
empty( )	Determine whether the vector is empty
clear( )	Erases entire elements from the vector
capacity( )	Provides the present capacity (limit) of the vector
begain( )	Provides a reference to the starting element
back( )	Provides a reference to the last element
at( )	Provides a reference to an element

Explanation: In the above program, e is an object of the vector class that can hold data of integer type. The member function push_back() is used to add the element in the vector object. Three integer elements 5, 8, and 9 are added to the vector. These elements are stored in contiguous memory locations. These elements can be accessed in the same manner as we access the array elements. The vector object name followed by the element number in the [ ] operator displays the specified number. Here, the overloaded operator [ ] is used.

 

Explanation: In the above program, the first for loop and the function push_back() add elements to the object e. The elements indicated by the loop variable x are stored in the object e. The second for loop and cout() statement display the contents of the object e.

The it is an iterator. The statement vector <int> :: iterator it = e.begin() declares the iterator. The iterator acts similar to a pointer. The begin() function is used to assign the reference (address) of the first element. The statement it = it+1 assigns the address of the second element where the element is to be inserted. The member function is invoked with two arguments as per the g statement e.insert (it, 7).

The first argument is an iterator that indicates the location, and the second argument is an integer value. The number 7 is inserted at the location indicated by the iterator it. The last for loop displays the contents of the vector object e after insertion.

 

Explanation: In the above program, the first for loop and the member function push_back() are used to add numbers in the vector element e. The cout() statement in the same loop displays the elements. All the elements are stored and displayed in ascending order. The member function size() returns the total number of the elements. The total number of the elements is stored in the integer variable s. The second for loop is executed in reverse order, and the value of the loop variable j is used with the object e to display the number. Thus, all the numbers are displayed in the reverse order.

 

Explanation: In the above program, e is an object of the vector that is capable of storing float values. The square roots of 5 to 12 numbers are stored in the object e. The erase() function erases the 4th and 5th elements. The variable ir is an iterator that gives the reference of the element. The erase() can be used with one or more argument. The last for loop displays the elements after deletion.

 

Explanation: In the above program, e is an object of the vector class that is capable of storing integer values. The size() member function gives the number of elements stored in the object e. The for loop and the cin statement within it reads three integers through the keyboard. The member function push_back() adds the element to the object e. It adds the element at the end. After adding elements again, the size() function displays the number of elements. It displays 3, that is the number of total elements added in the object e. The show() function is used to display the contents of the object e. The for loop and the statement cout <<e[j] are used to display the elements. The overloaded operator [ ] is used to access the specified element by the variable j.

20.9  LISTS

The list is a frequently used feature. It allows a bi-directional linear list. Element can be inserted or deleted at both the ends. The elements in the list can be accessed sequentially. Iterators are used for accessing individual elements of the list.

The list class supports various functions and they are listed in Table 20.8.

 

Table 20.8 Functions of list class

Function	Task
clear( )	Erases entire elements
back( )	Provides reference to the end elements
empty( )	Determines if the list is vacant or not
begain( )	Provides reference to the first element
erase( )	Erases given element
end( )	Provides reference of the end element of the list
merge( )	Combines two sorted lists
pop_fornt( )	Erases the first elements
pop_back( )	Erases the last elements
remove( )	Erases elements as specified
reverse( )	Reverse the list elements
insert( )	Adds given element
push_back( )	Appends an element to the end
push_front( )	Appends an element to the front
size( )	Provides the sizes of the list
unique( )	Erases the identical elements in the list
resize( )	Changes the size of the list
swap( )	Swaps the element of a list with those in the calling list
sort( )	Sorts the list elements

Explanation: In the above program, list is the object of list container class that is able to hold integer values. The push_back() functions adds elements to the list. Four integer numbers are added in the list. The show() function is used to display the numbers on the screen. The num reference variable receives the reference of the first element. The iterator n is used to display the numbers. It is used exactly as a pointer.

 

Explanation: The above program is similar to the previous one. In addition, here two elements are added to the front and rear ends of the list. The function push.front() adds elements to the front end of the list, and the function push_back() appends elements to the rear end of the list. The output shows all the elements of the list.

 

Explanation: In the above program, the member function pop_front( ) is used to delete the front element of the list, and the function pop.back() is used to delete the back element of the list. The output shows the list of numbers.

 

Explanation: In the above program, the push_back() function is used to add elements to the list object. The function sort() is used to sort the list element in ascending order. The program shows the list of elements in sorted and unsorted elements using the show() function.

 

Explanation: The above program is similar to a previous one. Here, the reverse() function arranges the list elements in reverse order. The output shows the list of elements in original and reversed order.

 

Explanation: In the above program, listX and listY are two objects of the list container. The listX is initialized with six integer elements using the push_back() functions. The statement listY = listX copies elements of the listX object to the listY object.

 

Explanation: In the above program, the objects listX and listY are initialized with three objects each with the function push_back(). The merge() function merges the elements of two list objects into one. The elements are merged in the calling object. Thus, in this program, listX calls the function, and listY is sent as an argument. The listX contains its own elements and the elements of listY. In the output, the contents of objects listX and listY are displayed.

20.10  MAPS

A map is a series of pairs of key names and values associated with it as per Figure 20.4. Access of data values depends on the key, and it is very quick. We should specify the key to get the corresponding value.

Fig. 20.4 Key and values in maps

Explanation: In the above program, using typedef statement item_map, a map variable is created. The first for loop and cin statement read two records through the keyboard. Using the member function insert() and assignment, two records are inserted. The size() member function returns the number of records. The variable t is an iterator to the map. The second for loop and the iterator produce the list of item names and code numbers. At the end, the program displays a code number that is associated with the entered item name. The item_name is a key. The list is automatically arranged in sorted order.

A map is generally also known as an associative array. The key is given with the help of the subscript operator [ ] in the following manner:

item[“PC”]=2510;

The above statement creates a record for “PC” and links it with code number 2510. The codeno is an object. It is also possible to insert and remove pairs at any point in the map. The insert() delete() function performs these tasks. Frequently used functions are described in Table 20.10.

 

Explanation: In the above program, two records are added in the map item_map. Using the size() function, the size (total number of records) is displayed; that is, the clear() function clears the contents of the map. After the clear() function, the size of the map becomes zero.

 

Table 20.9 describes important functions of map class.

 

Table 20.9 Important functions of the map class

Function	Task
clear( )	Removes all elements from the map
begin( )	Provides references of the first element
erase( )	Removes the given elements
insert( )	Inserts the elements as given
empty( )	Determines whether the map is vacant or not
end( )	Provides references to the end of the map
size( )	Provides the size of the map
find( )	Provides the location of the given elements
swap( )	Swaps the elements of the given map with those of the calling map

20.11  FUNCTION OBJECTS

A function object is a function. It is embedded in a class and hence behaves similar to an object. The class has same characteristics of a template and can be put to use with different data types. The class holds only one member function and the overloaded( )operator and never accommodates data. Function objects are frequently used as parameters for algorithms and containers.

sort ( num,num+3, greater <float>( ));

where num[] is an array. We can use an object greater<float>() to sort elements of the array in descending order. The standard template library also contains several pre-defined objects. These objects perform arithmetical and logical operations. The header file <functional> should be included while performing these operations. There are function objects that match foremost C++ operators. The variables a and b are objects of the class. K is a parameter sent to the function object. All the function objects described in Tables 20.10, 20.11, and 20.12 are defined in the functional header file.

 

Table 20.10 Relational function objects

Function object	Narration
not_equal _to<K>	a != b
equal_to<K>	a = = b
greater<K>	a > b
greater_equal<K>	a >= b
less<K>	a < b
less _equal<K>	a <= b

Table 20.11 Logical function objects

Function object	Narration
logical_and<K>	a && b
logical_not<K>	! a
logical _or<K>	a | | b

Table 20.12 Arithmetic function objects

Function object	Narration
plus<K>	a + b
divides<K>	a / b
modulus<K>	a % b
multiplies<K>	a * b
minus<K>	a – b
negate<K>	- a

Explanation: In the above program, two float arrays a[ ] and b[ ] are declared and initialized. Elements of two arrays are sorted by sort()function. The array a[ ] is sorted with the help of the function object greater<float>, and the array b[ ] is sorted without the function. At the end, the merge( ) function combines elements of both the arrays, and the resulting array is stored in the array s[ ]. The contents of the merged array are displayed.

 

Explanation: In the above program, the operator() is overloaded in the class show. The showvalue is an object of the class show. The overloaded operator() can be used with an object of the class show type similar to the statement showvalue(j); to display the value; so, it is called a function object.

1. The STL is a new expansion in C++ language. The all-famous compiler vendors give the STL as a feature of their compilers.
2. The Meng Lee and Alexander Stepanov of Hewlett Packard introduced the STL.
3. The STL is portative between different operating systems. The STL contents are defined in the namespace std.
4. The important subdivisions are as follows: (A) Containers, (B) Algorithms, (C) Iterators.
5. A container is an object that holds data or other objects. An algorithm is a process that is useful to handle the data stored in containers. The STL consists of by-guess 60 standard algorithms that give support to perform frequent and primary operations such as copying, finding, sorting, merging, and initializing.
6. An iterator is an object that is treated as a pointer. It indicates or points to data elements in a container. It is utilized to move between the data of containers.
7. The standard C++ library has a sequence of container classes. The container classes are robust and support C++ programmers in controlling common programming operations.
8. Sequence containers hold data elements in a linear series.
9. We know that an array is used to store similar data elements. The data elements are stored in continuous memory locations. The container class vector is similar to an array.
10. A vector container class is accelerated to allow quick access to its elements in sequence.
11. The list container allows the programmer the usual insertion and deletion of items. It is defined in header file <list>. It acts as a double-linked list.
12. A deque is similar to a multiple-ended vector. It has the ability similar to a vector class to perform sequential read and write operations. The deque class allows improved front-end and back-end operations.
13. The stack, queue, and priority queues are called container adaptors. All these container adaptors can be produced from unlike sequence containers.
14. Algorithms are independent template functions. They are not member or friend functions. They enable the programmer to manipulate the data stored in various containers. Each container has its functions for performing common operations.
15. Iterator acts as pointers. They are used for accessing contents of container classes.
16. The vector is a more useful container. Similar to an array, it stores elements in neighboring memory locations. Each can be directly accessed using the operator[]. A vector is able to enlarge its size if an extra element is assigned to it.
17. The list is a frequently used feature. It allows a bi-directional linear list. Elements can be inserted or deleted at both the ends.
18. A map is a series of pairs of key names and values associated with it.

(A) Answer the following questions

1. What is STL? Explain in brief.
2. Describe the different sub-divisions of STL with their definitions.
3. What are containers? Describe the types of containers with their components.
4. What do you mean by algorithms?
5. What are iterators?
6. What is the difference between an iterator and a pointer?
7. Describe any four functions of the vector class with their operations.
8. Describe any four functions of the list class with their operations.
9. What is a map? How does it work?
10. What do you mean by a function object?
11. Describe any four functions of the map class with their operations.
12. What are function objects?

(B) Answer the following by selecting the appropriate option

1. A container is an object that
   1. stores data
   2. temporarily holds data
   3. both (a) and (b)
   4. none of the above
2. An algorithm is a process that
   1. processes the data
   2. stores the data
   3. sorts the data
   4. none of the above
3. An iterator is similar to
   1. a pointer
   2. an array
   3. a class
   4. none of the above
4. The function object is similar to
   1. an object
   2. a variable
   3. both (a) and (b)
   4. none of the above
5. Algorithms are a part of
   1. a standard template library
   2. a class template
   3. an iostream
   4. none of the above

(C) Attempt the following programs

1. Write a program to demonstrate the use of operators for_each().
2. Write a program to create function objects.
3. Write a program to manipulate a list of item names and their code numbers using maps.
4. Write a program to copy the elements of one list object to another object. Display the contents of both the objects.
5. Write a program to merge two lists and display the merged list.
6. Write a program to demonstrate the use of the fill() algorithm.
7. Write a program to transverse lists using iterators.
8. Write a program to add and display elements in the vector object.
9. Write a program to add elements to both ends of the list and display the numbers.
10. Write a program to insert an element in the vector object. Use member functions and iterators.