Instantiation of Template class

Size: px

Start display at page:

Download "Instantiation of Template class"

Elvin Evans
5 years ago
Views:

1 Class Templates Templates are like advanced macros. They are useful for building new classes that depend on already existing user defined classes or built-in types. Example: stack of int or stack of double Until compilers and linkers are integrated better, the template classes definitions as well as code are placed in header file. You include a template file (i.e. header file) in your source program. You should never compile a template file alone. member functions must be template functions. 800

2 An example template <class T1, class T2> class SomeNewClass { public: SomeNewClass(const T1& t1); ~SomeNewClass(); T1& SetData(const T2& t2, int n); : private: T1 a; T2 b; } Code for all functions are placed here. 801

3 Instantiation of Template class #include <somenewclass.h> int main() { SomeNewClass<int,double> x; SomeNewClass<string,int> y; : : } Compiler will create automatically two sets for functions based on the template code. 802

4 Template List Class template <class ListItem> class List { public: List(); ~List(); bool IsEmpty(); void Insert(int pos, const ListItem& item, bool& success); void Delete(int pos, bool& success); : : 803

5 Template List Class (contd) private: struct ListNode; typedef ListNode* ListNodePtr; struct ListNode { ListItem item; ListNodePtr next; }; } ListNodePtr head; int size; 804

6 Template List Class (contd) template <class ListItem> List<ListItem>::List() { : } template <class ListItem> List<ListItem>::Insert(int pos, const ListItem& item, bool& success) { : } 805

7 Operator Overloading Standard Operators in C++ can be overloaded to have a different meaning when applied to operands of a new user defined class. The associativity or precedence of the operators remain the same. Operators such as + - * / = == < <= > >= & [] e.t.c. are all candidates for overloading. When overloading these operators we should maintain the intuitive meaning of these operators. We should also try to be consistent with their usage on built-in types. a + b does not change a or b. a = b, changes a but not b. It has value so that we can do c = a = b; 806

8 Operators as member functions If you define an operator using a member function, then the left operand must be an object of the class for which the overloading is done. Operator funtions can be overloaded. e.g. Complex a,b,c; c = a + b; is same as c = a.operator+(b); which in turn is same as c.operator=(a.operator+(b)); Will c = a + 2 work? Yes!! if Complex class has a constructor that takes an integer as parameter. Compiler will create a temporary object using this constructor and add with a. Then the temporary object is destroyed. Thus, there is implicit casting done on rhs. 807

9 Operator as member function Will c = 2 + a work? No!! Compiler will not cast 2 into Complex obj. Casting is done only for function parameters, not for the implicit object. When you define a operator as member function, the lhs operand MUST be an obj of the class. The type of rhs operand can be anything as long as you provide an operator function that takes that type or else there is a constructor function. Casting is done only if it can t find a matching function. It is not a good idea to depend on casting. If there is more than one way to cast, it leads to confusion. 808

10 Operator as non-member function It is also possible to define the operator functions as non-member functions. Non-member function do not have implicit operand. Both operands are passed. Both operands are defined as const ref parameters. Non-member function can t access private variables of the class, unless it is defined as friend function inside the class (prototype). If non-member function is defined as friend, it serves as the prototype or else give an explicit prototype anyway. Avoid friend functions as much as possible. 809

11 Operator as non-member function With non-member function operator+ will the following work? Complex a,b; b = 2 + a; Yes!! 2 will be cast as Complex object by compiler Non-member function is preferable to member functions when defining operators. Provide sufficient access functions in the class so that there is no need to give friend status to the function. 810

12 Operator Overloading (contd) class Foo { public: : bool operator<(const Foo& rhs) const; Foo operator+(const Foo& rhs) const; Foo& operator=(const Foo& rhs); bool operator==(const Foo& rhs) const; : } Note the use of const as necessary in defining the operator functions. For templates, Foo becomes, say Foo<T>. 811

13 operator = The left hand side operand is the implicit object. The left-hand side object is assigned the value of right hand side object. The code for operator= should first check for selfassignment. The code should also free the existing values for left hand side object before copying rhs. The return value should be a reference to the left hand side object (which is implicit). This can be done by return(*this). The right hand side object should not change and hence is a const parameter. 812

