Vector as ADT

1. Vector ADT

2. Abstract Data Type (ADT)
High-level definition of data types
An ADT specifies
 A collection of data
 A set of operations on the data or subsets of the data
ADT does not specify how the operations should be
implemented
Examples
 vector, list, stack, queue, deque, priority queue, table (map),
associative array, set, graph, digraph

3. The Vector ADT
Generic arrays

4. The Vector ADT
Extends the notion of array by storing a
sequence of arbitrary objects
Elements of vector ADT can be accessed
by specifying their index.

5. Vectors in STL
 Collection  Elements of some proper type T
 Operations
 int size()  returns the number of elements in the vector
 void clear()  removes all elementes from the vector
 bool empty()  returns true of the vector has no elements
 void push_back ( const Object &x )
adds x to the end of the vector
 void pop_back ( )
Removes the object at the end of the vector
 Object & back ( )
Returns the object at the end of the vector
 Object & front ( )
Returns the object at the front of the vector

6. Vectors in STL (contd.)
More Operations
 Object & operator[] ( int index )
Returns the object at location index (without bounds checking)
Both accessor and mutator versions
 Object & at( int index )
Returns the object at location index (with bounds checking)
 int capacity()
Returns the internal capacity of the vector
 void reserve(int newCapacity)
Sets the new capacity of the vector
 void resize(int newSize )
Change the size of the vector

7. Implementing Vector Class Template
Vector maintains
 A primitive C++ array
 The array capacity
 The current number of items stored in the Vector
Operations:
 Copy constructor
 operator=
 Destructor to reclaim primitive array.
 All the other operators we saw earlier.

8. Vector Implementation (Part 1)
Constructor
Copy Constructor
deep copy assignment

9. Vector Implementation (Part 2)
Expand to twice as large
because memory allocation
is an expensive operation

10. Vector Implementation (Part 3)
No error checking

11. Vector Implementation (Part 4)
Same as pointers to Object

12. 12
Standard Containers: Vectors
Adapted from Nyhoff, ADTs, Data Structures and Problem Solving with C++

13. 13
STL (Standard Template Library)
A library of class and function templates
Components:
1. Containers:
Generic "off-the-shelf" class templates for storing
collections of data
1. Algorithms:
Generic "off-the-shelf" function templates for operating
on containers
1. Iterators:
Generalized "smart" pointers provide a generic way to
access container elements

14. 14
Standard Template Library
Example of a specific
container class
iterator
algorithm

15. 15
STL's 10 Containers
Kind of Container STL Containers
Sequential: deque, list,
vector
Associative: map, multimap,
multiset, set
Adapters: priority_queue,
queue, stack

16. 16
The vector Container
A type-independent pattern for an array
class
capacity can expand
self contained
Declaration
template <typename T>
class vector
{ . . . } ;

17. 17
The vector Container
Constructors
vector<T> v, // empty vector
v1(100), // 100 elements of type T
v2(100, val), // 100 copies of val
v3(fptr,lptr); // contains copies of
// elements in memory
// locations fptr to lptr
int intArray[5] = {9,2,7,3,12};
Int arrSize = sizeof(intArray)/sizeof(int);
vector<int> intVector(intArray, intArray+arrSize);

18. 18
vector Operations
Information about a vector's contents
v.size()
v.empty()
v.capacity()
v.reserve(n)
Adding, removing, accessing elements
v.push_back(value)
v.pop_back()
v.front()
v.back()

19. 19
vector Operations
Assignment
v1 = v2
Swapping
v1.swap(v2)
Relational operators
== implies element by element equality
less than < behaves like string comparison

20. 20
Increasing Capacity of a Vector
When vector v becomes full
capacity increased automatically when item added
Algorithm to increase capacity of vector<T>
Allocate new array to store vector's elements (how
big)
use T copy constructor to copy existing elements to
new array (therefore your class must have copy constructor)
Store item being added in new array
Destroy old array in vector<T>
Make new array the vector<T>'s storage array
Expansion by addition is possible but costly

21. 21
Increasing Capacity of a Vector
Allocate new array
Capacity doubles when more space needed
Elements copied to new array

22. 22
Increasing Capacity of a Vector
Item being added now stored
Destroy old array
Make new array
the vector's storage
area

23. 23
Iterators
A subscript operator is provided
BUT … this is not a generic way to access
container elements
STL provides objects called iterators
can point at an element
can access the value within that element
can move from one element to another
They are independent of any particular
container … thus a generic mechanism

24. 24
Iterators
Given a vector which has had values
placed in the first 4 locations:
v.begin() will return the iterator value
for the first slot,
v.end() for the next empty slot
9 4 15 3
vector<int> v
v.begin()v.begin() v.end()v.end()

25. 25
Iterators
Each STL container declares an iterator type
can be used to define iterator objects
To declare an iterator object
the identifier iterator must be preceded by
name of container
scope operator ::
Example:
vector<int>::iterator vecIter = v.begin()

26. 26
Iterators
Basic operators that can be applied to
iterators:
increment operator ++
decrement operator --
dereferencing operator *
Assignment =
Addition, subtraction +, -, +=, -=
vecIter + n returns iterator positioned n
elements away
Subscript operator [ ]
vecIter[n] returns reference to nth
element from
current position

27. 27
Iterators
Contrast use of subscript vs. use of iterator
ostream & operator<<(ostream & out, const
vector<double> & v)
{
for (int i = 0; i < v.size(); i++)
out << v[i] << " ";
return out;
} for (vector<double>::iterator it = v.begin();
it != v.end(); it++)
out << *it << " ";

28. 28
Iterator Functions
Operators: ++, --, *, =. ==, !=, +, -, [ ]
Vector Functions: v.begin(), v.end(), v.rbegin(), v.rend(),
v.insert(iter, value), v.insert(iter,n,value), v.erase(iter), v.erase(iter1,iter2)
Note the capability of the last two groupings
Possible to insert, erase elements of a vector
anywhere in the vector
Must use iterators to do this
Note also these operations are as inefficient as for
arrays due to the shifting required
v.insert(iter, n, value)
v.erase(iter )
v.erase(iter1, iter2)

29. 29
Contrast Vectors and Arrays
Vectors Arrays
• Capacity can increase
• A self contained object
• Is a class template
• Has function members
to do tasks
• Fixed size, cannot be
changed during execution
(unless using dynamic alloc)
• Cannot "operate" on
itself
•Must "re-invent the
wheel" for most actions