Computer Application and Practice 2: Templates and the Standard Template Library

Transcription

1 Computer Application and Practice 2: Templates and the Standard Template Library 2014 Instructor: Young-guk Ha Dept. of Computer Science & Engineering

2 Contents Basics on templates Template classes Template instantiations Standard Template Library (STL) Containers Basic containers Container adaptors Iterators Algorithms 2

3 Template Classes Blueprints for general-purpose classes Template classes are not data-type specific Created with more than one class parameters, which are placeholders for specific data types Also called as parameterized classes Template classes promote code reuse in C++ If we write an Array template class once, we can reuse the template class to create Arrays of any data type Without template classes, we need to write Class IntArray for array of ints Class CharArray for array of chars Class StringArray, 3

4 Without Template Classes Class IntArray Class CharArray Class X-Array Integer Array Character Array X-type Array 4

5 Using Template Classes Class Parameters: int, char, X-type, Template Class Array<param> Class Array<int> Class Array<char> Class Array<X-type> Integer Array Character Array X-type Array 5

6 Declaring Template Classes template<class param1, class param2,...> class class_name {... or Template header template<typename param1, typename param2,...> class class_name {... 6

7 Defining Template Class Methods template<class p1, class p2,...> class class_name { public: return_type method_name(... ) { or template<class p1, class p2,...> return_type class_name<p1, p2,...>::method_name(... ) {... 7

8 class intarray { public: int& operator[](int); intarray(int); ~intarray(); // private: int* a; int size; // ; intarray::intarray(int s) { a = new int[size = s]; // intarray a1(10); class chararray { public: char& operator[](int); chararray(int); ~chararray(); // private: char* a; int size; // ; chararray::chararray(int s) { a = new char[size = s]; // chararray a2(50); Classes vs. Template Classes With template class Array template<class T> class Array { public: T& operator[](int); Array(int); ~Array(); // private: T* a; int size; // ; template<class T> Array<T>::Array(int s) { a = new T[size = s]; // Array<int> a1(10); Array<char> a2(50); Array<string> a3(20); // 8

9 Template Instantiation To use a template class, we must instantiate it with a specific data type A data type must be specified within angled brackets E.g., the previous template class Array template<class T> class Array {... ; If we instantiate Array<T> to Array<double> as follows Array<double> a1(100); // type of a1 is Array<double> Then the compiler replaces occurrences of T in the instantiation with double, thus the declaration T& operator[](int); T* a; are changed into double& operator[](int); double* a; 9

10 Template Instantiation (cont.) Un-instantiated template classes can not create their objects template<class T> class Array {... ; Array a0(50); //***** ERROR: not an instantiation Array<T> a1(50); //***** ERROR: not an instantiation template<class T> Array<T> a2(50); //***** ERROR: not an instantiation Array<int> a3(50); // OK, int instantiation A template class can be instantiated with either a built-in or a user-defined data type // user-defined data type Task class Task {... ; Array<Task> tasks(500); // Task instantiation 10

11 Template Classes in a Parameter List A template class may occur as a data type in a parameter list template<class T> ostream& operator<<(ostream& os, const Array<T>& ar) { for (int i = 0; i < ar.get_size(); i++) os << ar[i] << endl; // built-in << return os;... Array<int> a(3); a[0] = 0; a[1] = 1; a[2] = 2; cout << a; // overloaded <<

12 Function-Style Parameters Parameters for a template class Class parameters A template class MUST have one or more class parameters Function-style parameters May have any number of function-style parameters Data type can be either built-in or user-defined // just using a class parameter template<class T> Array<T>::Array(int s) { a = new T[size = s] Array<double> a1(10); Array<char> a2(50); // using function-style param. s template<class T, int s> Array<T, s>::array() { a = new T[size = s] Array<double, 10> a1; Array<char, 50> a2; Array<float> a3; // ERROR: missing arg. for s 12

13 Standard Template Library (STL) A part of standard C++ library STL has very powerful features in its own right Consists of template classes to provide containers for data and template functions to process data in containers Also has significant impact on the organization of other C++ libraries E.g., Active Template Library (ATL) and Windows Template Library (WTL) 13

14 Basic Components of STL STL s three basic components are containers, algorithms, and iterators Containers Collection of data structures implemented with template classes E.g., vectors, deques, lists, sets, maps, stacks, queues, Algorithms Recipes or procedures for processing containers contents, which are implemented with template functions E.g., sort, copy, reverse, search, merge, permute, Iterators Provides a unified mechanism for accessing contents in containers one at a time (high-level alternatives for looping constructs such as for and while) To move through containers from front to back, from back to front, in either direction, and randomly In any case, STL algorithms use iterators to process containers 14

15 Advantages of STL STL becomes increasingly popular among C++ programmers due to its advantages Efficiency STL offers assortment of containers delegated to perform storage management which is tedious and prone to error Flexibility Users can use various algorithms with iterators regardless of the types of containers Ease of use STL containers and algorithms are intuitive and easy to apply Extensibility Users can add new containers and algorithms to STL 15

16 Containers STL has 7 basic containers divided into 2 types Sequential containers Represent sequences of elements accessed by positions (list) or indices (vector and deque) vector and deque overload the subscript operator [] Associative containers Represent collections of elements accessed by unique keys Type Container Description Sequential Associative list vector deque set multiset map multimap Bidirectional linked list of elements Array that grows and shrinks as needed Array with efficient insertions/deletions at either end Collection of nonduplicate keys A set with duplicates allowed Collection of nonduplicate elements accessed by keys A map with duplicates allowed 16

17 Sequential Container: Vector Basics on vectors A list that supports access to its elements by their indices Commonly, a vector can be instantiated without its size, because a vector grows and shrinks automatically Even instantiated with its size, a vector still grows automatically if required Operations Directly accessed by subscript operator [] Basic methods: size(), begin(), end(), insert(), erase() E.g.) vector<int> v; for (i = 0; i < 100; i++) v[i] = 1; v[70] = 3; v : v.begin() v[70] v.end() end() returns the iterator that points just beyond the end element 17

18 Accessing Elements with Iterators STL containers have associated iterator data types E.g., vector<int> has iterators with the following type vector<int>::iterator vector<int>::const_iterator Note that const_iterator is used if the iteration does not change any element A sequential container provides methods that return iterators that mark its beginning and end begin() returns the iterator that points the first element end() returns the iterator that points just beyond the last element Such methods allow us to loop safely without knowing how many elements happen to be in a container vector<int>::const_iterator it; it = v.begin(); // initializes iterator for vector v while (it!= v.end()) { // is the iterator at the end? cout << *it << endl; // prints the element pointed by it it++; // increments the iterator // *** iterators are handled just like pointers 18

19 Insertion into a Vector Suppose a vector v has n elements initially In operation v.insert(it, e), where it is an iterator pointing ith element, we need to make room for the new element by shifting forward the n - i elements (v[i],, v[n - 1]) Thus, the insert operation runs in O(n) time Note that insert at the end (it = v.end()) takes just O(1) time it v.end() v v n-1 i n i v.end() O(n) time means linear time directly propositional to n, O(1) time means constan time v e i n 19

20 Deletion from a Vector In operation v.erase(it), where it is an iterator pointing ith element, we need to fill the hole left by the removed element by shifting backward the n - i - 1 elements (v[i + 1],, v[n - 1]) The erase operation runs in O(n) time Note that erase at (n - 1)th index (i = n - 1) takes just O(1) time it v.end() v e i n-1 v i n-1 v.end() v i n-2 20

21 Example of Using a Vector Insertions and deletions at each end of a vector #include <iostream> #include <vector> using namespace std; void main() { vector<int> nums; nums.insert(nums.begin(), -999); // [ -999 ] nums.insert(nums.begin(), 14); // [ ] nums.insert(nums.end(), 57); // [ ] for(int i = 0; i < nums.size(); i++) cout << nums[i] << endl; // prints " " cout << endl; nums.erase(nums.begin()); nums.erase(nums.begin()); // 14 erased // -999 erased, 57 left for(int i = 0; i < nums.size(); i++) cout << nums[i] << endl; // prints "57" 21

22 Sequential Container: Deque N-1 A deque is almost the same as a vector If we replace vector with deque in the previous example, the output is exactly the same They differ in their underlying implementation, in particular with respect to insertions and deletions A vector generally requires O(n) time for insertions and deletions, but O(1) time for insertions and deletions at the end Efficient for applications in which insertions and deletions are typically done at the end A deque requires O(1) time for insertions and deletions at the beginning or at the end Thus, it is efficient for applications in which insertions and deletions are typically done at both ends Note that a deque takes more time than a vector for insertions and deletions at the end due to using a circular array mechanism Deque f r N-1 No shifting required for insertions and deletions at both ends, it maintains two pointers f and r for both ends in a circular fashion 22

23 Sequential Container: List The list container is a bidirectional node list Implemented as a doubly linked list Node implementation includes Reference to an element Link to the previous node Link to the next node Special trailer and header nodes Header points to the beginning Trailer points to the end prev elem next node header nodes trailer elements 23

24 l : l : Insertion into a List Visualization of l.insert(it, e), which takes O(1) time All we need to do is to move 4 links it a b c it a b c it e l : a b e c 24

25 Deletion from a List Visualization of l.remove(l.end()), which also takes O(1) time l : l : l.end() A B C D A B C X X D l : A B C 25

26 Example of Using a List #include <iostream> #include <string> #include <list> using namespace std; void dump(list<string>& l) { list<string>::const_iterator it; it = l.begin(); while (it!= l.end()) { cout << *it << endl; it++; // list iterator it // initialize it // is it at the end? // increment it void main() { list<string> names; names.insert(names.begin(), "Kamiko"); // [Kamiko] names.insert(names.end(), "Andre"); // [Kamiko Andre] names.insert(names.begin(), "Chengwen"); // [Chengwen Kamiko Andre] names.insert(names.begin(), "Maria"); // [Maris Chengwen...] dump(names); // prints "Maria Chengwen Kamiko Andre" names.reverse(); // reverse the list dump(names); // prints "Andre Kamiko Chengwen Maria" 26

27 Time Complexity of vectors, deques, and lists Operations vector deque list Insert/delete at the beginning Linear Constant Constant Insert/delete at the end Constant Constant Constant Insert/delete in the middle Linear Linear Constant Access the first element Constant Constant Constant Access the last element Constant Constant Constant Access the middle element Constant Constant Linear Linear = O(n), Constant = O(1) 27

28 Associative Containers The four basic associative containers in this chapter fall into the following two groups Sets A collection of zero or more nonduplicate, unordered keys E.g.) { jobs, gates, ellison A multiset is a set that allows duplicate keys E.g.) { jobs, gates, jobs, ellison, gates Maps A collection of zero or more nonduplicate, unordered (key, value) pairs Each pair has a nonduplicate key and a value associated with the key E.g.) { (jobs, apple), (gates, microsoft), (ellison, oracle) A multimap is a map that allows duplicate keys E.g.) { (jobs, apple), (gates, microsoft), (jobs, apple) 28

29 Sets The insert method of set class ensures that the set does not contain duplicate keys Without specified position s.insert(123); // insert somewhere of set s It can also be invoked in similar fashion to a vector s, s.insert(s.begin(), 66) // insert at the beginning of set s s.insert(s.end(), 99); // insert at the end of set s Unlike a vector, keys of a set do NOT ordered or accessed directly by index The set provides the find method It checks whether a set contains a specified key If so, it returns an iterator that marks the key Otherwise, returns an iterator that marks the end it = s.find(123); if (it == s.end()) throw string( key not found ); 29

30 Example of Using a Set #include <iostream> #include <set> using namespace std; void main() { set<int> s; s.insert(-999); s.insert(18); s.insert(321); s.insert(-999); // not inserted, duplicates not allowed set<int>::const_iterator it; it = s.begin(); while (it!= s.end()) cout << *it++ << endl; int key; cout << Enter an integer: "; cin >> key; it = s.find(key); if (it == s.end()) // if not found cout << key << " is not in set." << endl; else cout << key << " is in set." << endl; Prints -999, 18, 321 in some order 30

31 Maps A map is an association list, i.e., a list that associates a key with a value Thus, it is instantiated with two parameters key and value map<string, int> m1; map<int, float> m2; // string key, int value // int key, float value A map provides two ways to insert and access (key, value) pairs Like all other basic containers, it provides an insert method and as an associate container, it provides a find method In addition, it overloads subscript operator [] for both insertions and accesses m1[ one ] = 10; // == m1.insert( one, 10) m1[ two ] = 20; // == m1.insert( two, 20) m2[1] = 10.0; // == m2.insert(1, 10.0) m2[2] = 20.0; // == m2.insert(2, 20.0) cout >> m1[ one ] >> endl >> m2[1] >> endl; // prints 10 and

32 Example of Using a Map #include <iostream> #include <string> #include <map> using namespace std; void main() { map<string, int> m; m["zero"] = 0; m["one"] = 1; m["two"] = 2; m["three"] = 3; m["four"] = 4; m["five"] = 5; m["six"] = 6; m["seven"] = 7; m["eight"] = 8; m["nine"] = 9; cout << m["one"] << endl // prints 1 << m["three"] << endl // prints 3 << m["five"] << endl; // prints m["one"] = -1; // a duplicate pair cancels the previous association cout << m["one"] << endl; // prints -1 32

33 Container Adaptors Adapts a container to behave in a particular way Three basic container adaptors stack: creates LIFO (Last In First Out) list queue: creates FIFO (First In First Out) list priority_queue: creates a queue whose elements are removed in some priority (descending) order push top pop push push 1 rear top front front pop Stack Queue Priority queue top pop 33

34 stack Adaptor Adapts a deque container by default Definition stack<char> s; is equivalent to stack<char, deque<char>> s; We could force to adapt a vector stack<char, vector<char>> s; Methods push(e): inserts given element e into the stack pop(): removes the top element from the stack (returns void, normally follows top) top(): returns the top element of the stack without removing it empty(): returns whether the stack is empty or not (returns bool) 34

35 Example of Using stack (1/2) Reversing expression Original expression: (1 + 2) * 3 Output expression: 3*(2+1) buf (1 + 2) * 3 ) ( ( ) 3*(2+1) Output top 3 * ) ( Stack s 35

36 Example of Using stack (2/2) #include <iostream> #include <cctype> #include <stack> using namespace std; int main() { const string prompt = "Enter an algebraic expression: "; const char lparen = '('; const char rparen = ')'; stack<char> s; string buf; // read an algebraic expr. cout << prompt << endl; getline(cin, buf); // push chars into the stack for (int i=0; i<buf.length(); i++) if(!isspace(buf[i]) s.push(buf[i]); cout << "Original expression: " << buf << endl; // print reversed expr. cout << "Expression in reverse: "; // pop chars from the stack while (!s.empty()) { char t = s.top(); // get top s.pop(); // remove top if (t == lparen) t = rparen; else if (t == rparen) t = lparen; cout << t; cout << endl; return 0; 36

37 queue Adaptor Adapts a deque container by default Definition queue<int> q; is equivalent to queue<int, deque<int>> q; We could also force to adapt a vector queue<int, vector<int>> q; Methods push(e): inserts given element e into the queue pop(): removes the front element from the queue (returns void, normally follows front) front(): returns the front element of the queue without removing it empty(): returns whether the queue is empty or not (returns bool) 37

38 Example of Using queue #include <iostream> #include <queue> using namespace std; int main() { queue<int> q; // == queue<int, deque<int>> q.push(1); q.push(3); q.push(5); q.push(7); q.push(11); // pop and print until the queue is empty // output is while(!q.empty()) { cout << q.front() << endl; // returns an integer q.pop(); // returns void return 0; 38

39 priority_queue Adaptor Adapts a vector container by default Definition priority_queue<int> s; is equivalent to priority_queue<int, vector<int>> s; Ensures that a priority order is maintained during removals E.g., a priority_queue of integers might removes the integers in a descending order by value (i.e., large value first) Methods push(e): inserts given element e into the priority_queue pop(): removes the next priority element from the priority_queue (returns void, normally follows top) top(): returns the next priority element of the priority_queue without removing it empty(): returns whether the priority_queue is empty or not (returns bool) 39

40 Example of Using priority_queue #include <iostream> #include <functional> #include <cstdlib> #include <ctime> #include <queue> using namespace std; void main() { const int howmany = 8; int i; priority_queue<int> nums; srand(time(0)); // insert pseudo-random ints for (i = 0; i < howmany; i++) { int next = rand(); cout << next << endl; nums.push(next); // print ints in desc. order cout << \n*** Priority by value: << endl; for (i = 0; i < howmany; i++) { cout << nums.top() << endl; nums.pop(); *** Priority by value:

41 Other Containers The string class and the bitset class qualify as containers in the STL sense string class chars as string elements can be processed by STL iterators and algorithms such as find, for_each, random_shuffle Has the begin and end methods of the STL standard containers bitset class A bitset is a sequence of binary digits, e.g., Can be used to represent an integer in binary Has many methods to manipulate, evaluate and convert bits, e.g., invert, test, shift, and, or, xor, convert to int, Has overloaded [] to access individual bits with an index bitset<8> bs1; // bs1 = bitset<128> bs2; // bs2 = (128 0s) bitset<8> bs3(9); // bs3 = (= 9) if (bs3[0] == true)... ; // rightmost bit is indexed 0 41

42 Example of Using bitset #include <iostream> #include <bitset> using namespace std; const featurecount = 8; const unsigned Framed = 1; // const unsigned Bordered = 2; // const unsigned StdMenu = 4; // const unsigned ToolBar = 8; // const unsigned StatusBar = 16;// class Window { public: Window(const string& n, unsigned f) { name = n; features = bitset<featurecount> (f); createwindow(); Window(const char* n, unsigned f) { name = n; features = bitset<featurecount> (f); createwindow(); private: void createwindow() { cout << "\n*** Window features for << name << " given bit mask " if (features[0]) // 1st (rightmost) bit set? cout << "\t" << "framed" << endl; if (features[1]) // 2nd bit set? cout << "\t" << "bordered" << endl; if (features[2]) // 3rd bit set? cout << "\t << "with standard menu" << endl; if (features[3]) // 4th bit set? cout << "\t" << "with tool bar" << endl; if (features[4]) // 5th bit set? cout << "\t" << "with status bar" << endl; string name; bitset< featurecount > features; ; int main() { Window w1("w1", Framed ToolBar StatusBar); Window w2("w2", ToolBar Framed StatusBar); Window w3("w3", Framed StdMenu StatusBar ToolBar Bordered); return 0; << features << ":" << endl; 42

43 The Output of the bitset Example *** Window features for w1 given bit mask : framed with tool bar with status bar *** Window features for w2 given bit mask : framed with tool bar with status bar *** Window features for w3 given bit mask : framed bordered with standard menu with tool bar with status bar 43

44 STL Algorithms STL has rich assortment of algorithms for processing containers, which fall into some standard categories Sorting and searching Numerical processing Set operations Copying Algorithms are implemented as template functions STL containers are implemented as template classes STL algorithms processes a container by using iterators to traverse the container It does NOT require any container-specific information Works the same way on each container to be processed 44

45 Example of Manipulating a string with STL algorithms #include <iostream> #include <string> #include <algorithm> using namespace std; void printchar(char c) { cout << c; void main() { string s= Pele, the greatest ever"; cout << s: " << s << endl; cout << "s in reverse: "; for_each(s.rbegin(), s.rend(), printchar); // uses reverse iterators cout << endl; char* where = find(s.begin(), s.end(), 'a'); cout << 'a' is the << where - s.begin() + 1 << "th char in: " << s << endl; random_shuffle(s.begin(), s.end()); cout << "s after a random shuffle: " << s << endl; where = find(s.begin(), s.end(), 'a'); cout << "'a' is the << where - s.begin() + 1 << "th char in: " << s << endl; sort(s.begin(), s.end()); cout << "sorted in ascending order: " << s << endl; 45

46 reverse Algorithm The reverse algorithm uses iterators to put the container s elements in reverse order The prototype of reverse algorithm template<class BidirectionalIterator> // template header void reverse(bidirectionaliterator it1, // iterator 1 BidirectionalIterator it2); // iterator 2 With the BidirectionalIterator, the reverse algorithm can traverse a container either from beginning to end, or from end to beginning The reverse algorithm can not (or need not) distinguish between different containers, i.e., a vector and a deque 46

47 Example of Algorithms generate, replace_if, sort, and for_each // include other required headers... #include <algorithm> // for STL algorithm using namespace std; void dump(int i) { cout << i << endl; bool odd(int i) { return i % 2!= 0; bool comp(const int& i1, const int& i2) { return i1 > i2; // reverse comparator void main() { vector<int> v(10); // vector of 10 integers... // fill with random integers genearte(v.begin(), v.end(), rand); // replace odds with 0 replace_if(v.begin(), v.end(), odd, 0); // sort in descending order (ascending if comp is omitted) sort(v.begin(), v.end(), comp); // print all the integers in v for_each(v.begin(), v.end(), dump); 47

48 Output Stream Iterator A special STL iterator used to do output Instantiating an output iterator ostream_iterator<output_data_type> iterator_name(output_stream, separator) E.g.) ostream_iterator<char> oit(cout, " ") Instantiate an output iterator oit that outputs each char data to cout, which is separated by a blank // Outputs first 32th Fibonacci // numbers to a disk file and cout vector<int> fibs(32); fibs[0] = fibs[1] = 1; for (int i = 2; i < 32; i++) fibs[i] = fibs[i 1] + fibs[i-2]; ofstream outfile("output.dat"); ostream_iterator<int> outfileit(outfile, " "); ostream_iterator<int> stdoutit(cout, "\n"); copy(fibs.begin(), fibs.end(), outfileit); copy(fibs.begin(), fibs.end(), stdoutit); STL also provides input stream iterators for copying from input streams into variables or containers such as vectors and deques 48

49 Example of Algorithms nth_element, random_shuffle, and copy // include required headers... void main(){ const int len = 27; const int med = len / 2; // med = 13 char alph[] = "abcdefghijklmnopqrstuvwxyz{"; print("\n\noriginal array:\n", alph, len); // len(= 27) chars random_shuffle(alph, alph + len); print("\n\nafter random-shuffle:\n", alph, len); nth_element(alph, alph + med, alph + len); print("\n\nafter nth elemnet:\n", alph, len); print("\n\t < median: ", alph, med); print("\n\t median: ", alph + med, 1); print("\n\t > median: ", alph + med + 1, len / 2); cout << endl; void print(const char* msg, char a[], int len) { cout << msg; copy(a, a + len, ostream_iterator<char>(cout, " ")); Place the posth (= alph+med+1th) element in the position it would occupy if the sequence were sorted ascending and any element to the left of pos any element to the right of pos 49

50 The Output of the Previous Example Original array: a b c d e f g h i j k l m n o p q r s t u v w x y z { After random_shuffle: e t a r k m { l s y g q h o j x u z w p n b f d v c i After nth element: e i a c d f b h g j k l m n o p q r s t u v { w z x y < median: e i a c d f b h g j k l m median: n > median: o p q r s t u v { w z x y 50