C Standard. l C++ For C Programmers :2 nd half. l C++11 feature of the day. l STL. C++ for C Programmers by Ira Pohl

Transcription

1 C Standard C++ For C Programmers :2 nd half C++11 feature of the day STL

2 Part I You have completed Part I, and: Know basic C++ Have coded both Min Spanning Tree and Dijkstra s algorithm Followed in my book if available Ch1-6

3 Part II More Standard Template Library New features of C++11, such as move semantics, and lambda expressions AI techniques used in implementing the game of Hex Highlight

4 New in C++11 std Let us introduce new practice and see how it replaces existing practice enum class is a type safe better form of enumeration type

5 Example :enum class enum class Color{RED, GREEN, BLUE}; enum class Stoplight{RED, YELLOW, GREEN}; With simple enums these shared enumerators would be ambiguous In C++11 they constitute separate type Stoplight::RED is different in type from Color::RED; both can be used in the same scope

6 enum class enumerator type The underlying type of enum classes is by default an int; this can be specified to be a different integral type. enum class Color : short {RED, BLUE, GREEN}; enum class Identifier : Integral_Type{ enumerator list};

7 Quiz: Define an enumerator Define a enum class that models three logical values yes, no, maybe- whose underlying type is unsigned and where yes>maybe>no --- also yes worth 2 maybe s

8 Answer enum class WierdLogic :unsigned{ NO, MAYBE = 5, YES = 10 }; // a yes is worth 2 maybe s

9 Standard Template Library Three Legged Stool Containers: Sequence containers vector, deques, list Associative containers set,map Iterators: input random Algorithms: Non-mutating sequence algorithms : Find, Count Mutating Sequence: Copy Random Shuffle, Sorting-Related:sort, Merge Numeric: accumulate, inner product

10 Some New Libraries C++11 <regex> - regular expression <thread> - threading <unordered_map> -hash based map <array> - fixed size array <forward_list> - singly linked list And much more

11 Quiz: In C A C container is? A C iterator is? A C algorithm is? Generics can be done clumsily with?

12 Answers: In C A C container is an array such as int d[100] A C iterator is a pointer int* p = d; A C algorithm is? rand(), sqrt() Generics can be done clumsily with void*

13 Iterator Categories We have seen input and output iterators Must have a single pass algorithm such as find Next up forward, bidirectional, random access

14 Forward

15 Iterator-Escher Staircase

16 C++ Forward Iterator Search forward direction one-by-one. The operator ++ is defined ("advance the iterator") and dereferencing operators * and ->. Iterators may be compared for equality == and!= and may be constructed and copy constructed. A canonical algorithm using this iterator is the STL replace algorithm:

17 replace template<class T> void replace(forwarditerator first, ForwardIterator last, const T& x, const T& y); This algorithm replaces occurences of x by y in the specified iterator range.

18 Square using iterator #include<iostream> #include<iterator> #include<fstream> #include<vector> using namespace std; template<typename ForwardIterator> void square(forwarditerator first, ForwardIterator last) { for(; first!=last; first++) } *first = (*first) * (*first);

19 main int main() {. square(w.begin(), w.end()); } for(auto i: w) // range for cout << i << "\t"; cout << endl;

20 Example: Poker Probability Wish to compute the probability in 5 card stud of making a straight flush Will create abstract data types to have card Will use vector and shuffle from STL

21 Wow A Straight Flush

22 Quiz: Poker probabilities for 5 card stud Flush is approximately A) 1/10, B)1/500, C) 1/10,000 Straight Flush is approximately A) 1/700, B)1/7000, C)1/70,000

23 Some types enum class: short suit{spade, HEART, DIAMOND, CLUB}; class pips{ public: pips(int val):v(val){ assert(v>0 && v <14);} friend ostream& operator<<(ostream& out, pips p); int get_pips(){return v;} private: int v; };

