The pair class is part of the C++ standard
template library (STL). It is defined in the
the utility library and acts as a simple
container of two values. We
write pair<T1,T2> to create an object of
two values. The first value has type T1; the
second has type T2. For isntance,
a pair<int,string> is an object with a
field first of type int and a
field second of type string.
Unlike the classes we have been writing, the pair
class knows how to make copies of itself by assignment; that is,
you can use = assignment with a pair just like you
would with an int. Consider the following code:
pair<int,string> p1(4, "apple"); // create an int*string pair pair<int,string> p2 = p1; // copy the values from p1 into p2 p1.first = 5; // change p1's integer to 5 cout << p2.first << endl; // prints 4, since p2's int is a different variable pair<int,string>* ptr1 = new pair<int,string>(8,"orange"); // dynamically allocate a pair pair<int,string>* ptr2 = ptr1; // this copies the *pointer*, not the pair ptr1->first = 10; // change the dynamically-allocated object's integer to 10 cout << ptr2->first << endl; // prints 10, since both pointers point to the same pair object
In the above, p1 and p2
are statically-allocated objects. Although none of the
statically allocated objects we have used so far have been
copyable (other than string
objects), pair objects can be copied. Note how
copying a pair object is different from copying
a pair pointer. In this lab, you won’t need
any pair pointers, so you don’t really need to worry
about that case.
The vector<T> class, found in
the vector library, is the C++ STL implementation of an array list. It is used somewhat differently from our List<T> interface. Here’s a handy translation guide:
| Operation | List code |
vector code |
|---|---|---|
| Insert at front | myList.insertAtHead(value) |
no simple equivalent |
| Insert at back | myList.insertAtTail(value) |
myVector.push_back(value) |
| Determine size | myList.getSize() |
myVector.size() |
| Get element by index | myList.get(index) |
myVector[index] |
| Set element by index | no equivalent | myVector[index] = value |
| Remove from back | myList.removeTail() |
myVector.pop_back() |
One other difference is that the pop_back method
is void; you must retrieve the last element yourself if
you want to see that element before it is removed.
The primary reason that we introduce vector for this
class is because vectors can also be copied just
like pairs. Consider the following code:
List<int>* listPointer1 = new STLList<int>; // create a pointer to a new List List<int>* listPointer2 = listPointer1; // copy the pointer listPointer1->insertAtTail(4); // add an element cout << listPointer2->getSize() << endl; // prints 1; they point to the same List LinkedList<int> list1; // create a statically-allocated list LinkedList<int> list2 = list1; // illegal! Lists don't know how to copy themselves! vector<int> vector1; // create a statically-allocated vector1.push_back(4); vector1.push_back(6); vector<int> vector2 = vector1; // vectors do know how to copy themselves cout << vector2.size() << endl; // prints 2 (since both elements were copied) vector1[0] = 2; // assigns 2 to the first position of vector 1 cout << vector2[0] << endl; // prints 4; vector 2 is a different vector