Containers in C++ and Java

Transcription

1 Containers in C++ and Java 1

2 1. Which of the following statements is true? a) Equality on the basis of reference implies equality on the basis of content. b) Equality on the basis of content implies equality on the basis of reference. 2

3 2. Consider the following two Java program fragments with two variables s1 and s2 holding references to the String objects as shown: String s1 = new String( "hello" ); String s1 = "hello"; String s2 = new String( "hello" ); String s2 = "hello"; Is s1 == s2 true? Is s1 == s2 true? Give reasons for your answser. 3

4 3. Java says to use the method equals() to test strings for equality of content. In which case below would this work? CASE 1: String s1 = new String( "Hello" ); String s2 = new String( "Hello" ); System.out.println( ( s1.equals( s2 ) ) + "" ); //??? CASE 2: StringBuffer s3 = new StringBuffer( "Hello" ); StringBuffer s4 = new StringBuffer( "Hello" ); System.out.println( ( s3.equals( s4 ) ) + "" ); //??? 4

5 4. In general, Java does not allow for operator overloading. There is only one exception to this rule. Which operator and for what type? 5

6 5. Since the operator + has not been overloaded for the StringBuffer type, how would you join two StringBuffer strings? 6

7 6. In general, suppose I define a class X in Java class X { } and construct two objects x1 and x2 of type X. Will there be any difference between what is returned by and by x1 == x2 x1.equals( x2 ) 7

8 7. Now that you have gained some insights into the class string in C++, do you see why you need to have private data members in a class? 8

9 Container Classes What are the two most widely used containers for holding together multiple items of data in a majority of programming languages? 9

10 Arrays Linked Lists 10

11 But for heavy-duty programming, both arrays and linked lists suffer from limitations. What are these limitations? 11

12 The container classes that are a part of the C++ Standard Template Library (STL) and those that come with the Java Collections Framework are designed to fix the shortcomings of plain arrays and linked lists. 12

13 In addition to the container classes, the C++ Standard Template Library and the Java Collections Framework also contain support for various algorithms that can be used with the containers for sorting, searching, inserting, deleting, shuffling, etc. 13

14 C++ Containers STL consists of the following ten main container classes: vector list deque stack queue priority queue map set multimap and multiset 14

15 Sequence Containers vector: Particularly efficient for random access of data elements using array like indexing. list: Particularly efficient for all kinds of list operations, meaning insertion and deletion of elements anywhere in a list, including the addition and deletion of elements at both its ends. deque: Combines the best of vector and list with regard to subscripting via the [] operator and the add/delete operations at both ends of a data sequence stored in a deque. 15

16 Operation vector deque list Efficiency for array-like access O(1) O(1) O(N) Efficiency for insert/delete at front O(N) O(1)+ O(1) Efficiency for insert/delete at back O(1)+ O(1)+ O(1) Efficiency for insert/delete in middle O(N) O(N) O(1) 16

17 Adapters stack: Only supports storage and retrieval at the back end of a sequence of data. That means that the only data element that can be retrieved is the one that was pushed most recently into the stack. queue: Only supports storage and retrieval at the front end of a sequence of data. That means that the very first data element that was pushed into the queue is the only one that is available for retrieval. priority queue: In a priority queue, the elements are stored in a sorted order on the basis of a priority value associated with each element. 17

18 Associative Containers map: This container is used to store a sequence of (key, value) pairs. set: A set is a degenerate form of a map in that no value need be specified for the keys. Therefore, in contrast with, say, a vector or a list, the list of objects (meaning the keys) is stored in a sorted order. multimap: A more general form of map. multiset: A multiset is a degenerate form of a multimap in which no value need be specified for the keys. 18

19 C++ vector: A vector is like an array that can grow and shrink as elements are added to or removed from the vector Since vectors allow for array-like indexing, they can be used very much like arrays. In addition, since vectors allow new elements to be inserted anywhere, they can be used very much like linked lists. The random access efficiency of a vector through array like indexing is comparable to that for arrays since as for arrays the elements are held in a contiguous block of memory. 19

