CS410 – Software Engineering Lecture #8: Advanced C++ III

Slides:



Advertisements
Similar presentations
The C ++ Language BY Shery khan. The C++ Language Bjarne Stroupstrup, the language’s creator C++ was designed to provide Simula’s facilities for program.
Advertisements

1 Inheritance Concepts n Derive a new class (subclass) from an existing class (base class or superclass). n Inheritance creates a hierarchy of related.
1 Inheritance and Polymorphism Andrew Davison Noppadon Kamolvilassatian Department of Computer Engineering Prince of Songkla University.
Virtual Functions Junaed Sattar November 10, 2008 Lecture 10.
Computer Science and Software Engineering University of Wisconsin - Platteville 7. Inheritance and Polymorphism Yan Shi CS/SE 2630 Lecture Notes.
Classes Mark Hennessy Dept. Computer Science NUI Maynooth C++ Workshop 18 th – 22 nd Spetember 2006.
Chapter 4 Inheritance Bernard Chen Spring Objective IS-A relationships and the allowable changes for derived classes The concept of polymorphism.
Chapter 12: Adding Functionality to Your Classes.
C++ Object Oriented 1. Class and Object The main purpose of C++ programming is to add object orientation to the C programming language and classes are.
Learners Support Publications Pointers, Virtual Functions and Polymorphism.
1 Classes- Inheritance Multiple Inheritance It is possible to derive a new class from more than one base class. This is called Multiple Inheritance. Under.
Chapter 15 – Inheritance, Virtual Functions, and Polymorphism
Programming in Java Unit 2. Class and variable declaration A class is best thought of as a template from which objects are created. You can create many.
CS212: Object Oriented Analysis and Design Lecture 6: Friends, Constructor and destructors.
 2006 Pearson Education, Inc. All rights reserved Classes: A Deeper Look, Part 2.
Chapter 3 Inheritance and Polymorphism Goals: 1.Superclasses and subclasses 2.Inheritance Hierarchy 3.Polymorphism 4.Type Compatibility 5.Abstract Classes.
LECTURE LECTURE 15 Inheritance Text book p
Copyright 2006 Oxford Consulting, Ltd1 February Polymorphism Polymorphism Polymorphism is a major strength of an object centered paradigm Same.
Copyright © 2006 Pearson Addison-Wesley. All rights reserved Learning Objectives  Inheritance  Virtual Function.
CS-1030 Dr. Mark L. Hornick 1 Basic C++ State the difference between a function/class declaration and a function/class definition. Explain the purpose.
Introduction to Object-Oriented Programming Lesson 2.
Overview of C++ Polymorphism
Recap Introduction to Inheritance Inheritance in C++ IS-A Relationship Polymorphism in Inheritance Classes in Inheritance Visibility Rules Constructor.
Polymorphism and Virtual Functions One name many shapes behaviour Unit - 07.
Copyright © 2012 Pearson Education, Inc. Chapter 10 Advanced Topics.
CS 342: C++ Overloading Copyright © 2004 Dept. of Computer Science and Engineering, Washington University Overview of C++ Overloading Overloading occurs.
 Virtual Function Concepts: Abstract Classes & Pure Virtual Functions, Virtual Base classes, Friend functions, Static Functions, Assignment & copy initialization,
