SNUOOPSLA Lab.
Chap17. Standard Containers
© copyright 2001 SNU OOPSLA Lab.
SNUOOPSLA Lab.C++
Contents
Standard Containers Sequences Sequence Adapters Associative Containers Almost Containers Defining a New Container
SNUOOPSLA Lab.C++
1. Standard Containers Two kinds of containers
Sequences Associative containers
Not fully-developed standard containers Built-in arrays,strings,valarrays,bitsets
SNUOOPSLA Lab.C++
1. Standard Containers
Vector
List
SizeRep
elements Extra space
rep
Elements:
SNUOOPSLA Lab.C++
1.Standard Containers
Map
String
Rep...
nodenode
Rep... Segment descriptors
String segments:
(key,value) pairs:
SNUOOPSLA Lab.C++
1. Standard Containers
Elements in a container are copies of the objects inserted by a copy constructor or an assignment
Associative containers require that their elements can be ordered
Sort(Ran first, Ran last) using < for comparison Sort(Ran first, Ran last, Cmp cmp) using cmp for comparis
on
SNUOOPSLA Lab.C++
2.Sequences
Vector,list,deque : fundamental sequences
Stack,queue,priority_queue
:container adapters or sequence adapters
SNUOOPSLA Lab.C++
2. Sequences
Vector Random-access iterators
List Bidirectional iterators Types and operations like vector’s, except [], at(), capacity(),
and reserve() Additional operations : slice, sort, merge,front, remove, uniq
ue
SNUOOPSLA Lab.C++
2. Sequences Deque
A double-ended queue Operations
List-like efficiency at both ends Vector-like efficiency in the middle
SNUOOPSLA Lab.C++
3. Sequence Adapters
Provides a restricted interface to a container Stack Queue Priority Queue
SNUOOPSLA Lab.C++
3. Sequence Adapters Stack
Defined in <stack>
template <class T, class C=deque<T>> class std::stack {protected:
C c:public:
typedef typename C::value_type value_type;typedef typename C::size_type size_type;typedef C container_type;
explicit stack(const C& a = C()) : c(a){ }bool empty() const { return c.empty(); }size_type size() const {return c.size(); }value_type& top() {return c.back();}const value_type& top() const {return c.back(); }void push { const value_type& x) { c.push_back(x); }void pop() { c.pop_back(); }
}
pass a containeras a template arg
give back,push_back,pop_back their conventional names: top,push,pop
SNUOOPSLA Lab.C++
3. Sequences Adapters Queue
Defined in <queue> An interface to a container that allows an insertion
of elements at the back() and the extraction of elements at the front()
template <class T,class C=deque<T>> class std:queue{…value_type& front(){ return c.front();}const value_type& front() const {return c.front();}
value_type& back(){ return c.back(); }const value_type& back() const { return c.back(); }
}
SNUOOPSLA Lab.C++
3. Sequences Priority Queue
Defined in <queue> A queue in which each element is given a priority
that controls the order
template <class T,class C= vector<T>,class Cmp=less<typename c::value_type>> class std::priority_queue{
…explicit priority_queue(const Cmp& a1=Cmp(), const C& a2=C())
:c(a2),cmp(a1){ }priority_queue(In first, In last, const Cmp&=Cmp(),const C&=CC());
void pop();}
Compare elementsusing the < opby default
return the largest element
SNUOOPSLA Lab.C++
4. Associative Containers
Generalization of the notion of an associative array Associative array
Keeps pairs of values : (key, mapped value) Map,multimap Set, multiset
SNUOOPSLA Lab.C++
4. Associative Containers Map
A sequence of (unique key,value) pairs that provides for fast retrieval based on the key
Bidirectional iterators Type
value_type of a map : (key,value) pair mapped_type : the type of the mapped values
Iteration Simply an iteration over a sequence of pair <const key, mapp
ed_type> Subscripting
Performs a lookup on the key and returns correponding value
SNUOOPSLA Lab.C++
4. Associative Containers Comparisons
By default, < (less than) key_comp(), value_comp()
Map operation find() : find element with key k count() : find number of elements with key k lower_bound() : find first element with key k upper_bound() : find key element with key
greater than k
SNUOOPSLA Lab.C++
4. Associative Containers Multimap
Is like a map ,except that it allows duplicate keys The primary means of accessing multiple values with th
e same key :equal_range(),lower_bound,upper_bound()
Set Can be seen as a map concerning only the keys Rely on a comparison op rather than equlity(==)
Multiset A set that allows duplicate keys
SNUOOPSLA Lab.C++
5. Almost Containers
Hold elements, but lack some aspect of the standard container interface
Built-in array, strings, valarrays, bitsets
basic_string Provides subscripting, random-access iterators, and most of
the notational conveniences of a container Valarray
A vector for optimized numeric computation Provides many useful numeric operations
SNUOOPSLA Lab.C++
5. Almost Containers Bitset
A bitset<N> is an array of N bits with binary conditions Ex)
Constructors Constructed with default values from the bits in an unsign
ed long int, or from a string Bit Manipulation Operations
Binary &(and),| (or), ^(exclusive or),<<(logical left shift),>>(logical right shift), set(),reset(),flip()...
Built-in Arrays Supplies subscripting and random-access iterators in th
e form of ordinary pointers
1 1 0 1 0bitset<5>:
SNUOOPSLA Lab.C++
6. Defining a New Container
A user can design additional containers to fit into the framework provided by the standard containers
Hash_map A map with a hash function The difference between a map and a hash_map
A map requires a < for its element type A hash_map requires an == and a hash function
A first approximation of a hash_map
Template <class Key,class T, class H=Hash<Key>,class EQ=equal_to<Key>, class A = allocator<T>>
class hash_map { //like map, except: typedef H Hasher; typedef EQ key_equal; hash_map(const T& dv=TT(),size_type n=101,const h& hf=H(),const EQ&=EQ()); … hash_map(In first, In last,const TT&dv = T(),size_type n=101,const H& hf=H()); }
SNUOOPSLA Lab.C++
6.Defining a New Container
The key operations The constructors The lookup(operator[]) The resize operation The operation removing an element
Each Entry A key, a value, a pointer to the next entry with
same hash value, and an erased bit
Class hash_map{ …struct Entry {
key_type key;mapped_type val;Entry* next;bool erased;…
} ….
Key val e next
Key val e next
...
Top Related