20 Doesn t holding all the elements of a vector in one contiguous block of memory prevent an indefinite insertion of new elements into the vector? Won t the vector eventually run into the memory allocated to other objects in a computer program? 20

21 In a vector, this problem is taken care of by allowing a vector to migrate elsewhere in memory as further elements are added to the vector. Therefore, it makes no sense to write functions that have pointers to vectors or to vector elements. 21

22 #include <iostream> #include <vector> // (A) void print( vector<int> ); int main() { vector<int> vec; vec.push_back( 34 ); vec.push_back( 23 ); // size is now 2 vector<int>::iterator p; // (B) // (C) // (D) print( vec ); // p = vec.begin(); // (E) *p = 68; // (F) *(p + 1) = 69; // (G) // *(p + 2) = 70; // WRONG // (H) print( vec ); // vec.pop_back(); // size is now 1 // (I) print( vec ); // 68 vec.push_back(101); vec.push_back(103); // (J) // (K) 22

23 // size is now 3 int i = 0; while ( i < vec.size() ) cout << vec[i++] << " "; cout << endl; // vec[0] = 1000; vec[1] = 1001; vec[2] = 1002; // (L) // (M) // (N) // (O) } print( vec ); // void print( vector<int> v ) { cout << "\nvector size is: " << v.size() << endl; vector<int>::iterator p = v.begin(); while ( p!= v.end() ) cout << *p++ << " "; cout << endl << endl; } 23

24 #include <iostream> #include <vector> int sum( vector<int> vec ) { int result = 0; vector<int>::iterator p = vec.begin(); while ( p!= vec.end() ) result += *p++; return result; } int main() { vector<int> v1(100); cout << v1.size() << endl; // 100 cout << sum( v1 ) << endl; // 0 v1.push_back( 23 ); cout << v1.size() << endl; // 101 cout << sum( v1 ) << endl; // 23 v1.reserve( 1000 ); cout << v1.capacity() << endl; // 1000 cout << v1.size() << endl; // 101 cout << v1[900] << endl; // undefined cout << sum( v1 ) << endl; // 23 cout << v1.front() << endl; // 0 cout << v1.back() << endl; // 23 v1.pop_back(); 24

25 cout << v1[ v1.size() - 1 ] << endl; // 0 vector<int>::iterator p = &v1[50]; cout << *p << endl; // 0 vector<int> v2(150, 2); cout << sum( v2 ) << endl; // 300 v2.resize( 500 ); cout << v2.size() << endl; // 500 cout << v2[150] << endl; // 0 v2.clear(); cout << v2.empty() << endl; // true cout << v2.capacity() << endl; // 500 cout << v2.size() << endl; // 0 v2.resize( 0 ); cout << v2.capacity() << endl; // 500 cout << v2.size() << endl; // 0 } return 0; 25

26 List Operations on Vectors A vector can also be used in pretty much the same manner as a linked list, meaning that elements can be added or removed at the beginning, anywhere in the middle, or at the end of a vector. 26

27 #include <iostream> #include <vector> #include <algorithm> // find() and sort() generic functions void print( vector<int> ); int main() { vector<int> vec(5); print( vec ); // vec.insert( vec.begin(), 9 ); print( vec ); // vec.erase( vec.begin() ); print( vec ); // vec.insert( vec.begin() + 2, 8 ); print( vec ); // vec.erase( vec.begin() + 2 ); print( vec ); // vec.insert( vec.end(), 7 ); print( vec ); // vec.erase( vec.end() - 1 ); print( vec ); //