UMass Lowell Computer Science Java and Distributed Computing Prof. Karen Daniels Fall, 2000 Lecture 10 Java Fundamentals Objects/ClassesMethods.
Object-Oriented Programming Review 1. Object-Oriented Programming Object-Oriented Programming languages vary but generally all support the following features:
Abstract classes only used as base class from which other classes can be inherit cannot be used to instantiate any objects are incomplete Classes that.
Chapter 2 Objects and Classes
Eine By: Avinash Reddy 09/29/2016.
Inheritance Modern object-oriented (OO) programming languages provide 3 capabilities: encapsulation inheritance polymorphism which can improve the design,
Modern Programming Tools And Techniques-I
Templates.
Friends of Template Classes
Andy Wang Object Oriented Programming in C++ COP 3330
CSC241: Object Oriented Programming
Inheritance and Polymorphism
References as Function Arguments
Inheritance and Run time Polymorphism
Inheritance & Polymorphism
Review: Two Programming Paradigms
CS410 – Software Engineering Lecture #11: C++ Basics IV
Polymorphism & Virtual Functions
Templates.
Inheritance Often, software encapsulates multiple concepts for which some attributes/behaviors overlap E.g. A computer (role-playing) game has: Monsters:
Chapter 12: Pointers, Classes, Virtual Functions, and Abstract Classes
Chapter 9 Inheritance and Polymorphism
Learning Objectives Inheritance Virtual Function.
CS212: Object Oriented Analysis and Design
Lecture 22 Inheritance Richard Gesick.
Week 6 Object-Oriented Programming (2): Polymorphism
Inheritance and Polymorphism
Overview of C++ Overloading
Dr. Bhargavi Dept of CS CHRIST
Polymorphism Polymorphism
9: POLYMORPHISM Programming Technique II (SCSJ1023) Jumail Bin Taliba
Pointers Dr. Bhargavi Goswami Department of Computer Science
Inheritance: Polymorphism and Virtual Functions
Fundaments of Game Design
Overview of C++ Polymorphism
CIS 199 Final Review.
CS410 – Software Engineering Lecture #5: C++ Basics III
Inheritance: Polymorphism and Virtual Functions
Final and Abstract Classes
四時讀書樂 (春) ~ 翁森 山光照檻水繞廊,舞雩歸詠春風香。 好鳥枝頭亦朋友,落花水面皆文章。 蹉跎莫遣韶光老,人生唯有讀書好。
C++ Object Oriented 1.
Static Binding Static binding chooses the function in the class of the base class pointer, ignoring any versions in the class of the object actually.
Computer Science II for Majors
Presentation transcript:

CS410 – Software Engineering Lecture #8: Advanced C++ III Function Templates In a similar way, we can use function templates. Here is a function template for copying arrays of different types: template <class TYPE> void copy(TYPE a[], TYPE b[], int n) { for (int i = 0; i < n; i++) a[i] = b[i]; } March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

CS410 – Software Engineering Lecture #8: Advanced C++ III Function Templates Which of the following calls fail to compile? double f1[50], f2[50]; char c1[25], c2[50]; int i1[75], i2[75]; char *ptr1, *ptr2; copy(f1, f2, 50); copy(c1, c2, 10); copy(i1, i2, 40); copy (ptr1, ptr2, 100); copy(i1, f2, 50); copy(ptr1, f2, 50); The last two invocations of copy() fail to compile because their types cannot be matched to the template type. March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

Static Members of Template Classes Static members of template classes are not universal but are specific to each instantiation: template <class T> class Thing { public: static int count; … }; Thing<int> a; Thing<double> b; The static variables Thing<int>::count and Thing<double>::count are distinct. March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

Friends of Template Classes Template classes can contain friends. A friend function that does not use a template specification is universally a friend of all instantiations of the template class. A friend function that incorporates template arguments is specifically a friend of its instantiated class. March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

