CS 247: Software Engineering Principles. C++ Templates. Reading: Eckel, Vol. 2 Ch. 5 Templates in Depth. U Waterloo CS247 (Spring 2017) p.

Transcription

1 CS 247: Software Engineering Principles C++ Templates Reading: Eckel, Vol. 2 Ch. 5 Templates in Depth U Waterloo CS247 (Spring 2017) p.1/16

2 Overloaded Functions Problem: Code in overloaded functions whose function bodies are identical, except for the types of their arguments. int compare(const int &v1, const int &v2) { if (v1 < v2) return -1; if (v2 < v1) return 1; return 0; int compare(const string &v1, const string &v2) { if (v1 < v2) return -1; if (v2 < v1) return 1; return 0; U Waterloo CS247 (Spring 2017) p.2/16

3 C++ Function Templates A function template describes a family of functions: template <typename T> int compare(const T &v1, const T &v2) { if (v1 < v2) return -1; if (v2 < v1) return 1; return 0; Client Code: compare (1, 3); // compare<int> compare (3.14, 2.7); // compare<double> U Waterloo CS247 (Spring 2017) p.3/16

4 Template Instantiation When the client programmer instantiates a template, the compiler generates and compiles a type-specific version of the template. int compare(const int &v1, const int &v2) { int compare(const if string (v1 < v2) &v1, return const -1; string &v2) { if (v2 < v1) return 1; int compare(const if (v1 < v2) Thing return &v1, 0; -1; const Thing &v2) { if (v2 < v1) return 1; if (v1 return < v2) 0; return -1; if (v2 < v1) return 1; return 0; U Waterloo CS247 (Spring 2017) p.4/16

5 Template Argument Deduction If a template type parameter is used for more than one function parameter, the deduced types for the call arguments must match; otherwise it is an error. template <typename T> int compare(const T &v1, const T &v2) { Client code: short si = 5; compare (si, si); // compare<short> compare (si, 20); // error - compiler cannot infer type U Waterloo CS247 (Spring 2017) p.5/16

6 Another Example template <class InputIter, class OutputIter, class Predicate> OutputIter copy_if (InputIter first, InputIter last, OutputIter result, Predicate pred) { for ( ; first!= last; ++first) if ( pred(*first) ) *result++ = *first; return result; U Waterloo CS247 (Spring 2017) p.6/16

7 C++ Class Templates Define a generic (parameterized) class e.g., a container whose element type is specified by a parameter template <typename T> // T is element type class Stack { public: Stack(); void push( const T& ); T top() { return items_[ top_ ]; void pop(); private: T items_ [STACK_SIZE]; int top_; ; template <typename T> void Stack<T>::push( const T &elem ) { ++ top_; items_ [top_] = elem;... U Waterloo CS247 (Spring 2017) p.7/16

8 Class Template Instantiation The actual element type is determined by the argument for T. When instantiating a class template, the user must provide the template parameter the compiler cannot infer this type. // Client code Stack<string> ss; Stack<int> is; Stack<Figure*> fs; The compiler generates an string-version of Stack by substituting string for T and generating the corresponding code. The compiler generates an int-version of Stack by substituting int for T and generating the corresponding code. The compiler generates a Figure-version of Stack by substituting Figure* for T and generating the corresponding code. U Waterloo CS247 (Spring 2017) p.8/16

9 Non-Type Template Parameters Can have non-type template parameters, which are treated as compile-time constants. - Can provide a default value. template <typename T, int size = 100> class Stack { public: Stack(); void push( const T& ); T top(); void pop(); private: T items_ [ size ]; int top_; ; Client code provides a compile-time value for size: Stack<int,99> mystack1; // stack of size 99 Stack<int> mystack2; // stack of size 100 U Waterloo CS247 (Spring 2017) p.9/16

10 Friends There are three kinds of friend declarations that may appear in a class template. Each kind of declaration declares friendship to one or more entities: 1. A friend declaration for an ordinary non-template class or function, which grants friendship to the specific named class or function. 2. A friend declaration for a class template or function template, which grants access to all instances of the friend. 3. A friend declaration that grants access only to a specific instance of a class or function template. U Waterloo CS247 (Spring 2017) p.10/16

11 "Duck Typing" How the template definition uses variables of type T will impose some requirements on allowable instantiations: template <typename T> T mumble (T val) { T newval = val; T *p = nullptr; val.speak(); cout << "val = " << val << endl; if ( val < newval) return "success"; U Waterloo CS247 (Spring 2017) p.11/16

12 Design Considerations 1. How should parameters of template type be passed? - Pass-by-value (appropriate for built-in types)? - Pass-by-reference (appropriate for class types)? 2. Consider the initialization of objects with parameterized members. template <typename T, typename U> struct pair { T first; U second; pair() : first {T(), second {U() { pair( const T &t, const U &u) : first {t, second {u { ; template <typename V, typename W> pair (const pair<v,w> &p) : first{p.first, second{p.second { U Waterloo CS247 (Spring 2017) p.12/16

13 Template Compilation 1. The template definition is compiled first. - If the code might be legal for some type T, then the definition is considered to be legal. // file max.h template <typename T> T max(t a, T b) { return a > b? a : b; 2. When the template is instantiated, then the instantiated class/function is type checked again. // Client code #include "max.h" #include "MyObject.h"... MyObject a{, b{ ; MyObject c = max<myobject>(a,b); U Waterloo CS247 (Spring 2017) p.13/16

14 Template Compilation 3. The compiler must see the template definition in order to instantiate and compile the template. a) Include template definitions in header file. Can #include implementation to maintain separation of header and implementation code. // header file utilities.h #ifndef UTILITIES_H // header guard #define UTILITIES_H template <typename T> int compare(const T&, const T&); // other declarations #include "utilities.hpp // get the definitions for compare etc. #endif // implementation file utilities.hpp template <typename T> int compare(const T &v1, const T &v2){ if (v1 < v2) return -1; if (v2 < v1) return 1; return 0; // other definitions U Waterloo CS247 (Spring 2017) p.14/16

15 C++11 : Variadic Templates In C++11, templates can have a variable number of template arguments. void print () // base case { template <typename T, typename... Types> void print (const T& firstarg, const Types&... args) { std::cout << firstarg << std::endl; // print first argument print(args...); // call print() for remaining arguments U Waterloo CS247 (Spring 2017) p.15/16

16 What You Should Get From This Recognition Know the purpose and motivation of templates, functors, functor adapters, lambdas. Know what Duck Typing is, and how it applies to generics. Comprehension Select appropriate STL container type based on how container is used in program. Application Use basic STL containers: vector, deque, list, set, map. Write a small program using STL algorithms, iterators. Specialize STL algorithms with functions, functors, lambdas. Specialize functions/functors with predefined functor adapters. Write small function or class templates. U Waterloo CS247 (Spring 2017) p.16/16