Lesson 11: Generic Programming. EE3490E: Programming S1 2018/2019 Dr. Đào Trung Kiên Hanoi Univ. of Science and Technology

Size: px

Start display at page:

Download "Lesson 11: Generic Programming. EE3490E: Programming S1 2018/2019 Dr. Đào Trung Kiên Hanoi Univ. of Science and Technology"

Carol Davidson
5 years ago
Views:

1 Lesson 11: Generic Programming 1

2 Function templates 2

3 General Occasionally, we like to write once but have many functions/methods with arguments of different types, instead of writing multiple overloaded functions int max(int a, int b) { return a>b? a:b; } double max(double a, double b) { return a>b? a:b; } float max(float a, float b) { return a>b? a:b; } programming at a more generic level: consider type of variables as parameters (type parameterization) Function template: helps to define functions having arguments of different types (late type determination) Can be considered as writing multiple overloaded functions with common algorithm Types of function arguments are parameters of the template Function templates are not functions, but their instances are 3

4 Defining a function template Example 1: template <typename T> void swap(t& a, T& b) { T c = a; a = b; b = c; } T can be any type used of arguments a, b and c T is resolved at compile time for each function call T is parameter of template, while a, b are parameters of functions Example 2: template <typename Containter, typename Object> void push(containter& s, Object o) {} Possible to use class keyword instead of typename template <class T> void swap(t& a, T& b) {} 4

5 Calling a template function Function calls with explicit types: max<int>(a, b); max<double>(x, y); swap<string&>(s1, s2); swap<worker*&>(p1, p2); push<list&, Student>(l, st); with implicit types: int a, b; double x, y; max(a, b); // max<int>(a, b); max(x, y); // max<double>(x, y); max(a, x); // error (ambiguous) 5

6 Overloading function templates Function templates can also be overloaded (like normal functions) template <typename T> T max(t a, T b) { } template <typename T> T max(t a, T b, T c) { } template <typename T> T max(t* arr, int n) { } Calling overloaded function template: max<int>(10, 20); max('c', 'f'); max<double>(1.5, 2.1, 3.14); max("1un34k", 6); 6

7 Specialization of function templates Possibly define special versions of function templates for particular argument types: template<typename T> T max(t a, T b) { return a>b? a:b; } template<> const char* max(const char* a, const char* b) { return strcmp(a, b) == 1? a:b; } Partial specialization: template <typename Containter, typename Object> void push(containter& s, Object o) {} template <typename Object> void push(stack& s, Object o) { } 7

8 Not only argument types can be parameterized but also return type template <typename Worker, typename Product> Product makeprod(worker& w) { w.work(); return w.getresult(); } and local variable types template <typename List, typename Iterator> void foreach(const List& l) { Iterator i = l.first(); for (; i!=l.last(); i = i.next()) dosmth(i.get()); } 8

9 Template parameters are not only types but can also be values used as constants template<typename Object, int N> Object* makearray() { return new Object[N]; } string* p1 = makearray<string, 5>(); Student* p2 = makearray<student, 10>(); Both types and values as parameters template<typename T, T min, T max> T range(t t) { return t<min? min : (t>max? max : t); } 9 y = range<double, -1.5, 2.>(x); b = range<int, 10, 20>(a);

10 Remarks when using function templates The implementation of a function template is only compiled when argument types are resolved if a function template is defined in a library, then its prototype and definition (implementation) must be put in the.h file (it s possible to put the definition in a separated file then include this file in the.h file) Only when there are calls made with specific argument types, corresponding functions will be generated from the template int a = 10, b = 20; swap(a, b); // generates: void swap(int&, int&) {} swap<float>(x, y); // void swap(float&, float&) {} Probably get errors with only some particular argument types template <typename T> T divide(t a, T b) { return a/b; } 10 double z = divide(1.5, 0.5); // OK const char* c = divide("ssss", "dddd"); // error

11 Class templates 11

12 General Similar to functions, classes can also be generically defined by templates class templates Declaring types used within a class as parameters template<typename Object> class Array { private: int N; Object* p; public: void setat(int i, Object o) {} Object& operator[](int i) {} 12

13 Methods defined outside of class template<typename Object> class Array { private: int N; Object* p; public: Array(int N); ~Array(); void setat(int i, Object o); int length() const; Object& operator[](int i); template<typename Object> Array<Object>::Array(int N) { this->n = N; p = new Object[N]; } template<typename Object> Array<Object>::~Array() { delete[] p; } template<typename Object> void Array<Object>:: setat(int i, Object o) { p[i] = o; } template<typename Object> int Array<Object>::length() const { return N; } template<typename Object> Object& Array<Object>:: operator[](int i) { return p[i]; } These methods are defined similarly to function templates, except the class scope 13

14 Instantiating template classes Example: Array<double> a(10); for (int i=0; i<10; i++) a.setat(i, i*2); typedef Array<string> StrArray; StrArray s(2); s[0] = string("abcd"); s[1] = string("12345"); Using function and class templates together template<typename Object> void printarray(array<object> &a) { for (int i=0; i<a.length(); i++) cout << a[i]; } 14 printarray(a); printarray(s);

15 Friend functions and classes Friend of only the corresponding class version template<typename T> class Array { friend void sort(array<t>& a); friend class Serializer<T>; Common friend with all class versions template<typename T> class A { friend void func1(); template<typename X> friend int func2(); friend class B; 15

16 Specialization of class templates template<typename Key, typename Data> class Map { Data find(key k); // full specialization template<> class Map<int, int> { int find(int k); // partial specialization template<typename Data> class Map<int, Data> { Data find(int k); 16

17 Default values of class template parameters Class template parameters can have default values, similarly to function and method arguments template<typename Object = int, int N = 100> class Pool { Pool<> p1; // Pool<int, 100> p1; Pool<string> p2; // Pool<string, 100> p2 Pool<double, 20> p3; Attn: only class templates have, function templates don t (*) * Default values of function template parameters have been added in the new C++11 standard 17

18 Static members of template classes Each class derived from template has its own static variables template<typename Data> class smartptr { static smartptr<data> nullptr; template<typename Data> static smartptr<data> smartptr<data>::nullptr; smartptr<string> p1 = smartptr<string>::nullptr; smartptr<double> p2 = smartptr<double>::nullptr; Similarly for static methods 18

19 Related class templates template<typename T> class Iterator; template<typename T> class List { Iterator<T> begin() { } Iterator<T> end() { } template<t> class Iterator { T& getdata() { } Iterator<T> next() { } List<float> l; Iterator<float> i; for (i = l.begin(); i!= l.end(); i = i.next()) cout << i.getdata() << endl; 19

20 Problems 1. Write a function to read user input for an array of arbitrary type 2. Write a function to sort an array of arbitrary type. Do this in two ways: (C) using a comparison function to determine the order of elements while sorting, (C++) using templates void sortc(void* a, int n, int size, int (*compare)(void*, void*)); template<typename T> void sortcpp(t* a, int n); 3. Write class Stack that allows to store data of any type, without need to use void* as before 4. Modify class LinkedList to allow storing data of any type 5. Modify class Iterator corresponding to above class LinkedList 6. Modify class Vector to allow manipulating vector with components of both float and double 7. Modify class String to allow working with both ASCII (char) and Unicode (wchar_t) character types 20

Comp151. Function Templates & Class Templates

Comp151. Function Templates & Class Templates Comp151 Function Templates & Class Templates Function Templates int max(const int& a, const int& b) string max(const string& a, const string& b) We often find a set of functions that look very much alike,