Friends of Template Classes Example: template <class T> class Matrix { public: friend void Foo(); // universal friend vect<T> Product(vect<T> v); // instantiated … }; March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

CS410 – Software Engineering Lecture #8: Advanced C++ III Template Arguments You can also use constant expressions, function names, and character strings as template arguments. Example: template <class T, int n> class AssignArray { public: T a[n]; }; AssignArray<double, 50> x, y; x = y; March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

Default Template Arguments In the standard library, the class complex is now a template class. Usually, we would instantiate it to double: complex<double> x, y, z[10]; A template provider could decide that this is such a common case that it should be provided as a default. To achieve this, we can use default template arguments. March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

Default Template Arguments Example: template<class T = double> class complex { … private: T real, imaginary; }; complex<> c; // same as complex <double> c; March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

CS410 – Software Engineering Lecture #8: Advanced C++ III Inheritance A class can be derived from an existing class by using the following form: class class-name:(public|protected|private) base-name { member declarations }; The keywords public, protected, and private are used to specify how the base-class members can be accessed by the derived class. Public derivation is far more important than private or protected derivation; it should be considered the normal form of inheritance. March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

CS410 – Software Engineering Lecture #8: Advanced C++ III Inheritance Example: class Student { public: enum year {fresh, soph, junior, senior, grad}; Student(string nm, int id, double g, year y); void Print() const; protected: string name; int student_id; double gpa; year yr; }; March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

CS410 – Software Engineering Lecture #8: Advanced C++ III Inheritance class GradStudent : public Student { public: enum support {ta, ra, fellowship, other}; GradStudent(string nm, int id, double g, year y, support s, string d, string th); void Print() const; protected: support supp; string dept; string thesis; }; March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

CS410 – Software Engineering Lecture #8: Advanced C++ III Inheritance In the preceding example, GradStudent is the derived class, and Student is the base class. Using the keyword public following the colon in the derived-class header has several effects: The protected and public members of Student are inherited as protected and public members, resp., of GradStudent. Private members are inaccessible. GradStudent is a subtype of Student. A GraduateStudent is a Student, but a Student does not have to be a GraduateStudent (is-a relationship, or interface inheritance). March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

CS410 – Software Engineering Lecture #8: Advanced C++ III Inheritance A derived class is a modification of the base class, inheriting the public and protected members of the base class. Notice: Only constructors, destructors, and the member function operator=() cannot be inherited. Frequently, a derived class adds new members to the existing class members. It is also possible to override existing class members. Notice: Overriding is different from overloading, in which the same function name can have different meanings for each unique signature. March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

CS410 – Software Engineering Lecture #8: Advanced C++ III Inheritance Benefits of using a derived class: Code is reused: GradStudent uses existing, tested code from Student. The hierarchy reflects a relationship found in the problem domain. In the real world, graduate students make up a subgroup of all students. Various polymorphic mechanisms will allow client code to treat GradStudent as a subtype of Student, which simplifies the code but keeps distinctions among subtypes. March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

Typing Conversions and Visibility A variable of a publicly derived class can in many ways be treated as if it were the base-class type. For example, a pointer whose type is pointer to base class can point to objects that have the derived-class type. To examine the properties of base classes and derived classes, let us first take a closer look at our examples Student and GradStudent. March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

Typing Conversions and Visibility Implementation of constructors: Student::Student(string nm, int id, double g, year y) : name(nm), student_id(id), gpa(g), yr(y) {} GradStudent::GradStudent(string nm, int id, double g, year y, support s, string d, string th) : Student(nm, id, g, y), supp(s), dept(d), thesis(th) Notice: The constructor of Student is invoked as part of the initializer list in the constructor of GradStudent. March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

Typing Conversions and Visibility Because GradStudent is a subtype of Student, a reference to the derived class GradStudent may be implicitly converted to a reference to the public base class Student. Example: GradStudent gst(“John Miller”, 31416, 3.99, grad, ra, “Computer Science”, “Eye Movements in the Dark”); Student &st = gst; March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

CS410 – Software Engineering Lecture #8: Advanced C++ III Inheritance class GradStudent : public Student { … }; Using the keyword public following the colon in the derived-class header has several effects: The protected and public members of Student are inherited as protected and public members, resp., of GradStudent. Private members are inaccessible. GradStudent is a subtype of Student. A GraduateStudent is a Student, but a Student does not have to be a GraduateStudent (is-a relationship, or interface inheritance). March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

CS410 – Software Engineering Lecture #8: Advanced C++ III Inheritance class GradStudent : private Student { … }; Using the keyword private following the colon in the derived-class header has several effects: The protected and public members of Student are inherited as private members of GradStudent. However, GradStudent can re-declare protected members of Student as protected… …and public members of Student as either public or protected. Private members of Student are inaccessible by GradStudent. GradStudent is not a subtype of Student. March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

CS410 – Software Engineering Lecture #8: Advanced C++ III Inheritance class GradStudent : protected Student { … }; Using the keyword protected following the colon in the derived-class header has several effects: The public and protected members of Student are inherited as protected members of GradStudent. However, GradStudent can re-declare public members of Student as public. Private members of Student are inaccessible by GradStudent. GradStudent is not a subtype of Student. March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

Typing Conversions and Visibility Example for pointer conversions: int main() { Student s(“Joe Smith”, 111, 2.57, student::fresh); Student *ps = &s; GradStudent gs(“John Miller”, 31416, 3.99, student::grad, ra, “Computer Science”, “Eye Movements in the Dark”); GradStudent *pgs; ps->Print(); ps = pgs = &gs; pgs->Print(); } // Student::Print() // GradStudent::Print() // Student::Print() March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

CS410 – Software Engineering Lecture #8: Advanced C++ III Virtual Functions Overloaded member functions are invoked by a type-matching algorithm. These types are known at compile time and allow the compiler to select the appropriate member directly. As you will see, it would be nice to dynamically select at runtime the appropriate member function from among base- and derived-class functions. Such a mechanism is provided by the keyword virtual; it may be used only to modify member function declarations. Virtual functions combined with public inheritance are a form of pure polymorphism. March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

CS410 – Software Engineering Lecture #8: Advanced C++ III Virtual Functions When a virtual function is invoked, its semantics are the same as those of other functions. In a derived class, a virtual function can be overridden by a another function with a matching signature. The selection of which function definition to invoke for a virtual function is dynamic. A pointer to base class can point at either a base-class object or a derived-class object. The member function selected will depend on the class of the object being pointed at, not on the pointer type. March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

CS410 – Software Engineering Lecture #8: Advanced C++ III Virtual Functions Note the difference in selection of the appropriate overridden virtual function from an overloaded member function: An overloaded member function is selected at compile time, based on its argument types, and it can have distinct return types. A virtual function is selected at runtime, based on the object’s type, which is passed to it as its this pointer argument. Once a function is declared virtual, this property is automatically carried along to all redefinitions in derived classes. March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

CS410 – Software Engineering Lecture #8: Advanced C++ III Virtual Functions Example: Virtual function selection class B { public: int i; virtual void Print() const { cout << i << “ inside B” << endl; } }; class D : public B void Print() const { cout << i << “ inside D “ << endl; } int main() { B b; B *pb = &b; D d; d.i = 1 + (b.i = 1); pb->Print(); pb = &d; } Output: 1 inside B 2 inside D March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

CS410 – Software Engineering Lecture #8: Advanced C++ III Virtual Functions In the Student/GradStudent example, the selection of Print() is based on the pointer type, known at compile time. In the current (B/D) example, selection is based on what is being pointed at. Here, the pointer’s base type is not determining the function selection. Instead, different class objects are processed by different functions, determined at runtime. March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

CS410 – Software Engineering Lecture #8: Advanced C++ III Virtual Functions Example: class Shape { public: virtual double Area() const { return 0; } protected: double x, y; }; class Rectangle : public Shape double Area() const { return (height*width); } private: double height, width; class Circle : public Shape { public: double Area() const { return (PI*radius*radius); } private: double radius; }; int main() … Shape *s[N]; for (int i = 0; i < N; i++) totArea += s[i]->Area(); } March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

CS410 – Software Engineering Lecture #8: Advanced C++ III Virtual Functions Notice: The declaration of an identifier in a scope hides all declarations of that identifier in outer scopes. A base class is an outer scope of any class derived from it. This rule is independent of whether the names are declared virtual or not. If the selected function is inaccessible, we get a compile-time error. March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III

CS410 – Software Engineering Lecture #8: Advanced C++ III Virtual Functions We can define abstract base classes that include pure virtual functions (also called deferred methods). These are declared as follows: virtual function prototype = 0; An abstract base class specifies the basic common properties of its derived classes but cannot itself be used to declare objects. It is used to declare pointers that can access subtype pointers derived from the abstract class. March 26, 2019 CS410 – Software Engineering Lecture #8: Advanced C++ III