C++ (7. Vorlesung) Exercise Discussion, Advanced Templates

Transcription

1 C++ (7. Vorlesung) Exercise Discussion, Advanced Templates Thomas Gschwind 1

2 Agenda Exercise Discussions RPN Calculator Complex numbers (Operators) min (Complex) Connect 4 finding whether the opponent can win pvector with strings Advanced Template Topics Template Implementation: C++ vs. Java vs. C# Traits Dynamic Static Algorithm Selection 2

3 Complex numbers The standard complex class is trivial Don t use free-standing operators in combination with friends Make the operators members of the class Input and output is the only exception RPN calculator with complex Many colleagues did not implement it Many colleagues used the C++11 complex class (my mistake) Hint, you need to ensure that you have all the operators used by the RPN calculator: >>, <<, ==,!=, <, 3

4 RPN<complex> and min Yes, there is no ordering defined on complex classes Solutions I have seen/heard: Define min for complex as a<b iff a < b Creative solution but not really nice min function part of the RPN calculator => bad choice In C++ we don t have to cram random stuff into random classes Specialization for complex requires rewriting of RPN calculator Adapt min to return a pointer to the minimum, overload for complex and return NULL Creative solution but makes min not really nice to use Overload min for complex and throw an exception My favorite solution 4

5 pvector<string> Many colleagues tried the pvector with strings and did not observe anything Hello, World, Somestring, Apple, Banana : are not really useful strings to test something This is interesting, Tab\tstop, And\nnewlines?, Umlaute? ÄÖÜäöü : are better strings Then we would realize that white spaces are problematic with our pvector implementation, especially \n should have been obvious So, how do we solve this? This is the matter of today s lecture. 5

6 Connect 4: Checking if the other player could win A minority of colleagues look for 3 stones in a row (buggy x_xx) or a pattern of 3 in a series of 4 fields (better but clumsy) Most colleagues drop a stone and use the has_won method You don t need to copy the playfield every time, just remove the stone after the test Do this for every column dead simple Yes, with this implementation, you can already recursively start computing the next possible move for the opponent, etc. 6

7 Connect 4: Interoperability Exercises Get an implementation from your colleague almost nobody did this Do it for the next exercise when we do connect 4 with inheritance A few problems you would have encountered (or will encounter) You may want to extend your playfield The playfield your computer player receives, might be different if running in a colleagues implementation Just use the provided methods, not more If you rely on your own playfield, copy whatever you get into your own playfield that provides all the extra methods problem solved Maybe you do not want to extend your main playfield but use your own playfield class inside the computer player anyway The above are just some ideas to get you thinking! 7

8 Agenda Exercise Discussions RPN Calculator Complex numbers (Operators) min (Complex) Connect 4 finding whether the opponent can win pvector with strings Advanced Template Topics Template Implementation: C++ vs. Java vs. C# Traits Dynamic Static Algorithm Selection 8

9 C++ Templates Implementation C++ creates a new artifact for each new use of a template (almost, modern C++ compilers do some optimization) Similar to advanced C macros