28 vec.insert( vec.begin() + 3, 6 ); print( vec ); // vec.erase( find( vec.begin(), vec.end(), 6 ) ); print( vec ); // vec.insert( vec.begin() + 1, 3 ); vec.insert( vec.begin() + 5, 3 ); print( vec ); // vec.erase( find( vec.begin(), vec.end(), 3 ) ); vec.erase( find( vec.begin(), vec.end(), 3 ) ); print( vec ); // vec[0] = 23; vec[1] = 2; vec[2] = 16; vec[3] = 45; vec[4] = 16; } print( vec ); // sort( vec.begin(), vec.end() ); print( vec ); // void print( vector<int> v ) { vector<int>::iterator p = v.begin(); while ( p!= v.end() ) cout << *p++ << " "; cout << endl; 28

29 } 29

30 #include <iostream> #include <vector> #include <string> #include <algorithm> void print( vector<string> ); int main() { vector<string> vec; vec.push_back( "hi" ); vec.push_back( "wow" ); vec.push_back( "daah" ); vec.push_back( "hello" ); vec.push_back( "zora" ); vec.push_back( "dud" ); vec.push_back( "huh" ); vec.push_back( "yuk" ); print( vec ); sort( vec.begin(), vec.end() ); print( vec ); vec.erase( find( vec.begin(), vec.end(), "yuk" ) ); print( vec ); vec.erase( vec.begin() + 1 ); print( vec ); // (A) // (B) // (C) // (D) 30

31 vec.insert( vec.begin() + 1, "yum" ); print( vec ); vec.insert( vec.end(), "zing" ); // eqiv to vec.push_back(...) print( vec ); // (E) // (F) } void print( vector<string> vec ) { vector<string>::iterator p = vec.begin(); while ( p < vec.end() ) cout << *p++ << " "; cout << endl; } 31

32 Using an Array to Initialize a Vector To initialize a vector with an array, the vector constructor takes two arguments, both pointers, one pointing to the beginning of the array and the other to one past the end of the array. 32

33 #include <iostream> #include <vector> void print( vector<int> ); int main() { int data[] = {11, 12, 23, 34}; int size = sizeof( data ) / sizeof( data[0] ); vector<int> vec( data, &data[ size ] ); // (A) // (B) // (C) } print( vec ); // (D) void print( vector<int> vec ) { vector<int>::iterator p = vec.begin(); while ( p < vec.end() ) cout << *p++ << " "; cout << endl; } 33

34 Vector of Class Type Objects For a class type object to be stored in a container, at the minimum the class should support a no-arg constructor so that memory appropriated for a container can be properly initialized. The class must also possess overload definitions for the == and < operators so that the objects stored in a container can be compared for the various STL algorithms. 34

35 #include <iostream> #include <vector> #include <algorithm> // for sort() class X { int p; public: X() { p = 42; } X( int q ) { p = q; } int getp() const { return p; } }; bool operator<( const X& x1, const X& x2 ) { return x1.getp() < x2.getp(); } bool operator==( const X& x1, const X& x2 ) { return x1.getp() == x2.getp(); } //(A) //(B) void print( vector<x> ); 35