24 Card type { class card public: card():s(suit::spade),v(1){} card(suit s, pips v):s(s),v(v){} friend ostream& operator<<(ostream& out, card c ); suit get_suit(){return s;} pips get_pips(){return v;} private: suit s; pips v; }; ostream& operator<<(ostream& out, card c ){ cout << c.v << c.s; //presumes << overloaded for pips and suit return out; }

25 Deck vector of cards void init_deck(vector <card> & d){ for(int i = 1; i < 14; ++i){ card c(suit::spade, i); d[i-1] = c; } for(int i = 1; i < 14; ++i){ card c( suit:: HEART, i); d[i+12] = c; } for(int i = 1; i < 14; ++i){ card c(suit:: DIAMOND, i); d[i+25] = c; } for(int i = 1; i < 14; ++i){ card c(suit:: CLUB, i); d[i+38] = c; } }

26 C11 auto feature { } { } void print (vector <card> & deck) for(auto p = deck.begin(); p!= deck.end(); ++p) cout << *p; cout << endl; bool is_flush(vector < card > & hand) suit s = hand[0].get_suit(); for(auto p = hand.begin() + 1; p!= hand.end(); ++p) if (s!= p -> get_suit()) return false; return true;

27 Quiz Change print() to use range for() statement

28 Answer: void print (vector <card> & deck) { } for(auto cardval:deck) cout << cardval; cout << endl;

29 straight bool is_straight(vector < card > & hand){ int pips_v[5], i = 0; for(auto p = hand.begin(); p!= hand.end(); ++p) pips_v[i++] = (p -> get_pips()).get_pips(); sort(pips_v, pips_v +5); //stl iterator range if (pips_v[0]!= 1) //non-aces return ( pips_v[0] == pips_v[1] -1 && pips_v[1] == pips_v[2] -1 ) && ( pips_v[2] == pips_v[3] -1 && pips_v[3] == pips_v[4] -1 ); else //aces have a special logic return ( pips_v[0] == pips_v[1] -1 && pips_v[1] == pips_v[2] -1 ) && ( pips_v[2] == pips_v[3] -1 && pips_v[3] == pips_v[4] -1 ) (pips_v[1] == 10)&&(pips_v[2] == 11)&&(pips_v[3] ==12)&& (pips_v[4] == 13); }

30 So straight flush is easy bool is_straight_flush(vector < card > & hand) { } return is_flush(hand) && is_straight(hand);

31 Set up simulation { int main() vector < card > deck(52); srand(time(0)); init_deck(deck); int how_many ; int flush_count = 0; int str_count = 0; int str_flush_count = 0; cout << " How Many shuffles?"; cin >> how_many;

32 STL use to run simulation for(int loop = 0; loop < how_many; ++loop){ random_shuffle(deck.begin(), deck.end()); //STL algorithm vector <card> hand(5); int i = 0; for( auto p = deck.begin(); i < 5; ++p) hand[i++] = *p; if (is_flush(hand)) flush_count++; if (is_straight(hand)) str_count++; if (is_straight_flush(hand)) str_flush_count++ ; } cout << " Flushes " << flush_count << " out of " << how_many << endl; cout << " Straights " << str_count << " out of " << how_many<< endl; cout << " Straight Flushes " << str_flush_count << " out of " << how_many << endl;

33 Quiz at home Write is_4of_akind() Write is_straight_flush() for 7 card stud or 5 card draw.

34 Bidirectional Iterator The bidirectional iterator must allow the elements to be searched in both a forward direction and backward direction. This requires the operation on a forward iterator ++ operator -- ("back up the iterator").

35 reverse A canonical algorithm using this iterator is the STL reverse() algorithm: template<typename T> void reverse(bidirectionaliterator first, BidirectionalIterator last); This algorithm reverses the elements in the specified iterator range.

36 How would you write reverse

37 Move both ends Front++ Back So swap and move would lead to reverse

38 Palindrome

39 Palindrome Otto Dalmatian

40 Palindrome Otto otto Dalmatian

41 Palindrome Otto otto Dalmatian Na it am lad

42 ispalindrome template<typename Bidirectional> bool ispalindrome(bidirectional first, Bidirectional last) { while( true ){ } last--; if(first == last) //assume >= undefined break; if(*first!= *last) return false; first++; if(first == last) break; } return true;

43 How it works The algorithm moves forward and backward testing each position for equality. It checks if a value is not equal and returns false. If all values test as equal then the iterators "meet in the middle" (or pass each other) and it returns true. Compare to how you would do this with a forward only iterator - becomes n*n

44 Random access Iterator The random access iterator must allow the elements to be randomly searched in fixed time. Think indexed array. This requires effectively being able to add or subtract to an iterator value and retrieve a value from the computed position. It also means that iterator values can be compared for less and greater than as well as equality operators.

45 Sort() -hoare quicksort A canonical algorithm using this iterator is the STL sort() algorithm: template<class T> void sort(randomaccessiterator first, RandomAccessIterator last);

46 Pick an element at random template< typename RandomAccess> RandomAccess pickrandel( RandomAccess first, RandomAccess last) { ptrdiff_t temp = last-first; return first + rand()%temp; }

47 ptrdiff_t #include<cstddef> //ptrdiff_t ptrdiff_t. type. <cstddef>. Result of pointer subtraction. This is the type returned by the subtraction operation between two pointers. This is a signed integral type.

48 use cout << *pickrandel(w.begin(),w.end());

49 Standard Template Library Standard template library accepted in July 1994 into C++ ANSI Standard STL library provides containers, iterators and algorithms designed to work efficiently work parametrically work orthogonally

50 Two Varieties of Containers Sequence - ordered by sequence of elements Associative - keys for looking up elements deque! list! vector! set! multiset! map! multimap!

51 Typical Container Interfaces Constructors default constructors, copy constructors Element access Element insertion Element emplacement -new C++11(&&) Element deletion Destructor Iterators

52 Overview of Containers Common set of properties Constructors and destructors Element access, insertion and deletion Allocate and manage memory Associated allocator objects

53 Associative Containers Key based accessible elements set! multiset! map! multimap! Ordering relation Compare Comparison object for the associative container

54 Unordered_map C++11 introduces hash based lookup for map and set unordered_map -uses hash lookup unordered_set - uses hash lookup Advantage much of the time O(1) lookup

55 MAP Program #include <map> #include <unordered_map> #include <string> #include <iostream> using namespace std; //we will use both types of map

56 MAP Program { int main() map<unsigned long, string> worker; unordered_map<unsigned long, unsigned> payroll; unsigned total_pay =0; worker[ ] = "Harold Fish"; payroll[ ] = 67300; worker[ ] = "Phillip Fish"; payroll[ ] = 87300;

57 MAP Worker links id number to name Payroll links id number to salary Ordinary map red-black tree Unordered map hash

58 MAP for(auto p = worker.begin(); p!= worker.end(); ++p) cout << "name " << (*p).second << "\t id no. " << (*p).first << endl; //associate (first, second) // (id no, name)

59 MAP for(auto p = payroll.begin(); p!= payroll.end(); ++p) total_pay += (*p).second; cout << "payroll totals $"<< total_pay << endl;

60 STL Algorithms Library Sorting algorithms Non-mutating sequence algorithms Mutating sequence algorithms Numerical algorithms Generally use iterators to access containers instantiated on given type Resulting code can be competitive in efficiency with special purpose codes

61 Sorting Algorithm Prototypes template<class RandAcc> void sort(randacc b, RandAcc e); Quicksort algorithm over elements b to e template<class RandAcc> void stable_sort(randacc b, RandAcc e); Stable sorting algorithm over elements b to e Elements remain in their relative same position

62 Non-Mutating Sequence Algorithms Do not modify contents of the containers they work on Typical operation is searching container for particular element and returning its position

63 Non-mutating Algorithm template<class InputIter, Class T> InputIter find(inputiter b, InputIter e, const T& t)); Finds position of t in range b to e template<class InputIter, Class Predicate> InputIter find(inputiter b, InputIter e, Predicate p)); Finds position of first element that makes predicate true in range b to e, otherwise position e returned

64 Non-mutating Algorithm Prototypes (2 of 2) template<class InputIter, Class Function> void for_each(inputiter b, InputIter e, Function f)); Apply f to each value found in range b to e

65 Example: Algorithm find() int main() // find pos of "hop" { string words[5] = { "my", "hop", "mop", "hope", "cope"}; string* where; } where = find(words, words + 5, "hop"); cout << *++where << endl; //mop sort(words, words + 5); where = find(words, words + 5, "hop"); cout << *++where << endl; //hope

66 Lambda Expressions; for_each Expression Derived from Lisp Previously for_each needs a function Will use new C++11 idea write an unnamed function in place a lambda expression

67 Old style for_each() #include <algorithm> #include <vector> #include <iostream> using namespace std; void incr(int &i){static int n = 1; i = n++;} void outvec(int i){cout <<i << endl;} { int main() vector <int> v(6); for_each(v.begin(), v.end(), incr ); for_each(v.begin(), v.end(), outvec ); }

68 What got printed? vector <int> v(6); for_each(v.begin(), v.end(), incr ); for_each(v.begin(), v.end(), outvec ); }

69 Answer Static keeps value on exit, so

70 Lambda C++11 Taken from LISP Unnamed function [](int i){cout <<i << endl;} //goes where the function object is required

71 returns Lambda C++11 [] (int n) { return n * 5.5; }//double // deduces the return value no return void [] (int n) -> int { return ++n; } //explicit Read wikipedia about Lambda

72 Mutating Function template<class InputIter, class OutputIter> OutputIter copy(inputiter b1, InputIter e1, OutputIter b2); Copying algorithm over elements b1 to e1 Copy is placed starting at b2 Position returned is end of copy

73 Suggested work Write a small program with vectors that tests using copy()

74 Numerical Algorithms Sums Inner product Adjacent difference Numerical Algorithm functions behave as expected on numerical types where + and * are defined

75 Numerical Algorithm Program int main() { double v1[3] = { 1.0, 2.5, 4.6 }, v2[3] = { 1.0, 2.0, -3.5 }; double sum, inner_p; } sum = accumulate(v1, v1 + 3, 0.0); inner_p = inner_product(v1, v1 + 3, v2, 0.0); cout << "sum = " << sum << ", product = " << inner_p << endl;

76 Numerical Algorithm Prototypes (1 of 2) template<class InputIter, class T> T accumulate(inputiter b, InputIter e, T t); Standard accumulation algorithm whose sum is initially t Successive elements from the range b to e are added to sum

77 Numerical Algorithm Prototypes (2 of 2) template<class InputIter, class T, class BinOp> T accumulate(inputiter b, InputIter e, T t, BinOp bop); Accumulation whose sum is initially t Successive elements from range b to e are summed with sum = bop(sum, element)

78 Function Objects Useful to have function objects to further leverage STL library Numerical functions have built-in meaning using + or *, as well as user-provided binary operators which could be passed in Defined function objects can be found in function.h or built Function objects are classes that have operator() defined Inlined, compiled producing efficient object code"

79 Function Object for minus<int> int main() { double v1[3] = {1.0, 2.5, 4.6}, sum; sum = accumulate(v1, v1 + 3, 0.0, minus<int>()); cout << "sum = " << sum << endl; //sum = -7 } Accumulation using integer minus for binary operation over the array v1[]

80 Generator Object and Integration // The function is represented in class gen class gen { // generator for integrated function public: gen(double x_zero, double increment) : x(x_zero), incr(increment) { } double operator()() { x += incr; return x * x; } }; private: double x, incr;

81 integrate double integrate(gen g, int n) // integrate on (0,1) { vector<double> fx(n); } generate(fx.begin(), fx.end(), g); return (accumulate(fx.begin(), fx.end(), 0.0) / n);

82 End of code int main() { const int n = 10000; } gen g(0.0, 1.0/n); cout << "integration program x**2" << endl; cout << integrate(g, n) << endl;

83 Defined Function Object Classes Arithmetic objects Comparison objects Logical objects

84 Arithmetic Objects (1 of 2) template <class T> struct plus<t> Adds two operands of type T template <class T> struct minus<t> Subtracts two operands of type T template <class T> struct times<t> Multiplies two operands of type T

85 Arithmetic Objects (2 of 2) template <class T> struct divides<t> Divides two operands of type T template <class T> struct modulus<t> Modulus (%) for two operands of type T template <class T> struct negate<t> Unary minus for one argument of type T

86 Function Adapters Creation of function objects using adaption Negators for negating predicate objects Binders for binding a function argument Adapters for pointer to function

87 Use of Function Adapter bind2nd (1 of 2) template <class ForwIter> void print(forwiter first, ForwIter last, { } const char* title) cout << title << endl; while( first!= last) cout << *first++ << '\t'; cout << endl;

88 Use of Function Adapter bind2nd (2 of 2) // use a binder function bind2nd to transform initial sequence of // values to these values doubled int main() { int data[3] = { 9, 10, 11}; } print(data, data + 3, "Original values"); transform(data, data + 3, data, bind2nd(times<int>(), 2)); print(data, data + 3, "New values");

89 STL Based on Templates Key to understanding STL is to use iterator logic When extending STL keep consistent with existing libraries Generality and genericity are not enough: It s not STL if it isn t efficient

90 Next Time: How to play Tic-Tac-Toe The game of Hex term assignment