10 C++ Templates Implementation (cont d) template<typename T> inline T min(t a, T b) { return a<b?a:b; } const double pi= ; void f() { // create implementation for min( ,1.0); // min<double> min('a','z'); // min<char> min(1,26); // min<int> min(pi, ); // already created min<char>('a',26); // already created min( ,1.0); // already created }

11 C++ Templates Consequences C++ creates a new artifact for each new use of a template Uses more memory Templates need to be defined in the header file (Otherwise, the compiler cannot instantiate them when they are used) Can be used in combination with built-in types Can be used in combination with non-typenames (e.g., ints, chars, ) Better optimization since the template can be optimized for each specific template argument

12 C++ Templates Question What if we have multiple source files instantiating the same template? file1.cc instantiating vector<int> file2.cc instantiating vector<int> Will the code for vector<int> be generated twice once for each object file? Will the executables be double the size when main.cc uses both of them?

13 C++ Templates Question What if we have multiple source files instantiating the same template? file1.cc instantiating vector<int> file2.cc instantiating vector<int> Will the code for vector<int> be generated twice once for each object file? Yes! Will the executables be double the size when main.cc uses both of them? No! Why? The corresponding code of the templates is put into a COMDAT section of the object file. The linker only uses the first such section with the same name.

14 Java Generics Implementation Java Generics are implemented using type erasure All the template parameters are internally replaced with their type bound (Object by default) The compiler inserts casts as necessary

15 Java Generics Implementation Source Code public class Iterator<E> { E next(); boolean hasnext(); } Iterator<String> iter= ; while(iter.hasnext()) { String s=iter.next(); } Generated Code public class Iterator { Object next(); boolean hasnext(); } Iterator iter= ; while(iter.hasnext()) { String s=(string) iter.next(); }

16 Java Generics Consequences Java keeps only one copy of the class Java Generics cannot be used with primitive types Need to be encapsulated in the corresponding wrapper class Java does this since quite some time automatic BUT generating wrappers requires memory, stresses the garbage collector Allows forward and backward compatibility with existing code public String oops(integer x) { List<String> ys = new LinkedList<String>(); List xs = ys; xs.add(x); // compile-time unchecked warning return ys.iterator().next(); } // run-time error

17 Java Generics Consequences (cont d) Java keeps only one copy of the class Uses more memory many casts need to be inserted Programs can be unsafe although they look safe (but the compiler will warn about it) Allows forward and backward compatibility with existing code Cannot create elements of E No new E or new E[] Especially the latter can be annoying, need to use Object[] and a lot of (E) casts which are unsafe JIT cannot optimize for different parameterizations

18 C# Generics Implementation C# thought about Generics from the start Unlike the Java VM, the CLR is already generic Generics can be parameterized with primitive types CLR JIT can optimize code for different parameterizations

19 C# Generics Consequences Templates are stored as such in the byte-code Can be used for built-in types Can use arrays of type T. Cannot be used in combination with non-typenames (e.g., ints, chars, ) Better optimization since the template can be optimized for each specific template argument Uses more memory Is somewhere between C++ and Java

20 Agenda Exercise Discussions RPN Calculator Complex numbers (Operators) min (Complex) Connect 4 finding whether the opponent can win pvector with strings Advanced Template Topics Template Implementation: C++ vs. Java vs. C# Traits Dynamic Static Algorithm Selection 20

21 pvector<string> Implement the persistent vector data type. Experiment with the persistent vector and use it in combination with different data types. What do you observe? Why do you observe that behavior? How can it be changed? What happens if we pass the pvector around? 21

22 A Persistent pvector Class (cont d) pvector.cc template<typename T> class pvector { string filename; vector<t> v; void readvector() { ifstream ifs(filename); for(;;) { What if we use string as type parameter? Reads a string up to the next whitespace T x; ifs >> x; if(!ifs.good()) break; v.push_back(x); } } void writevector() { ofstream ofs(filename); Writes a string with and without whitespace vector<t>::iterator fst=v.begin(), lst=v.end(); while(fst!=lst) ofs << *fst++ << endl; } 22

23 pvector for string? Use partial specialization Partial specialization allows us to change the implementation of a template for a specific class Very easy to implement but very repetitive pvector.cc template<> class pvector<string> { string filename; vector<string> v; void readvector() { } void writevector() { } // repeat all the other methods as is 23

24 pvector for string? (cont d) Use inheritance Need to change readvector and writevector in parent class to be virtual Implied dynamic dispatch although unnecessary We need a new class with a new name pvectorstring? pvectorstring.cc class pvectorstring : pvector<string> { virtual void readvector() { } virtual void writevector() { } } 24

25 pvector for string? (cont d) Factor out the persistence logic into a separate interface Yes, not so repetitive Yes, the persistence logic can be reused template<typename T> struct pvector_serialize { virtual void readvector(string fn) = 0; virtual void writevector(string fn) = 0; } 25

26 pvector with inheritance based serializer Pass serializer to pvector in constructor template<typename T> class pvector { string filename; vector<t> v; pvector_serializer<t> *serializer; public: pvector(string fname, pvector_serializer<t> *ser) : filename(fname), serializer(ser) { serializer->readvector(); } }; ~pvector() { serializer->writevector(); } 26

27 pvector for string? (cont d) Current solution is rather coarse grained Would be better to just factor out the read and write function Gives better reuse (left as exercise) template<typename T> struct element_serializer { virtual void read(ifstream &i, T &elem) = 0; virtual void write(ofstream &o, const T &elem) = 0; } Trouble is we always use virtual method calls although We know the type T And typically the serializer to be used upfront Templates, if used correctly allow the same mechanism as we just implemented with inheritance Same functionality, same everything, just more efficient 27

28 Traits are similar to Inheritance but Different Inheritance allows to define an interface to be provided by subtypes Traits define an interface to be used for any type AND provide a default implementation as well pvector.cc template<typename T> struct persister { static void read(ifstream &i, T &elem) { } static void write(ofstream &o, const T &elem) { } } With inheritance subtypes may override methods With traits, specializations may override methods pvector.cc Default implementation Same principle as for min<string> template<> struct persister<string> { static void read(ifstream &i, T &elem) { } static void write(ofstream &o, const T &elem) { } } 28

29 Pvector Refactoring First, let s refactor the pvector class to move the read and write methods into external classes 29

30 pvector for string? (cont d) pvector.cc template<typename T> struct persister { static void read(ifstream &i, T &elem) { } static void write(ofstream &o, const T &elem) { } } template<> struct persister<string> { static void read(ifstream &i, T &elem) Depending { } on the static void write(ofstream &o, const type T of &elem) container { } } template<typename T> class pvector { void writevector() { ofstream ofs(filename); <T> in use can be determined by the compiler vector ::iterator fst=v.begin(), lst=v.end(); while(fst!=lst) persister <T> ::write(ofs,*fst++); } 30

31 pvector for string? (cont d) Factor out the persistence logic in a separate class Yes, not so repetitive Yes, the persistence logic can be reused Yes, everything determined at compile time But, what if we want to use different persisters? Now, let s use our traits class in a polymorphic way Sort of like we are used from object-oriented programming Except that types are resolved during compile time 31

32 Traits are similar to Inheritance but Different Inheritance allows us to use different implementations Similarly, allow to specify the use of different implementations, independently of the trait s type The key difference is that all type inference is known, verified, and resolved during compile time pvector.cc template<typename T, typename P> class pvector { void writevector() { ofstream ofs(filename); vector<t>::iterator fst=v.begin(), lst=v.end(); while(fst!=lst) P<T>::write(ofs,*fst++); } foo.cc pvector<string, persister<string> > myvector; 32

33 pvector for string? (cont d) Make the persistence class generic Yes, now we can even specify the persister Yes, the code is as readable as generic Java code Yes, BUT creating a new object becomes tedious Are we picky?!? 33

34 pvector for string? (cont d) pvector.cc pvector.cc foo.cc template<typename T, typename P> class pvector { void writevector() { Typically called ofstream ofs(filename); a traits class vector<t>::iterator fst=v.begin(), lst=v.end(); while(fst!=lst) P<T>::write(*fst++); } template<typename T, typename P=persister<T> > class pvector { void writevector() { ofstream ofs(filename); This is not the most pretty implementation vector<t>::iterator fst=v.begin(), lst=v.end(); while(fst!=lst) P::write(*fst++); } pvector<string> myvector; 34

35 pvector for string Beauty Contest pvector.cc pvector.cc template<typename T, typename P> class pvector { void writevector() { ofstream ofs(filename); vector<t>::iterator fst=v.begin(), lst=v.end(); while(fst!=lst) P<T>::write(*fst++); } template<typename T, typename P=persister<T> > class pvector { typedef P persister; typedef typename vector<t>::iterator iterator; void writevector() { ofstream ofs(filename); This helps the compiler to identify that the following is a typename iterator fst=v.begin(), lst=v.end(); while(fst!=lst) persister::write(*fst++); } 35

36 Agenda Advanced Uses of Templates Traits Not just typenames? C++ Standard Library II Iterators & Algorithms Binders 36

37 Different Types of Iterators Category output input forward bidirectional randomaccess Abbrev. Out In For Bi Ran Read =*p =*p =*p =*p Access -> -> -> -> [] Write *p= *p= *p= Iteration Compare ==!= ==!= ==!= *p= = = == < <=!= > >= 37

38 Types of Iterators (cont d) Input Output Forward Bidirectional struct input_iterator_tag {}; struct output_iterator_tag {}; struct forward_iterator_tag : public input_iterator_tag {}; struct bidirectional_iterator_tag : public forward_iterator_tag {}; struct random_access_iterator_tag : public bidirectional_iterator_tag {}; Random Access 38

39 Iterator Tags? Algorithm selection Saves typing overhead Simulation of bound genericity 39

40 Why Iterator Tags? (cont d) iterator template <class In> iterator_traits<in>::difference_type distance(in first,in last, input_iterator_tag dummy) { iterator_traits<in>::difference_type n = 0; while(first!=last) { ++first; ++n; } return n; } template <class Ran> iterator_traits<ran>::difference_type distance(ran first,ran last, random_access_iterator_tag dummy) { return last-first; } template <class I> inline iterator_traits<i>::difference_type distance(i first,i last) { typedef typename iterator_traits<i>::iterator_category cat; return distance(first,last, cat()); } 40

41 iterator_traits iterator template <class Iter> struct iterator_traits<iter> { typedef typename Iter::iterator_category iterator_category; typedef typename Iter::value_type value_type; typedef typename Iter::difference_type difference_type; typedef typename Iter::pointer pointer; typedef typename Iter::reference reference; }; template <class T> struct iterator_traits<t*> { typedef random_access_iterator_tag iterator_category; typedef T value_type; typedef ptrdiff_t difference_type; typedef T* pointer; typedef T& reference; }; 41

42 Advise Decide which algorithms you want; parameterize them so that they work for a variety of suitable types and data structures. Bjarne Stroustrup 42

43 Summary Exercise Discussions RPN Calculator Complex numbers (Operators) min (Complex) Connect 4 finding whether the opponent can win pvector with strings Advanced Template Topics Template Implementation: C++ vs. Java vs. C# Traits Dynamic Static Algorithm Selection 43

44 Exercise 1 Adapt your persistent pvector to make use of the new persister trait. Also implement a pset that implements a persistent set (based on std::set). 44

45 Exercise 2 Extend your dictionary program Instead of printing out all unknown words, your program should allow the user to correct them or insert them into the dictionary if spelled correctly but not in the dictionary. Make use of your persistent set implementation form exercise 1. Please make a copy of the old version of the dictionary program. 45

46 Exercise 3 Implement a template based version of the Connect 4 game where players. Connect 4 builds on a playing field composed out of 7 columns each having 6 rows. When a player puts a stone into a column, gravity pulls the stone towards the lowest unoccupied column. The player who first has 4 stones in a row (horizontally, vertically, diagonally) wins. After each turn display the game field using simple ASCII graphics. Implement the game in such a way that players can be exchanged easily using templates. The precise interfaces to follow will be published at the lecture s homepage. It is important that you follow these interfaces religiously. 46

47 Exercise 4 Implement a computer player. Again, the computer player of this version does not have to be intelligent. At a minimum, however, the computer player should be able to identify whether he can win the game by placing a stone. Let your computer player compete against computer players from your colleagues. 47

48 Exercise 5: rpn_calculator<complex> Make sure the RPN calculator works with both with your implementation of complex numbers With the C++11 version of complex numbers 48

49 Next Lecture Algorithms, Binders, and Programming with Templates Have fun solving the examples! See you next week! 49

50 Agenda Exercise Discussions RPN Calculator Complex numbers (Operators) min (Complex) Connect 4 finding whether the opponent can win pvector with strings Advanced Template Topics Template Implementation: C++ vs. Java vs. C# Traits Dynamic Static Algorithm Selection 50