Download
intro to the c standard template library stl n.
Skip this Video
Loading SlideShow in 5 Seconds..
Intro to the C++ Standard Template Library (STL) ‏ PowerPoint Presentation
Download Presentation
Intro to the C++ Standard Template Library (STL) ‏

Intro to the C++ Standard Template Library (STL) ‏

199 Views Download Presentation
Download Presentation

Intro to the C++ Standard Template Library (STL) ‏

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. Intro to the C++ Standard Template Library (STL)‏ • The STL is a collection of related software elements • Containers • Data structures: store values according to a specific organization • Iterators • Variables used to give flexible access to the values in a container • Algorithms • Functions that use iterators to access values in containers • Perform computations that modify values, or creates new ones • Function objects • Encapsulate a function as an object, use to modify an algorithm • The STL makes use of most of what we’ve covered • Extensive use of function and class templates, concepts • The STL makes use of several new ideas too • typedefs, traits, and associated types

  2. Intro to C++ STL Containers • Goals • See how STL containers are implemented • See how differences in implementation affect use • We’ll cover several kinds • Focus on template concepts • And how each container’s concept relates to its implementation • Example to the left prints v[0] is 1 v[1] is 2 v[2] is 4 #include <iostream> #include <vector> using namespace std; int main (int, char *[]) { vector<int> v; // This would be asking for trouble.... // v[0] = 1; v[1] = 2; v[2] = 4; // ... but this works fine... v.push_back (1); v.push_back (2); v.push_back (4); // ... and now this is ok ... for (size_t s = 0; s < v.size(); ++s) { cout << "v[" << s << "] is " << v[s] << endl; } return 0; }

  3. Example: C++ Array, type traits template <class T, size_t N> struct block{ // every iterator must have value, difference, reference and pointer types. typedef T value_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type& reference; typedef const value_type& const_reference; typedef ptrdiff_t different_type;// should always be signed typedef size_t size_type; // should always be unsigned typedef pointer iterator; // iterator types typedef const_pointer const_iterator; }; From Matthew H. Austern, “Generic Programming and the STL”

  4. Containers Must Work with Iterators • Declare appropriate iterator types (traits)‏ typedef pointer iterator; typedef const_pointer const_iterator; • Provide iterator accessor/factory methods iterator begin() {return data;} iterator end() {return data+N;} const_iterator begin() const {return data;} const_iterator end() const {return data+N;} iterator rbegin() {return data+N-1;} iterator rend() {return data-1;} const_iterator rbegin() const {return data+N-1;} const_iterator rend() const {return data-1;}

  5. Example: Array-based STL Container template <class T, size_t N> struct block{ // typedef’s defining required types // define both mutable and const versions iterator begin() {return data;} const_iterator begin() const {return data;} iterator end() {return data+N;} const_iterator end() const {return data+N;} // accessor methods reference operator[](size_type n) {return data[n];} const_reference operator[](size_type n) const {return data[n];} size_type size() const {return N;} T data [N]; };

  6. Basic Requirements for an STL Container • Contains elements: value semantics • Containers may not overlap • An element belongs to at most one container. • may copy by value into other containers • object ownership can not be shared • Object’s lifetime may not extend beyond that of the container. • object created no earlier than when container is constructed • contained object are destroyed when container is destroyed • Container may be fixed or variable size. • Provide interfaces to contained values • Iterators with all elements contained in the range [A.begin(),A.end())‏ • must define ancillary types: value_type, pointer, const_pointer, reference, const_reference, difference_type and size_type. • Should obey the “principle of least surprise” • For example a linked list would not provide [] • Provide operations for a regular type • Assignable, Default Constructible, Equality Comparable

  7. Classifying containers • Containers may be classified by the type of iterator: • Forward: supports forward iterators • Reversible: is a Forward Container whose iterators bidirectional iterators. A reversible container must define reverse_iterator, const_reverse_iterator and the methods rbegin() and rend(). • Reverse iterator range [A.rbegin(),A,rend())‏ • Random Access: A reversible container whose iterators are random access iterators. It defines the operator operator[]().

  8. Hierarchy of STL Container Concepts From: Matthew H. Austern, “Generic Programming and the STL” Container Forward Container Associative (variable size)‏ Reversible Container Simple Associative Container Pair Associative container Sequence (variable size)‏ Random Access Container Unique Associative Container Multiple Associative Container Front Insertion Sequence Back Insertion Sequence Sorted Associative Container Hashed Associative Container

  9. General Container Concepts Container • Notice containers can have multiple classifications • Useful to look at differences between data structures! • Back vs. front insertion • Forward vs. reversible vs. random access • More general concepts higher in the hierarchy • More specific concepts appear farther down Forward Container slist Sequence list Reversible Container Front Insertion Sequence Back Insertion Sequence Random Access Container deque vector refined by models

  10. Container: Top of its Concept Hierarchy • Valid Expressions Complexity • Copy constructor X(a) linear • Copy constructor X b(a) linear • Assignment operator b = a linear • Destructor a.~X() linear • Beginning of range a.begin() constant • End of range a.end() constant • Size a.size() linear -- O(N)‏ • Maximum size a.max_size() amortized, constant • Empty a.empty() amoritized, constant • Swap a.swap(b) linear – O(N) Container • Invariants (for Container a): • valid range: [a.begin(), a.end()), but order is not guaranteed • Range size: a.size() == distance(a.begin(), a.end())‏ • Completeness: Iterating through the range [a.begin(), a.end()) will access all elements.

  11. Container • Container concept: • Owns elements that it stores. • Provides methods to access elements • Defines an associated iterator type • Requires iterator to model the input_iterator concept • Elements are unordered. • Only one active iterator permitted. • Refinement of Assignable • Associated types: • value_type: must model Assignable • reference: usually value_type& • const_reference: usually const value_type& • pointer: usually value_type* • const_pointer: usually const value_type* • iterator: must model input iterator. Expected its value, reference and pointer types are the same as the containers. Its not required to be mutable. • const_iterator: value type is expected to be the containers value type (not const value_type). Reference and pointer types expected to be const versions of containers. • different_type: signed integral type, represents distance between iterarors. • size_type: unsigned integral represents >0 value of difference type.

  12. Forward Container • Additional Expressions Complexity • Equality a == b linear • Inequality a != b linear • Less than a < b linear • Greater than a > b linear • Less than or equal a <= b linear • Greater than or equal a >= b linear Container deque vector Forward Container slist list • Refinement of Container, Equality Comparable, LessThan Comparable • equality semantics: sizes are equal and each element is equal • Invariants (for Forward Container a): • Ordering: ordering is consistent across accesses, providing no mutations of occurred.

  13. Reversible Container • Additional Expressions Complexity • Beginning of reverse range a.rbegin() amortized constant • End of reverse range a.rend() amortized constant Container list Forward Container vector Reversible Container deque • Refinement of Forward Container whose iterators are bidirectional. • Introduces types: reverse_iterator and const_reverse_iterator • Invariants: • Valid range: [a.rbegin(), a.rend())‏ • Equavalence of ranges: forward and reverse distance is the same.

  14. Random Access Container • Additional Expressions Complexity • Element access a[n] Amortized constant Container vector Forward Container deque Reversible Container Refinement of Reversible Container whose iterator is Random Access. Random Access Container

  15. Sequence • Additional Expressions Complexity • Fill constructor X(n,t) linear • Fill constructor X(n) (same as X(n,T()) linear • Default constructor X()(same as X(0,T()) linear • Range constructor X(i,j) linear • Insert a.insert(p,t) sequence-dependent • Fill insert a.insert(p,n,t) linear • Range insert a.insert(p,i,j) linear • Erase a.erase(p) sequence-dependent • Range erase a.erase(p,q) linear • Front a.front() amortized constant Container vector deque Forward Container list slist Refinement of Forward Container, Default Constructable Elements arranged in a strict order. After an insert operation iterators are not guaranteed to remain valid Sequence

  16. Front Insertion Sequence • Additional Expressions Complexity • a.front()‏ • Push front a.push_front(t) constant • Pop front a.pop_front(t) constant Container slist Forward Container list Sequence deque Front Insertion Sequence

  17. Back Insertion Sequence • Additional Expressions Complexity • Back a.back() constant • Push back a.push_back(t) constant • Pop back a.pop_back(t) constant Container list Forward Container vector Sequence deque Back Insertion Sequence

  18. Sequential Containers • Sequential Containers • vector: fast random access • list: fast insertion/deletion • deque: double-ended queue • Sequential Containers Adaptors • stack: last in/first out stack • queue: First in/First out queue • priority queue: priority management • Element types must support assignment and copy. • Only vector and deque support subscripting

  19. Sequence s • vector can be used as a stack: • push_back(), pop_back() • pop_back() does not return a value, must use back(). • List operations • insert(), erase() and clear(). • not as efficient on vectors. • a list container is optimized for inserting and removing from arbitrary locations within the sequence. • adding/removing elements may invalidate iterator

  20. size and capacity • the size() method returns the number of elements in the container • the capacity() method indicates the maximum number of elements that can be stored in the current memory allocation – vector only. • capacity() – size() is the number of elments that can be added before memory must be reallocated. • max_size() is the largest possible container of this type. • calling resize() on a vector may move elements to another location invalidating any iterators. • instantiating a container may result in a bad_alloc() exception vector<int> v(10000);

  21. Associative Container Concepts Container refined by models Forward Container Associative Container multiset Simple Associative Container Pair Associative container set multimap map Unique Associative Container Multiple Associative Container hash_multiset hash_set hash_multimap Sorted Associative Container Hashed Associative Container hash_map

  22. Associative Container hash_set hash_multiset • Additional Expressions Complexity • Default constructor X () constant • Default constructor X a; constant • Find a.find(k) logarithmic • Count a.count(k) O(log(size())+count(k))‏ • Equal range a.equal_range(k)) logarithmic • Erase key a.erase(k) O(log(size())+count(k))‏ • Erase element a.erase(p) constant • Erase range a.erase(p,q) O(log(size())+count(k))‏ multiset multimap set map hash_map hash_multimap

  23. Unique Associative Container • Additional Expressions Complexity • Range constructor X a(i,j) linear • Insert element a.insert(t) logarithmic • Insert range a.insert(i,j) O(Nlog(size()+N))‏ hash_set set map hash_map

  24. Multiple Associative Container • Additional Expressions Complexity • Range constructor X a(i,j) linear • Insert element a.insert(t) logarithmic • Insert range a.insert(i,j) O(Nlog(size()+N)) hash_multiset multiset multimap hash_multimap

  25. Sorted Associative Container • Additional Expressions Complexity • Default constructors X (); X a; constant • Default constructor with comparator X a(c) constant • Range constructor X(i,j) O(NlogN)‏ • Range constructor w/ comparator X a(i,j,c) O(NlogN)‏ • Key comparison a.key_comp() constant • Value comparison a.value_comp() constant • Lower bound a.lower_bound(k) logarithmic • Upper bound a.upper_bound(k) logarithmic • Equal range a.equal_range(k) logarithmic • Insert with hint a.insert(p,t) logarithmic multimap map multiset set

  26. Hashed Associative Container • Additional Expressions Complexity • Default constructors X (); X a; constant • Default constructor with bucket count X a(n) constant • Default constructor with hash function X a(n,h) constant • Default constructor with key equality X a(n,h,k) constant • Range constructor X a(i,j) linear • Range constructor with bucket count X a(i,j,n) linear • Range constructor w/ hash fxn X a(i,j,n,h) linear • Range constructor w/ key eq X a(i,j,n,h,k) linear • Hash function a.hash_funct() constant • Key equality a.key_eq() constant • Bucket count a.bucket_count() constant • Resize a.resize() linear hash_set hash_multiset hash_map hash_multimap

  27. Example Using map • write a program that maps c-style strings for numbers specifying your own comparison operator (<)‏ // define a functor for comparing c-style strings class CStringLess { public: bool operator()(const char *s1, const char *s2) { return strcmp(s1, s2) < 0; } }; // define convenience typedefs typedef map<const char *, const char *, CStringLess> mapType; typedef mapType::value_type pairType; mapType tbl; // the table tbl["00"] = "Zero"; tbl["01"] = "One"; tbl["02"] = "Two"; tbl["03"] = "Three"; tbl["04"] = "Four"; tbl["05"] = "Five"; tbl["06"] = "Six"; tbl["07"] = "Seven";tbl["08"] = "Eight"; tbl["09"] = "Nine";

  28. continued • Looking for a value mapType::const_iterator cit = tbl.find(“05”)‏ if (cit == tbl.end())‏ … found it … else … not found … • Erase a value mapType::iterator iter = tbl.find(eraseVal); if (iter != tbl.end())‏ tbl.erase(iter); • Inserting values using insert()‏ pair<mapType::iterator, bool> ret = tbl.insert(make_pair(eraseVal, "XXXXX")); if (ret.second)‏ std::cout << "Inserted entry: “ << ret.first->first << "\n";

  29. Student Records Num LastName FirstName MName Email StdtId DropCd Score Grade 1) Alhaddad Lorinda Hang al@cecX.wustl.edu 000007 EN 87 B 2) Asnicar Reynalda Phebe ar@cecX.wustl.edu 000000 EN 97 A 3) Baudino Ernesto Rex be@cecX.wustl.edu 000016 WD -1 NG 4) Bock Ester Jimmy be@cecX.wustl.edu 000010 EN 88 B 5) Bonavita Elias Johnathan be@cecX.wustl.edu 000012 EN 71 C 6) Botti Maybell Shawnta bm@cecX.wustl.edu 000014 EN 27 F 7) Dailey Kyle Quinn dk@cecX.wustl.edu 000018 DP -1 NG 8) Debellis Rusty Gale dr@cecX.wustl.edu 000009 EN 85 B 9) Duldulao Sherman Orlando ds@cecX.wustl.edu 000003 EN 95 A 10) Hertweck Carmelo Garret hc@cecX.wustl.edu 000011 EN 80 B 11) Laughead Troy Kirby lt@cecX.wustl.edu 000015 EN 39 F 12) Lieuallen Cristen Erma lc@cecX.wustl.edu 000001 EN 93 A 13) Malsom Anton Darrell ma@cecX.wustl.edu 000013 EN 72 C 14) Mcbrayer Jerald Wendell mj@cecX.wustl.edu 000019 DP -1 NG 15) Myer Brandie Aleen mb@cecX.wustl.edu 000002 EN 92 A 16) Schmid Tarsha Louis st@cecX.wustl.edu 000008 EN 83 B 17) Siroka Odis Tom so@cecX.wustl.edu 000017 WD -1 NG 18) Tutaj Keva Venessa tk@cecX.wustl.edu 000004 EN 88 B 19) Ventrella Jene Reita vj@cecX.wustl.edu 000005 EN 83 B 20) Waz Nereida Sherill wn@cecX.wustl.edu 000006 EN 85 B

  30. Example using multimap typedef vector<string> record_t; typedef vector<record_t> roster_t; roster_t roster; map<string, record_t> nameMap; multimap<string, record_t> gradeMap; // Now get roster records while (getline(fin, line)) { vector<string> fields; // skip blank lines if (string2flds(fields, line, "\t", " \n\r") == 0)‏ continue; // create student record, ignoring first field record_t rec(fields.begin()+1, fields.end()); roster.push_back(rec);

  31. continued { // … loop reading records // Add to name to roster mapping nameMap[fullName] = roster.back(); // Add to grade to roster mapping gradeMap.insert(make_pair(rec[Grade], rec)); } // print the number of students receiving an A cout << "Students getting an A (" << gradeMap.count("A") << ")\n"; // print names of students receivign an A multimap<string, record_t>::const_iterator iter = gradeMap.lower_bound("A"); for (; iter != gradeMap.upper_bound("A"); ++iter)‏ cout << "\t" << iter->second[LastName] << ", " << iter->second[FirstName] << endl; // All students map<string, record_t>::const_iterator iterx = nameMap.begin(); for (; iterx != nameMap.end(); ++iterx)‏ cout << iterx->second[LastName] << endl;