14 Operator + + means addition for numbers. + can mean concatenation for strings. + can mean Union for sets. + can mean pair-wise addition for arrays or matrix The return value must be a new object. A local variable is needed to create the new object before it can be returned. return statement will invoke copy constructor. Can be very inefficient if a large object creation and copy is made. Inherent problem in C++. We need to depend on compiler to optimize this. 813

15 Operator >> We can define this operator so that we can read an object using iostream. e.g. Complex a; cin >> a; Notice that the lhs operand is not of type Complex Member function is NOT possible. Always pass iostream objects by reference. Not even const (unless you don t do io in the fn). Invariably, these functions will need access to private variables and hence the friend access may be needed for this function. The return value should be reference to the stream object passed. 814

16 mutable Suppose we want to implement a class in which we have some private variables that are used for efficiency but not quite associate with the class itself. e.g. iterators for list use a private pointer curr. string class can have two variables datalength and lengthvalid flag to compute the length of string and store so that subsequent calls can use this for efficiency instead of recomputing. Length function uses these variables. Should Length be const fn? These functions should be allowed on const objects, but the compiler will not treat them as const functions. Soln: Define these variables as mutable. 815

17 Stream Input Consider reading an integer from cin. int sum, m, n; cin >> m >> n; sum = 0; while (cin >> m) { sum += m; } The value of cin >> m should be cin itself so that we can read n in cin >> m >> n; What should the value of cin >> m in while loop? If the value is cin, which is not NULL, it is always true and hence the loop should be infinite!!! 816

18 Stream Input (Contd) while loop expects an integer. The steam class provides an operator to cast cin to an int. That function ignores the pointer and returns the status of the stream (good or bad). The status of the stream should be bad after reading past end of file or after reading a bad input If the status of a steam is bad, no further input is possible until you clear the stream. When you open a file, if the file does not exist or it could not be opened, the stream is placed in a bad state. Thus, you cannot perform io. If you do, you will get garbage. 817

19 Stream Input (contd) iostream has 4 bits. enum io_state { goodbit = 0x00, eofbit = 0x01, failbit = 0x02, badbit = 0x04 }; Member Functions: int good() -- All ok int eof() -- stream encountered eof int fail() -- operation not successful int bad() -- operation invalid int rdstate() -- read current state void clear() -- restore to good state int operator!(); true if fail or bad bit is set. e.g. if (!cin) or if (! (cin >> n)) 818

20 Operator>> The operator>> is intended to read an object. If it sees end of file or it sees bad input, it should place the stream in a bad state. It is possible that the stream is placed in a bad state when doing io to read a subpart of the object. In that case, there is nothing to do. If the input read does not meet the expectation, we want to place the stream in bad state by doing fis.setstate(ios_base::failbit); To clear a stream, you can do fis.clear(); 819

21 Operator++ (or --) ++ and -- are unary operators. The impicit object is the operand. Since there are two types: pre and post, we need a way to distinguish between them. The pre-increment operator for a class Foo is written as Foo& operator++(); The post-increment operator for a class Foo is written as Foo& operator++(int); int argument is not used in the code and hence there is no need to specify the variable name. 820

22 Casting Operators You can write casting operators for a class Foo so that an object of type Foo can be converted to an object of another type. These are special member functions that have the syntax: operator <type>(); Note that there is no return type. Note that there is no parameter. class Foo { : operator int(); : } Foo a; int b; b = (int)a; <type> can be any type. e.g. int *, void *, char *, double, etc. 821

23 operator [] This operator overloading is meaningful for an object that has container objects. [] can be used to retrieve individual objects. For example, if we have a vector object, we can access or change individual members. The syntax is: <elemtype>& operator[](int index) const The return value is a reference object which can be used on lhs or rhs of an assignment statement. The return type can include the keyword const to prevent changes done on the object. Then, we can only retrieve the object but not change it. 822

