template<typename T> cout << "The value is << value << endl; } void printdata(t value){

Transcription

1 C++ Templates

2 Parametric Polymorphism void printdata(int value){ cout << "The value is << value << endl; void printdata(double value){ cout << "The value is << value << endl; void printdata(string value){ cout << "The value is << value << endl; template<typename T> void printdata(t value){ cout << "The value is << value << endl; double d=4.75; string s("hello"); bool b=false; printdata(3); //T is int printdata(d); //T is double printdata(s); //T is string printdata(b); // T is bool 2

3 Function Template template <typename T> T GetMax (T a, T b) { T result = (a>b)? a : b; return result; Definition void main(){ int i=5, j=6, k; double d=3.14, e=5.0, f; k=getmax<int>(i,j); f=getmax<double>(d,e); Usage 3

4 Specifying Actual Template Parameters Explicit: template<typename T> void func() { int main(){ func<int>(); func<double>(); Implicit: template<typename T> void func(t value) { template<typename T,typename U> T func2(u value) { return T(value); int main(){ // T=int func(3); // T=int, U=double func2<int>(3.5); 4

5 Class Template template <typename T> class MyQueue { std::vector<t> data; public: ; void add(t const &d); void remove(); void print(); void main(){ MyQueue<int> q; q.add(1); q.print(); template <typename T> void MyQueue<T>::add(T const &d){ data.push_back(d); Usage Declaration Definition q.remove(); q.print(); 5

6 Template Parameters Type parameters typename name or class name name can be used anywhere a type can be used Non-Type parameters compile-time constants int, bool, address of a global variable No floating point values Template parameters Next slide template<int i> class A{; A<3> a3; A<sizeof(string)> as; 6

7 Template Template Parameters Enable a template to be parameterized by the name of another template. Example: a class that lets you choose a container type A container is also a template template<template<typename T> class ContainerType> class MyClass{ ; ContainerType<int> intcontainer; ContainerType<string> stringcontainer; MyClass<vector>; MyClass<list>; 7

8 Default Template Parameters Just like functions If a parameter has a default specified, all subsequent parameters must also have a default specified. When referencing a template, parameters with default values can be omitted if a template parameter is omitted, all subsequent template parameters must also be omitted. template<typename T1,typename T2=int,int i=23> class MyClass{; MyClass<double, string,46> mc1; // specify all parameters MyClass<string,double> mc2; // omit "i" MyClass<string,double,23> mc3; // same as above MyClass<int> mc4; MyClass<int,int,0> mc5; // all default // must specify "T2" to specify "i" 8

9 Templates Instantiation Two template instantiations refer to the same template if their parameters are all the same typedef string MyString; typedef vector<string> T1; typedef vector<mystring> T2; T1 vec1; T2 vec2; vector<string> vec3; 9

10 Instantiation of Member Functions Member functions of class templates are only instantiated if they are referenced. template <typename T> class MyClass{ public: T* makecopy(t* p){ return p->clone(); ; MyClass<int> mci; // OK double d; MyClass<double> mcd; // OK double* pd=mcd.makecopy(&d); // error 10

11 Templates and Static Members Each instantiation of the template will have its own private copy of the static members. Template <typename T> class X { public: static T s ; ; It s a template Member name template <class T> T X<T>::s = 0 ; member type Initialization value 11

12 Templates and Friends template <typename T> class X { ; friend class Y<T>; // Y<T> is friend of X<T> only if // they have the same type parameter template <typename OtherType> friend class Z; // All instances of Z are friends to all // instances of X. friend class Foo; //class Foo is friend to all instances of // X. 12

13 Templates and Inheritance Templates and inheritance can be related in different ways A class template derived from a class template instantiation template<typename T> class Base{ ; template<typename T> class Derived : private Base<T>{ ; A class template derived from a non-template class class Base{ ; template<typename T> class Derived : private Base{ ; A non-template class derived from a class template instantiation template<typename T> class Base{ ; class Derived : Base<ConcreteType>{ ; Mixins template<typename T> class Derived : T { ; 13

14 Template Constraints Constraints on parameters are implicitly imposed operations that must work on objects of the appropriate type class members that must exist template<typename T> void func(t value) { const T ref=value; //copy ctor T* p=new T; // public default ctor *p = ref; // assignment operator T temp(23); // ctor with int argrument p->clone(); // clone() member 14

15 Template Specialization Allows defining different code for a specific set of template parameters Explicit specialization template<typename T> struct Printer { void print(t t) { cout << "the value is " << t << endl; ; template<> struct Printer<int> { void print(int n) { cout << "the number is " << n ; << endl; 15

16 Compile-time Computations with Explicit Specialization template<int N> struct Factorial{ enum {value = N*Factorial<N-1>::value; ; template <> struct Factorial<0> { enum {value = 1; ; void foo(){ int x = Factorial<4>::value; // == 24 int y = Factorial<0>::value; // == 1 16

17 Partial Specialization Specializing for a subset of the template parameters template <typename T,typename U> struct SameType{ static const bool result=false; ; template <typename T> struct SameType<T,T> { static const bool result=true; ; void foo(){ cout<<"is int the same type as double?" <<(SameType<int,double>::result?"Yes":"No") <<endl; cout<<"is string the same type as string?" <<(SameType<string,string>::result?"Yes":"No") <<endl; 17

18 Meta Operations template <bool g, typename T, typename E> struct IF { typedef T RET; ; template < typename T, typename E> struct IF<false, T, E> { typedef E RET; ; // if sizeof(int) < sizeof(long) then use long else use int IF< sizeof(int)<sizeof(long), long, int>::ret i; 18

19 typename keyword Used for denoting qualified, dependent types. e.g.: template <typename T> struct SameType{ int x; void foo() { T::something * x; ; Is T::something a type or a value? template <typename T> struct SameType{ int x; void foo() { typename T::something * x; ; 19