Professional Documents
Culture Documents
STL Quick Reference 1.29
STL Quick Reference 1.29
29
[A4]
1
S:iterator S::erase(S::const iterator post erased S::const iterator void S::pop back(); S::reference S::front(); S::const reference S::front()
const const
Notations
2.2.2
rst, last);
The symbol const for const. The symbol for function returned value. Template class parameters lead by outlined character. For example: T, Key, Compare. Interpreted in template denition context. Sometimes class, typename dropped. Template class parameters dropped, thus C sometimes used instead of C T . See example by
X::X(); X::X(const X&); X::~X(); X& X::operator=(const X&); X::iterator X::const iterator X::iterator X::const iterator X::reverse iterator X::const reverse iterator X::reverse iterator X::const reverse iterator X::size type X::size type bool void X::begin(); X::begin() X::end(); X::end() X::rbegin(); X::rbegin() X::rend(); X::rend() ; ; ; ;
void / move xs [xFirst,xLast) before pos / list::splice (iterator pos, list T & x, iterator xFirst, iterator xLast); 7.2 void list::remove(const void list::remove if (Predicate pred); / after call: this iterator p, p = (p + 1) / void list::unique(); / remove repeats / void / as before but, binPred(p, (p + 1)) / list::unique(B inaryPredicate binPred); / Assuming both this and x sorted / void list::merge(list T & x ); / merge and assume sorted by cmp / void list::merge(list T & x, Compare cmp); void list::reverse(); void list::sort(); void list::sort(Compare cmp);
T& value);
; ;
const
, its output by w .
2.4
Vector
template class class class vector;
const
#include <vector>
2
2.1
Containers
Pair
template class T1, class T2 struct pair { T1 rst; T2 second; pair() {} pair(const T1& a, const T2& b): rst(a), second(b) {} };
const
#include <utility>
T, A lloc=allocator
void X::clear();
2.2.3
Let, X v == v < v <=
Comparison Operators
v, w. X may also be pair (2.1). w v != w w v > w w v >= w bool.
See also 2.2 and 2.3. size type vector::capacity() const ; void vector::reserve(size type n); vector::reference vector::operator[ ](size type i); vector::const reference vector::operator[ ](size type i) const ; 7.1.
2.7
2.7.1
Sorted Associative
Types
2.1.1
Types
2.5
Deque
template class class class deque;
#include <deque>
For A=[multi]set, columns are the same A::key type A::value type A::keycompare A::value compare
2.1.2
2.3
2.3.1
Sequence Containers
Constructors
T, A lloc=allocator
2.2
Containers Common
S::S(S::size type n, const S::value type& t); S::S(S::const iterator rst, S::const iterator last);
T& x );
Compare
2.7.3
Members
A::key comp() const ; A::value comp() const ; hint, val);
7.2, 7.3
2.6
List
template class class class list;
#include <list>
2.3.2
Members
before, val); before, nVal, val);
2.2.1
Types
X::value type X::reference X::const reference X::iterator X::const iterator X::reverse iterator X::const reverse iterator X::dierence type X::size type Iterators reference value type (See 6).
S::iterator / inserted copy / S::insert(S::iterator const S::value type& S::iterator / inserted copy / S::insert(S::iterator S::size type const S::value type&
T, A lloc=allocator
See also 2.2 and 2.3. void list::pop front(); void list::push front(const T& x ); void / move all x (&x = this) before pos / list::splice(iterator pos, list T & x ); 7.2 void / move xs xElemPos before pos / list::splice (iterator pos, list T & x, iterator xElemPos); 7.2
rst, last);
S::iterator / inserted copy / S::insert(S::iterator before, S::const iterator rst, S::const iterator last); S:iterator S::erase(S::iterator position);
A::size type / # erased / A::erase(const A::key type& k ); void A::erase(A::iterator p); void A::erase(A::iterator rst, A::iterator last); A::size type A::count(const A::key type& k )
const
;
const
? http://www.medini.org/stl/stl.html
u yotam.medini@gmail.com
2
A::iterator A::lower bound(const A::key type& k ) const ; A::iterator A::upper bound(const A::key type& k ) const ; pair A::iterator, A::iterator / see 4.3.1 / A::equal range(const A::key type& k ) const ;
[A4]
map::map(
2.8
Set
template class class class class set;
multimap::const iterator multimap::lower bound( const multimap::key type& k ) multimap::const iterator multimap::upper bound( const multimap::key type& k ) pair multimap::const iterator, multimap::const iterator multimap::equal range( const multimap::key type& k )
const
const
const
#include <set>
3
3.1
Container Adaptors
Stack Adaptor
template class T, class Container=deque class stack;
See also 2.2 and 2.7. set::set(const Compare& cmp=Compare()); pair set::iterator, bool / bool = if new / set::insert(const set::value type& x );
#include <stack>
const queue& q1); bool operator<(const queue& q0, const queue& q1);
Container::value type& queue::back(); Comparision Operators bool operator= =(const queue& q0,
map::key type& k )
const
Example
typedef map<string, int> MSI; MSI nam2num; nam2num.insert(MSI::value_type("one", 1)); nam2num.insert(MSI::value_type("two", 2)); nam2num.insert(MSI::value_type("three", 3)); int n3 = nam2num["one"] + nam2num["two"]; cout << n3 << " called "; for (MSI::const_iterator i = nam2num.begin(); i != nam2num.end(); ++i) if ((*i).second == n3) {cout << (*i).first << endl;}
3.3
T
Priority Queue
#include <queue> template class T, class Container=vector class Compare=less T class priority queue;
2.9
Multiset
template class Key, class Compare=less Key , class A lloc=allocator class multiset;
#include <multiset.h>
Default constructor. Container must have back(), push back(), pop back(). So vector, list and deque can be used. bool stack::empty() const ;
T,
3 called three
2.11
Multimap
multiset::multiset(
#include <multimap.h> template class Key, class T, class Compare=less Key , class A lloc=allocator class multimap; See also 2.2 and 2.7.
Container::value type& stack::top(); Comparision Operators bool operator= =(const stack& s0,
void
const
stack::top()
Container::value type&
const
and have empty(), size(), front(), push back() and pop back(). So vector and deque can be used. Mostly implemented as heap.
3.3.1
Constructors
bool operator<(
const const
3.2
Key,T
Queue Adaptor
2.10
Map
3.3.2
#include <map> template class Key, class T, class Compare=less Key , class A lloc=allocator class map; See also 2.2 and 2.7.
2.11.1
Types
const
Container::size type T
const
2.11.2
const
Container::value type&
const
multimap::multimap( multimap::multimap(
2.10.1
Types
/ pair /
const
map::value type
Key,T
Default constructor. Container must have empty(), size(), back(), front(), push back() and pop front(). So list and deque can be used. bool queue::empty() const ;
? http://www.medini.org/stl/stl.html
u yotam.medini@gmail.com
[A4]
3 O utputIterator // sk Sk ri = bop(s1 , s2 ) i i i transform(InputIterator1 rst1, InputIterator1 last1, InputIterator2 rst2, O utputIterator result, B inaryOperation bop);
void replace(ForwardIterator
Algorithms
#include <algorithm> STL algorithms use iterator type parameters. Their names suggest their category (See 6.1). For abbreviation, the clause
InputIterator1, InputIterator2 mismatch(InputIterator1 rst1, InputIterator1 last1, InputIterator2 rst2, B inaryPredicate binPred);
bool
/ / pair
template class Foo, ... is dropped. The outlined leading character can suggest the template context. Note: When looking at two sequences: S1 = [rst1 , last1 ) and S2 = [rst2 , ?) or S2 = [?, last2 ) caller is responsible that function will not overow S2 .
equal(InputIterator1 rst1,
bool
InputIterator1 last1, InputIterator2 rst2); InputIterator1 last1, InputIterator2 rst2, B inaryPredicate binPred);
rst1,
rst,
equal(InputIterator1
void
4.1 Query Algorithms Function // f not changing [rst, last) for each(InputIterator rst, InputIterator last, Function f ); 7.4 InputIterator // rst i so i==last or *i==val nd(InputIterator rst, InputIterator last,
const
/ [rst2 , last2 ) [rst1 , last1 ) / ForwardIterator1 search(ForwardIterator1 rst1, ForwardIterator1 last1, ForwardIterator2 rst2, ForwardIterator2 last2); / [rst2 , last2 ) binPred / ForwardIterator1 search(ForwardIterator1 ForwardIterator1 ForwardIterator2 ForwardIterator2 [rst1 , last1 ) rst1, last1, rst2, last2, binPred);
ForwardIterator // as above but using pred remove if (ForwardIterator rst, ForwardIterator last, Predicate pred); O utputIterator // past last copied remove copy(InputIterator rst, InputIterator last, O utputIterator result, const T& value); O utputIterator // as above but using pred remove copy if (InputIterator rst, InputIterator last, O utputIterator result, Predicate pred);
All variants of unique template functions remove consecutive (binPred-) duplicates. Thus usefull after sort (See 4.3). ForwardIterator // [ ,last) gets repetitions unique(ForwardIterator rst, ForwardIterator last);
O utputIterator // result2 + #[rst, last) replace copy(InputIterator rst, InputIterator last, O utputIterator result, const T& oldVal, const T& newVal); O utputIterator // as above but using pred replace copy if (InputIterator rst, InputIterator last, O utputIterator result, Predicate& pred, const T& newVal);
void ll(ForwardIterator
T val); 7.2 InputIterator // rst i so i==last or pred(i) nd if (InputIterator rst, InputIterator last, Predicate pred); 7.7 ForwardIterator // rst duplicate adjacent nd(ForwardIterator rst, ForwardIterator last); ForwardIterator // rst binPred-duplicate adjacent nd(ForwardIterator rst, ForwardIterator last, B inaryPredicate binPred);
void / n = # equal val / count(ForwardIterator rst, ForwardIterator last, const T val, S ize& n);
B inaryPredicate
4.2 Mutating Algorithms O utputIterator // rst2 + (last1 rst1 ) copy(InputIterator rst1, InputIterator last1, O utputIterator rst2);
copy backward(
rst,
void ll n(ForwardIterator
ForwardIterator // as above but using binPred unique(ForwardIterator rst, ForwardIterator last, B inaryPredicate binPred); O utputIterator // past last copied unique copy(InputIterator rst, InputIterator last, O utputIterator result, const T& result); O utputIterator // as above but using binPred unique copy(InputIterator rst, InputIterator last, O utputIterator result, B inaryPredicate binPred);
void
B idirectionalIterator2
/ /
bi-pointing to rst != InputIterator1, InputIterator2 mismatch(InputIterator1 rst1, InputIterator1 last1, InputIterator2 rst2);
/ / pair
B idirectionalIterator1 rst1, B idirectionalIterator1 last1, B idirectionalIterator2 last2); void swap(T& x, T& y); ForwardIterator2 // rst2 + #[rst1 , last1 ) swap ranges(ForwardIterator1 rst1, ForwardIterator1 last1, ForwardIterator2 rst2); O utputIterator // result + (last1 rst1 ) transform(InputIterator rst, InputIterator last, O utputIterator result, UnaryOperation op); 7.6
B idirectionalIterator last); O utputIterator // past last copied reverse copy(B idirectionalIterator rst, B idirectionalIterator last, O utputIterator result);
All variants of remove and unique return iterator to new end or past last copied.
void / with rst moved to middle / rotate(ForwardIterator rst, ForwardIterator middle, ForwardIterator last);
ForwardIterator // [ ,last) is all value remove(ForwardIterator rst, ForwardIterator last, const T& value);
O utputIterator // rst to middle position rotate copy(ForwardIterator rst, ForwardIterator middle, ForwardIterator last, O utputIterator result);
? http://www.medini.org/stl/stl.html
u yotam.medini@gmail.com
4
void
[A4]
random shue(
void / rand() returns double in [0, 1) / random shue( RandomAccessIterator rst, RandomAccessIterator last, RandomGenerator rand);
B idirectionalIterator // begin with true partition(B idirectionalIterator rst, B idirectionalIterator last, Predicate pred); B idirectionalIterator // begin with true
stable partition(
Let n = position rst, nth element partitions [rst, last) into: L = [rst, position), en , R = [position + 1, last) such that l L, r R l > en r. void nth element( RandomAccessIterator rst, RandomAccessIterator position, RandomAccessIterator last); void / as above but using comp(ei , ej ) / nth element( RandomAccessIterator rst, RandomAccessIterator position, RandomAccessIterator last, Compare comp);
ForwardIterator,ForwardIterator equal range(ForwardIterator rst, ForwardIterator last, const T& value); pair ForwardIterator,ForwardIterator equal range(ForwardIterator rst, ForwardIterator last, const T& value, Compare comp); 7.5
pair
equal range returns iterators pair that lower bound and upper bound return.
includes(InputIterator1 rst1,
bool / S1 S2 /
4.3.2
Merge
4.3
void sort(RandomAccessIterator
4.3.1
bool
Binary Search ForwardIterator last, const T& value); ForwardIterator last, const T& value, Compare comp);
O utputIterator merge(InputIterator1 InputIterator1 InputIterator2 InputIterator2 O utputIterator O utputIterator merge(InputIterator1 InputIterator1 InputIterator2 InputIterator2 O utputIterator Compare
Assuming S1 = [rst1 , last1 ) and S2 = [rst2 , last2 ) are sorted, stably merge them into [result, result + N ) where N = |S1 | + |S2 |. rst1, last1, rst2, last2, result); rst1, last1, rst2, last2, result, comp);
ForwardIterator
void
B idirectionalIterator rst, B idirectionalIterator middle, B idirectionalIterator last); B idirectionalIterator B idirectionalIterator B idirectionalIterator Compare
inplace merge(
void / as above but using comp(ei , ej ) / partial sort( RandomAccessIterator rst, RandomAccessIterator middle, RandomAccessIterator last, Compare comp);
ForwardIterator
ForwardIterator last, const T& value); ForwardIterator last, const T& value, Compare comp);
4.3.3
Functions on Sets
Can work on sorted associcative containers (see 2.7). For multiset the interpretation of union, intersection and dierence is by: maximum, minimum and substraction of occurrences respectably. Let Si = [rsti , lasti ) for i = 1, 2.
O utputIterator // S1 S2 , past end set union(InputIterator1 rst1, InputIterator1 last1, InputIterator2 rst2, InputIterator2 last2, O utputIterator result); O utputIterator // as above but using comp set union(InputIterator1 rst1, InputIterator1 last1, InputIterator2 rst2, InputIterator2 last2, O utputIterator result, Compare comp); O utputIterator // S1 S2 , past end set intersection(InputIterator1 rst1, InputIterator1 last1, InputIterator2 rst2, InputIterator2 last2, O utputIterator result); O utputIterator // as above but using comp set intersection(InputIterator1 rst1, InputIterator1 last1, InputIterator2 rst2, InputIterator2 last2, O utputIterator result, Compare comp); O utputIterator // S1 \ S2 , past end set dierence(InputIterator1 rst1, InputIterator1 last1, InputIterator2 rst2, InputIterator2 last2, O utputIterator result); O utputIterator // as above but using comp set dierence(InputIterator1 rst1, InputIterator1 last1, InputIterator2 rst2, InputIterator2 last2, O utputIterator result, Compare comp);
Compare
? http://www.medini.org/stl/stl.html
u yotam.medini@gmail.com
STL Quick Reference Version 1.29 O utputIterator // S1 S2 , InputIterator1 InputIterator1 InputIterator2 InputIterator2 O utputIterator InputIterator1 InputIterator1 InputIterator2 InputIterator2 O utputIterator Compare Heap RandomAccessIterator last);
past end
[A4]
4.3.5
const const
O utputIterator // rk = sk sk1 for k > 0 InputIterator rst, InputIterator last, O utputIterator result); InputIterator InputIterator O utputIterator B inaryOperation
/ r 0 = s0 /
T& min(const T& x0, const T& x1); T& min(const T& x0, const T& x1, Compare comp); T& max(const T& x0, const T& x1); T& max(const T& x0, const T& x1, Compare comp); ForwardIterator last); ForwardIterator last, Compare comp); ForwardIterator last); ForwardIterator last, Compare comp);
bool lexicographical compare( InputIterator1 rst1, InputIterator1 last1, InputIterator2 rst2, InputIterator2 last2); bool lexicographical compare( InputIterator1 rst1, InputIterator1 last1, InputIterator2 rst2, InputIterator2 last2, Compare comp);
const const
ForwardIterator ForwardIterator
Function Objects
template class A rg, class Result struct unary function { typedef A rg argument type; typedef Result result type;}
4.4
Computational
#include <functional>
4.3.4
ForwardIterator ForwardIterator
InputIterator T
4.3.6
Permutations
To get all permutations, start with ascending sequence end with descending. bool / / i available
T // as above but using binop accumulate(InputIterator rst, InputIterator last, T initVal, B inaryOperation binop); P T // i e1 e2 for ek Sk , (k = 1, 2) i i i inner product(InputIterator1 rst1, InputIterator1 last1, InputIterator2 rst2, T initVal); T // Similar, using (sum) and mult rst1, inner product(InputIterator1 InputIterator1 last1, InputIterator2 rst2, T initVal, B inaryOperation sum, B inaryOperation mult);
P
Derived unary objects: struct negate T ; struct logical not T ; 7.6 template class A rg1, class A rg2, class Result struct binary function { typedef A rg1 rst argument type; typedef A rg2 second argument type; typedef Result result type;} Following derived template objects accept two operands. Result obvious by the name. struct struct struct struct struct struct struct struct struct struct struct struct struct
next permutation(
B idirectionalIterator rst, B idirectionalIterator last); B idirectionalIterator rst, B idirectionalIterator last, Compare comp);
i available
next permutation(
void / sort the [rst,last) heap / sort heap(RandomAccessIterator void / as above but using comp / sort heap(RandomAccessIterator
bool / /
prev permutation(
B idirectionalIterator rst, B idirectionalIterator last); B idirectionalIterator rst, B idirectionalIterator last, Compare comp);
O utputIterator // rk = rst+k ei i=rst partial sum(InputIterator rst, InputIterator last, O utputIterator result); O utputIterator // as above but using binop
P
partial sum(
prev permutation(
plus T ; minus T ; multiplies T ; divides T ; modulus T ; equal to T ; not equal to T ; greater T ; less T ; greater equal T ; less equal T ; logical and T ; logical or T ;
? http://www.medini.org/stl/stl.html
u yotam.medini@gmail.com
[A4]
5.1
5.1.1
Function Adaptors
Negators
template class Predicate class unary negate : public unary function Predicate::argument type, bool ; unary negate::unary negate( Predicate pred); bool / negate pred / unary negate::operator()( Predicate::argument type x); unary negate Predicate not1(const Predicate pred);
template class O peration class binder2nd: public unary function O peration::rst argument type, O peration::result type ; binder2nd::binder2nd( const O peration& const O peration::second argument type op, y);
In table follows requirements check list for Input, Output and Forward iterators. Expression; Requirements X() might be singular X u X(a) X(a) == a *a=t *X(a)=t X u(a) u == a X u=a u copy of a a==b equivalence relation a!=b !(a==b) r = a r == a *a convertible to T. a==b *a==*b *a=t (for forward, if X mutable) ++r result is dereferenceable or past-the-end. &r == &++r convertible to const X& convertible to X& r==s ++r==++s r++ convertible to X& {X x=r;++r;return x;} *++r convertible to T *r++ IOF
6.2
Stream Iterators
template class T, class D istance=ptrdi t class istream iterator : pubic iterator input iterator tag, / end of stream 7.4 / istream iterator::istream iterator(); istream iterator::istream iterator( istream& s); 7.4
T, D istance ;
O peration::result type
istream iterator::istream iterator( const istream iterator T, D istance &); istream iterator::~istream iterator();
const
template class Predicate class binary negate : public binary function Predicate::rst argument type, Predicate::second argument type ; bool ; binary negate::binary negate( Predicate pred); bool / negate pred / binary negate::operator()( Predicate::rst argument type Predicate::second argument type binary negate Predicate not2(const Predicate pred);
5.1.3
Pointers to Functions
template class A rg, class Result class pointer to unary function : public unary function A rg, Result ;
Result
/ istream iterator& / Read and store T value istream iterator::operator+ +() const ; bool / all end-of-streams are equal / operator= =(const istream iterator, const istream iterator);
x y);
template<class A rg1, class A rg2, class Result> class pointer to binary function : public binary function A rg1, A rg2, Result ;
struct bidirectional iterator tag {} The forward requirements and: --r Convertible to const X&. If r=++s then --r refers same as s. &r==&--r. --(++r)==r. (--r == --s r==s. r-- {X x=r; --r; return x;}.
template class T class ostream iterator : public iterator output iterator tag, void, . . . ; / If delim = 0 add after each write / ostream iterator::ostream iterator( ostream& s, const char * delim=0); ostream iterator::ostream iterator( const ostream iterator s); ostream iterator& / Assign & write (*o=t) / ostream iterator::operator*() const ; ostream iterator& ostream iterator::operator=( const ostream iterator s); ostream iterator& / No-op / ostream iterator::operator+ +(); ostream iterator& / No-op / ostream iterator::operator+ +(int);
5.1.2
Binders
6
6.1
X a, b r t
Iterators
Iterators Categories
iterator type. iterator values. iterator reference (X& r). a value type T.
template class O peration class binder1st: public unary function O peration::second argument type, O peration::result type ; binder1st::binder1st( const O peration& const O peration::rst argument type op, y);
6.1.3
#include <iterator>
struct random access iterator tag {} The bidirectional requirements and (m,n iterators distance (integral) value): r+=n {for (m=n; m-->0; ++r); for (m=n; m++<0; --r); return r;} / /but time = O(1). a+n n+a {X x=a; return a+=n]} r-=n r += -n. a-n a+(-n). b-a Returns iterators distance value n, such that a+n == b. a[n] *(a+n). a<b Convertible to bool, < total ordering. a<b Convertible to bool, > opposite to <. a<=b !(a>b). a>=b !(a<b).
O peration::result type
binder1st::operator()( const binder1st::argument type x); binder1st O peration bind1st(const O peration& op,
const
6.1.1
T& x);
struct input iterator tag {} 7.8 struct output iterator tag {} struct forward iterator tag {}
7.4.
? http://www.medini.org/stl/stl.html
u yotam.medini@gmail.com
[A4]
April 20, 2007 Denote RI = reverse iterator AI = RandomAccessIterator. Abbreviate: typedef RI<AI,
6.3
7
7.1
Examples
Vector
template
class iterator {
// safe get int vi(const vector<unsigned>& v, int i) { return(i < (int)v.size() ? (int)v[i] : -1);} // safe set void vin(vector<int>& v, unsigned i, int n) { int nAdd = i - v.size() + 1; if (nAdd>0) v.insert(v.end(), nAdd, n); else v[i] = n; }
6.3.1
Reference
7.2
List Splice
iterator category; value type; I::value type I::dierence type dierence type; I::pointer pointer; I::reference reference;}
Pointer specilaizations:
7.8
iterator category ; value type; ptrdi t dierence type; T* pointer; T& reference;}
template T class iterator traits const T* { random access iterator tag iterator category ; T value type; ptrdi t dierence type; const T* pointer; const T& reference;}
back insert iterator::back insert iterator( Container& x); explicit / Container::push front(const T&) / front insert iterator::front insert iterator( Container& x); / Container::insert(const T&) / insert iterator::insert iterator( Container x, Container::iterator i); Denote InsIter = back insert iterator insFunc = push back iterMaker = back inserter 7.4 or InsIter = front insert iterator insFunc = push front iterMaker = front inserter or InsIter = insert iterator insFunc = insert
T will denote the Container::value type. Constructors explicit / Container::push back(const T&) /
void lShow(ostream& os, const list<int>& l) { ostream_iterator<int> osi(os, " "); copy(l.begin(), l.end(), osi); os<<endl;} void lmShow(ostream& os, const char* msg, const list<int>& l, const list<int>& m) { os << msg << (m.size() ? ":\n" : ": "); lShow(os, l); if (m.size()) lShow(os, m); } // lmShow list<int>::iterator p(list<int>& l, int val) { return find(l.begin(), l.end(), val);} static int prim[] = {2, 3, 5, 7}; static int perf[] = {6, 28, 496}; const list<int> lPrimes(prim+0, prim+4); const list<int> lPerfects(perf+0, perf+3); list<int> l(lPrimes), m(lPerfects); lmShow(cout, "primes & perfects", l, m); l.splice(l.begin(), m); lmShow(cout, "splice(l.beg, m)", l, m); l = lPrimes; m = lPerfects; l.splice(l.begin(), m, p(m, 28)); lmShow(cout, "splice(l.beg, m, ^28)", l, m); m.erase(m.begin(), m.end()); // <=>m.clear() l = lPrimes; l.splice(p(l, 3), l, p(l, 5)); lmShow(cout, "5 before 3", l, m); l = lPrimes; l.splice(l.begin(), l, p(l, 7), l.end()); lmShow(cout, "tail to head", l, m); l = lPrimes; l.splice(l.end(), l, l.begin(), p(l, 3)); lmShow(cout, "head to tail", l, m);
6.3.2
Reverse Iterator
Transform [i , j) [j 1, i 1). template Iter class reverse iterator : public iterator iterator traits Iter ::iterator category, iterator traits Iter ::value type, iterator traits Iter ::dierence type, iterator traits Iter ::pointer, iterator traits Iter ::reference ;
Reference // *(*this + n) reverse iterator::operator[ ](D istance n); D istance // r0.base() - r1.base() operator-(const self& r0, const self& r1);
self / n + r.base() / operator-(D istance n,
const
w
primes & perfects: 2 3 5 7 6 28 496 splice(l.beg, m): 6 28 496 2 3 5 7 splice(l.beg, m, ^28): 28 2 3 5 7 6 496 5 before 3: 2 5 3 7 tail to head: 7 2 3 5 head to tail: 3 5 7 2
const
Template Function InsIter / return InsIter Container (x) / iterMaker(Container& x); / return insert iterator Container (x, i) / insert iterator Container inserter(Container& x, Iterator i);
? http://www.medini.org/stl/stl.html
u yotam.medini@gmail.com
[A4]
7.3
(-0.809,-0.588) (0.309,-0.951)
7.7
7.8
Iterator Traits
class ModN { public: ModN(unsigned m): _m(m) {} bool operator ()(const unsigned& u0, const unsigned& u1) {return ((u0 % _m) < (u1 % _m));} private: unsigned _m; }; // ModN ostream_iterator<unsigned> oi(cout, " "); unsigned q[6]; for (int n=6, i=n-1; i>=0; n=i--) q[i] = n*n*n*n; cout<<"four-powers: "; copy(q + 0, q + 6, oi); for (unsigned b=10; b<=1000; b *= 10) { vector<unsigned> sq(q + 0, q + 6); sort(sq.begin(), sq.end(), ModN(b)); cout<<endl<<"sort mod "<<setw(4)<<b<<": "; copy(sq.begin(), sq.end(), oi); } cout << endl;
7.5
Binary Search
// first 5 Fibonacci static int fb5[] = {1, 1, 2, 3, 5}; for (int n = 0; n <= 6; ++n) { pair<int*,int*> p = equal_range(fb5, fb5+5, n); cout<< n <<":["<< p.first-fb5 <<, << p.second-fb5 <<") "; if (n==3 || n==6) cout << endl; }
w
0:[0,0) 1:[0,2) 2:[2,3) 3:[3,4) 4:[4,4) 5:[4,5) 6:[5,5)
7.6
// self-refering int class Interator : public iterator<input_iterator_tag, int, size_t> { int _n; public: Interator(int n=0) : _n(n) {} int operator*() const {return _n;} Interator& operator++() { ++_n; return *this; } Interator operator++(int) { Interator t(*this); ++_n; return t;} }; // Interator bool operator==(const Interator& i0, const Interator& i1) { return (*i0 == *i1); } bool operator!=(const Interator& i0, const Interator& i1) { return !(i0 == i1); } struct Fermat: public binary_function<int, int, bool> { Fermat(int p=2) : n(p) {} int n; int nPower(int t) const { // t^n int i=n, tn=1; while (i--) tn *= t; return tn; } // nPower int nRoot(int t) const { return (int)pow(t +.1, 1./n); } int xNyN(int x, int y) const { return(nPower(x)+nPower(y)); } bool operator()(int x, int y) const { int zn = xNyN(x, y), z = nRoot(zn); return(zn == nPower(z)); } }; // Fermat for (int n=2; n<=Mp; ++n) { Fermat fermat(n); for (int x=1; x<Mx; ++x) { binder1st<Fermat> fx = bind1st(fermat, x); Interator iy(x), iyEnd(My); while ((iy = find_if(++iy, iyEnd, fx)) != iyEnd) { int y = *iy, z = fermat.nRoot(fermat.xNyN(x, y)); cout << x << ^ << n << " + " << y << ^ << n << " = " << z << ^ << n << endl; if (n>2) cout << "Fermat is wrong!" << endl; } } }
template <class Itr> typename iterator_traits<Itr>::value_type mid(Itr b, Itr e, input_iterator_tag) { cout << "mid(general):\n"; Itr bm(b); bool next = false; for ( ; b != e; ++b, next = !next) { if (next) { ++bm; } } return *bm; } // mid<input> template <class Itr> typename iterator_traits<Itr>::value_type mid(Itr b, Itr e, random_access_iterator_tag) { cout << "mid(random):\n"; Itr bm = b + (e - b)/2; return *bm; } // mid<random> template <class Itr> typename iterator_traits<Itr>::value_type mid(Itr b, Itr e) { typename iterator_traits<Itr>::iterator_category t; mid(b, e, t); } // mid template <class Ctr> void fillmid(Ctr& ctr) { static int perfects[5] = {6, 14, 496, 8128, 33550336}, *pb = &perfects[0]; ctr.insert(ctr.end(), pb, pb + 5); int m = mid(ctr.begin(), ctr.end()); cout << "mid=" << m << "\n"; } // fillmid list<int> l; fillmid(l); vector<int> v; fillmid(v);
w
four-powers: sort mod 10: sort mod 100: sort mod 1000: 1 1 1 1 16 81 16 16 81 256 625 1296 625 16 256 1296 625 256 81 1296 81 256 1296 625
template <class T> class AbsPwr : public unary_function<T, T> { public: AbsPwr(T p): _p(p) {} T operator()(const T& x) const { return pow(fabs(x), _p); } private: T _p; }; // AbsPwr template<typename InpIter> float normNP(InpIter xb, InpIter xe, float p) { vector<float> vf; transform(xb, xe, back_inserter(vf), AbsPwr<float>(p > 0. ? p : 1.)); return( (p > 0.) ? pow(accumulate(vf.begin(), vf.end(), 0.), 1./p) : *(max_element(vf.begin(), vf.end()))); } // normNP float distNP(const float* x, const float* y, unsigned n, float p) { vector<float> diff; transform(x, x + n, y, back_inserter(diff), minus<float>()); return normNP(diff.begin(), diff.end(), p); } // distNP float x3y4[] = {3., 4., 0.}; float z12[] = {0., 0., 12.}; float p[] = {1., 2., M_PI, 0.}; for (int i=0; i<4; ++i) { float d = distNP(x3y4, z12, 3, p[i]); cout << "d_{" << p[i] << "}=" << d << endl; }
7.4
Stream Iterators
void unitRoots(int n) { cout << "unit " << n << "-roots:" << endl; vector<complex<float> > roots; float arg = 2.*M_PI/(float)n; complex<float> r, r1 = polar((float)1., arg); for (r = r1; --n; r *= r1) roots.push_back(r); copy(roots.begin(), roots.end(), ostream_iterator<complex<float> >(cout, "\n")); } // unitRoots {ofstream o("primes.txt"); o << "2 3 5";} ifstream pream("primes.txt"); vector<int> p; istream_iterator<int> priter(pream); istream_iterator<int> eosi; copy(priter, eosi, back_inserter(p)); for_each(p.begin(), p.end(), unitRoots);
w
mid(general): mid=496 mid(random): mid=496
w
unit 2-roots: (-1.000,-0.000) unit 3-roots: (-0.500,0.866) (-0.500,-0.866) unit 5-roots: (0.309,0.951) (-0.809,0.588)
w
d_{1}=19 d_{2}=13 d_{3.14159}=12.1676 d_{0}=12
w
3^2 5^2 6^2 7^2 + + + + 4^2 = 5^2 12^2 = 13^2 8^2 = 10^2 24^2 = 25^2
? http://www.medini.org/stl/stl.html
u yotam.medini@gmail.com