24 Temporary Object It is possible to create temporary objects that can be useful in expressions. These temporary objects are automatically created and deleted by the compiler. We can create a temporary object by simply using the name of the class. Let us say we have a class called Rational that has a constructor function that takes an integer. Then, we can use it as follows: Rational a(1,2), b(1,4), c; c = a + b + Rational(2); The value of c will be 1/2+1/4+2 = 2 3/4 c = (int) a; // Need operator int(). 823

25 Inheritance If you define a class based on a previously defined class, the derived (or descendant) class is said to inherit many properties of the base (or ancestor) class. It is possible to have an hierarchy of classes arranged in a tree like structure. Inheritance describes the ability of a class to inherit information from ancestor classes. A class can be based on more than one base class in which case we are said to have multiple inheritance. We will avoid it in this course. It is complex and can lead to confusion if not used properly. 824

26 Why Inheritance? Inheritance enables the reuse of existing classes. Inheritance reduces the effort needed to add new features to an existing object. For example, we can have a class called Person and then create a new class called Student and yet another class called Faculty both of which are derived from Person. Features that are common to both classes are placed in Person and hence reduces the need for duplication of information in classes. When an object is created for a class, it is also considered to be an object of all super classes. 825

27 What is inherited? All member of the base class are inherited except the constructors and destructors. The derived class can add new members (both variables and functions) You cannot revise the ancestor s members. You can redefine member functions to have a different meaning in a derived class. You cannot redefine data members. When an object is created, remember that we need to initialize all variables and this will involve the constructor functions for ancestor classes. 826

28 Inheritance vs Access? The derived class inherits the private variables of the base class but cannot access them directly. Thus, we need to depend on constructor and member functions to deal with these variables. Inheritance does not mean accessibility. The member functions of a derived class can call public member functions of the base class. The member functions of a derived class cannot call private member functions of the base class. What if a function name, say Foo, is common to both classes? An object of a derived class will use the one in derived class and an object of the base class will use the one in base class. 827

29 Protected Members A class can have protected members in addition to public and private. protected members are not accessible to clients of the class. protected members are accessible to derived class. protected category helps to share information among the classes in a single path of the hierarchy without sharing that information with other clients In general, one should place variables in private section. Place them in protected if it is essential to share them with derived classes. 828

30 Kinds of Inheritance Public Inheritance: Both public and protected members of the base class remain public and protected members of the derived class. (i.e Keep same type of access) Protected Inheritance: Both public and protected members of the base class become protected members of the derived class. Private Inheritance: Both public and protected members of the base class become private members of the derived class. Note that the derived class keeps the same access or more stringent access (not more liberal access) 829

31 Data Initialization Since the derived class inherits all data members of the base class, we need to initialize them all. When an object of the derived class is created, we call the constructor function of the derived class. The constructor function of the derived class will automatically call the constructor function of the base class. Thus constructor functions are executed starting from the farthest ancestor to the derived class. Thus, a constructor function of a class is only responsible for initializing variables explicitly defined in that class not for those inherited. 830

32 Is-A Relationship If you find that two classes share is-a relationship, then it indicates that you can use public inheritance. An object of the derived class can be substituted for an object of the base class. (Object Type Compatibility). Thus, if a function expects a formal parameter to be of base type class, you can call it with derived class object. Object compatibility applies both to reference and value parameters. This leads to the issue of static vs dynamic (late) binding. 831

33 Has-A relationship A ball-point pen has ball has its point. You wouldn t want to use a ball wherever a pen is expected! You may not even want to use inheritance here. Make the ball as an object in the pen class. i.e it is a member of the pen class. has-a ==> containment When an object of type pen is created, an object of type ball is indirectly created and hence the constructor function for this should be called. This is done in the initializer list. Destructors are executed in reverse order. 832

34 As-A relationship You can implement stack as a list. When there is as-a relationship, consider private inheritance. Both has-a and as-a relationships are possible when public inheritance in inappropriate. When you have private inheritance, the public and protected members of the base class become private and hence are not accessible to any new derived classes. has-a is the simplest to use and is preferable if it is sufficient for your needs. 833

35 Private Inheritance If class D privately inherits from class B, then we can say that D is implemented in terms of B. Object of type D cannot be substituted for objects of type B. Private Inheritance means nothing during Software Design, only during Software implementation. Private inheritance means that implementation only is inherited; interface should be ignored. Example: Suppose we implement stack in terms of list. Clearly an object of type Stack has a different interface from an object of type List. List is used only to implement Stack. 834