36 int main() { vector<x> vec; X x1( 2 ); X x2( 3 ); X x3( 5 ); vec.push_back( x1 ); vec.push_back( x3 ); vec.push_back( x2 ); print( vec ); // vec.erase( vec.begin(), vec.end() ); print( vec ); // size of vec is 0 cout << x1.getp() << " " << x2.getp() << " " << x3.getp() << endl; // vector<x> vec_2( 5 ); print( vec_2 ); // vec_2.resize( 7 ); print( vec_2 ); // vec_2.reserve( 10 ); cout << vec_2.capacity() << endl; // 10 print( vec_2 ); // , // size still returns 5 cout << vec_2[ 8 ].getp() << endl; // undefined 36

37 vec_2[0] = X(12); vec_2[1] = X(36); vec_2[2] = X(3); vec_2[3] = X(56); vec_2[4] = X(2); sort( vec_2.begin(), vec_2.end() ); //(E) print( vec_2 ); // vec_2.clear(); print( vec_2 ); // vec_2 is now empty cout << vec_2.capacity() << endl; // 10 } return 0; void print( vector<x> v ) { cout << "\nvector size is: " << v.size() << endl; vector<x>::iterator p = v.begin(); while ( p!= v.end() ) cout << (*p++).getp() << " "; cout << endl << endl; } 37

38 Deque A deque has all the functionality of a vector and then some. A vector is inefficient for insert/delete operations at the front of the sequence, because if you insert a new element at the front, you d need to shuffle all the other elements in the memory to their next location. On the other hand, in a deque the insert/delete operations at the front are just as efficient as they are at the back. So, whereas avector provides us with the efficientpush back andpop back operations at the back, a deque has these two and also push front and pop front for equally efficient operations at the front. 38

39 //DequeFront.cc #include <string> #include <deque> #include <algorithm> // for sort, find void print( deque<string> ); int main() { deque<string> animals; animals.push_back( "yak" ); animals.push_back( "zebra" ); animals.push_front( "cat" ); animals.push_front( "canary" ); print(animals); // canary cat yak zebra animals.pop_front(); animals.pop_back(); print(animals); // cat yak animals.erase( find( animals.begin(), animals.end(), "cat" ) ); print(animals); // yak animals.insert( animals.begin(), "canary" ); print(animals); // canray yak 39

40 int sz = animals.size(); // 2 animals.resize( 5 ); // size() will now return 5 animals[sz] = "fox"; animals[sz+1] = "elephant"; animals[sz+2] = "cat"; print( animals ); // animals[2] = "fox" // animals[3] = "elephant" // animals[4] = "cat" // canary yak fox elephant cat animals.erase( animals.begin() + 2 ); // remove "fox" print( animals ); // canary yak elephant cat } sort( animals.begin(), animals.end() ); print( animals ); // canary cat elephant yak void print( deque<string> d ) { typedef deque<string>::const_iterator CI; cout << "The number of items in the deque: " << d.size() << endl;; for ( CI iter = d.begin(); iter!= d.end(); iter++ ) cout << *iter << " "; cout << endl << endl; } 40

41 List If your application requires frequent insertions of new data items anywhere front, back, or anywhere else in the middle in a sequence and array-like indexing for accessing the data items is not important, then you need to use a list. 41

42 #include <string> #include <list> void print( list<string>& ); int main() { list<string> animals; animals.push_back( "cheetah" ); animals.push_back( "lion" ); animals.push_back( "cat" ); animals.push_back( "fox" ); animals.push_back( "elephant" ); animals.push_back( "cat" ); //<<<<< duplicate print( animals ); animals.pop_back(); print( animals ); animals.remove( "lion" ); print( animals ); animals.push_front( "lion" ); print( animals ); animals.pop_front( ); print( animals ); // cheetah lion cat fox elephant cat // cheetah lion cat fox elephant // first occurrence of "lion" // cheetah cat fox elephant // lion cheetah cat fox elephant // cheetah cat fox elephant animals.insert( animals.end(), "cat" ); print( animals ); // cheetah cat fox elephant cat 42

43 animals.sort(); print( animals ); animals.unique(); print( animals ); // cat cat cheetah elephant fox // cat cheetah elephant fox list<string> pets; pets.push_back( "cat" ); pets.push_back( "dog" ); pets.push_back( "turtle" ); pets.push_back( "bird" ); animals.splice( animals.begin(), pets, pets.begin() ); print( animals ); // cat cat cheetah elephant fox print( pets ); // dog turtle bird pets.sort(); // bird dog turtle animals.merge( pets ); } cout << pets.empty() << endl; print( animals ); // true // bird cat cat cheetah dog elephant // fox turtle void print( list<string>& li ) { typedef list<string>::const_iterator CI; 43

44 } cout << "The number of items in the list: " << li.size() << endl;; for ( CI iter = li.begin(); iter!= li.end(); iter++ ) cout << *iter << " "; cout << endl << endl; 44