36 Inheritance Syntax class Ball: public Sphere { : } class Ball: protected Sphere { : } class Ball: private Sphere { : } 835

37 Constructor Usage Ball::Ball():Sphere(),... { : } call the base class constructor Ball::Ball(int n):sphere(n),... { : } 836

38 early binding Let us assume that both Sphere and Ball classes have a function called Display. Consider the following examples: Sphere s1(3); Ball b1(4); Sphere *p = &s1; Sphere *q = &b1; s1.display(); // early binding b1.display(); // early binding p->display(); // late binding? q->display(); // late binding? Since p and q are pointers to Sphere, the last two calls will call Display in Sphere. Even the last one!! 837

39 Virtual Functions and Late Binding In the previous example, if we defined Display in Sphere class as a virtual function, then the last example will call the Display in Ball class rather than the one in Sphere class. Virtual keyword ==> Use the function in derived class if it has one. Assume that Display in sphere is declared as virtual. Sphere *p = &s1; p->display() will still call Display in Sphere as the object is an instance of Sphere, not Ball. So, the question of considering Display in Ball does not even arise. 838

40 What is Late Binding? Thus, the determination of which function to call for a particular statement in the code is done at run time rather than during compiler time. This is known as late or dynamic binding. Dynamic binding is possible for functions declared as virtual. Thus a virtual function can be overridden in the derived class. The function Display is called polymorphic. A polymorphic function has multiple meanings. If you want the function in derived class to override the one in base class, don t forger virtual! 839

41 Omission of Virtual keyword What happens if we omit virtual keyword? class Sphere { public: double Area() const; virtual Display() const; : } class Ball:public Sphere { public: double Area() const; } Ball class has Display function. 840

42 Ball b(10); Omitting Virtual Keyword b.display(); Let us say Display calls Area(). Since Area is not defined as virtual, the call to Area in Display will be interpreted by the compiler as the Area in Sphere (static binding). Thus the area function called will be the one in Sphere not the one in Ball. If we had defined Area as virtual, then the Area() function call in Display will use late binding and will call correctly the Area in Ball class. 841

43 Virtual Method Table The compiler creates a table for each class in which it keeps track of the pointer to the actual function to be called for each virtual function defined in the class. VMT is invisible to the programmer as it is automatically created and managed by the compiler. A call to the constructor establishes this table. Thus, VMT enables late (or dynamic) binding. 842

44 Abstract Class When a class defines a virtual function, normally the code for the function is also given. Virtual function means, use the one in base class unless it is overridden in the derived class. Thus the code for the base class virtual function is the most common use of the function. The code in derived classes are used to capture special cases. A base class can decide not to write the code for a virtual function. Thus, every derived class MUST provide one. Such a virtual function is called a pure virtual function. A class with at least one pure virtual function is called an abstract class. No instantiation allowed. 843

45 Abstract Class (contd) Abstract classes are useful to build an hierarchy of classes. We do not create an instance (i.e an object) of an abstract class. It is not allowed in C++. You declare a virtual function as pure by using = 0 virtual int Display() = 0; If a class does not have any virtual function, it means that it is meant to be used as a base class. If a class has at least one virtual function, you should normally declare the destructor as a virtual function too. It is highly recommended. If a class has no virtual function, don t declare destructor function as virtual. Bad idea. 844

46 Destructors and Inheritance When you have inheritance, the destructor functions are called in reverse order. What happens if we try to delete a derived class object using a base class pointer? The compiler will call the destructors starting only from the base class going up in the hierarchy. But,we want to call destructors starting from the most specific class. The solution is to make the destructor function virtual in base classes. One twist: If you want to make a class abstract but you have no pure virtual functions, what do you do? Make the destructor a pure virtual function. But, you must provide code for this destructor fn. 845

Short Notes of CS201

#includes: Short Notes of CS201 The #include directive instructs the preprocessor to read and include a file into a source code file. The file name is typically enclosed with < and > if the file is a system