Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-1 Concordia University Department of Computer Science and Software Engineering COMP345 Advanced program design with C++ Lecture 2: Classes
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-2 Learning Objectives Structures Classes Inheritance Encapsulation Information hiding Friends Inline functions Static members
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-3 Structures aggregate data type: array and struct Recall: aggregate meaning "grouping" Array: collection of values of same type Structure: collection of values of different types Treated as a single entity, like arrays Major difference: Must first declare struct Prior to declaring any variables
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-4 Structure Types Declare struct globally (typically) No memory is allocated Just a "placeholder" for what our struct will "look like“, i.e. a type declaration Definition: struct CDAccountV1 //Name of new "type" { //list members and their types double balance; double interestRate; int term; };
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-5 Declare Structure Variable With structure type defined, now declare variables of this new type: CDAccountV1 account; Just like declaring simple types Variable account now of type CDAccountV1 It contains "member values" Each of the struct "parts"
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-6 Accessing Structure Members Dot Operator to access members account.balance account.interestRate account.term Called "member variables" The "parts" of the structure variable Different structs can have same name member variables Each struct defines its own scope for naming No conflicts
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-7 Structure Example: Display 6.1 A Structure Definition (1 of 3)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-8 Structure Example: Display 6.1 A Structure Definition (2 of 3)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-9 Structure Example: Display 6.1 A Structure Definition (3 of 3)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-10 Structure Pitfall Semicolon after structure definition ; MUST exist: struct WeatherData { double temperature; double windVelocity; }; // REQUIRED semicolon! Required since you "can" declare structure variables in this location e.g. this declares a variable upon struct declaration: struct WeatherData{…} myData;
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-11 Structure Assignments Given structure struct CropYield{ int quantity; int size;} Declare two structure variables: CropYield apples, oranges; Simple assignments are legal: apples = oranges; Simply copies each member variable from apples into member variables from oranges, equivalent to: apples.quantity = oranges.quantity; apples.size = oranges.size; Things are not so simple when pointers are involved
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-12 Structures as Function Arguments Passed like any simple data type Pass-by-value Pass-by-reference Can also be returned by function Return-type is of a type declared by struct Return statement in function definition sends structure variable back to caller
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-13 Initializing Structures Can initialize at declaration Example: struct Date { int month; int day; int year; }; Date dueDate = {12, 31, 2003}; Declaration provides initial data to all three member variables
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-14 Classes Similar to structures Adds member FUNCTIONS Not just member data Integral to object-oriented programming Focus on objects Object: Contains data and operations In C++, variables of class type are objects
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-15 Class Definitions Defined similar to structures Example: class DayOfYear //name of new class type { public: //information hiding void output(); //member function int month; int day; }; Notice only member function’s prototype Function declaration Function’s implementation is elsewhere, unless inline
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-16 Declaring Objects Declared same as all variables Predefined types, structure types Example: DayOfYear today, birthday; Declares two objects of class type DayOfYear Objects include: Data members month, day Operations (member functions, methods) output()
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-17 Class Member Access Members accessed same as structures today.month today.day To access member function: today.output();
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-18 Class Member Functions Must define or "implement" class member functions Like other function definitions Can be after main() definition Must specify class name in the function header: void DayOfYear::output() {…} :: is scope resolution operator Instructs compiler "what class" member is from Item before :: called type qualifier
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-19 Class Member Functions Definition Notice output() member function’s definition (in next example) Refers to member data of class No qualifiers, as function definition is defined “inside the class scope”, thus has direct access to anything in this scope Function used for all objects of the class Will refer to "that object’s" data when invoked Example: today.output(); Displays "today" object’s data
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-20 Complete Class Example: Display 6.3 Class With a Member Function (1 of 4)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-21 Complete Class Example: Display 6.3 Class With a Member Function (2 of 4)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-22 Complete Class Example: Display 6.3 Class With a Member Function (3 of 4)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-23 Complete Class Example: Display 6.3 Class With a Member Function (4 of 4)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-24 Dot and Scope Resolution Operator Used to specify "of what thing" they are members Dot operator: Specifies member of particular object Scope resolution operator: Specifies what class the function definition comes from If scope resolution operator not used, this would be defining a “free function”.
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-25 A Class’s Place Class is full-fledged type Just like data types int, double, etc. Can have variables of a class type We simply call them "objects“, or “instances” Can have parameters of a class type Pass-by-value Pass-by-reference Can use class type like any other type
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-26 Encapsulation Any data type includes Data (range of data) Operations (that can be performed on data) Example: int data type has: Data range : +-32,767 Operations: +,-,*,/,%,logical,etc. Same with classes But WE specify data, and the operations to be allowed on our data, using methods and operators
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-27 Encapsulation Encapsulation Means "bringing together as one“ Declare a class get an object Object is "encapsulation" of Data values Operations on the data (member functions)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-28 Principles of OOP Information Hiding Some details of how an entity is internally representing or acting are hidden to the client class Abstraction Details of how data is manipulated within ADT/class not known to client class. Only what is necessary to know is available externally. Encapsulation Bring together data and operations in a same entity, possibly hiding some.
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-29 Public and Private Members Data in class almost always designated private in definition Upholds principles of OOP Hide data from user Allow manipulation only via operations Which are member functions public items (usually member functions) are "user-accessible"
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-30 Public and Private Example Modify previous example: class DayOfYear { public: void input(); void output(); private: int month; int day; };| Data now private Other objects have no direct access
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-31 Public and Private Example 2 Given the previous example Declare object: DayOfYear today; Object today can ONLY access public members cin >> today.month;// NOT ALLOWED! cout << today.day; // NOT ALLOWED! Must instead call public operations: today.input(); today.output();
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-32 Public and Private Style Can mix public & private More typically place public first Allows easy viewing of portions that can be USED by programmers using the class Private data is "hidden", so irrelevant to users Outside of class definition, cannot change (or even access) private data
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-33 Accessor and Mutator Functions Object needs to "do something" with its data accessor member functions Allow object to read data Also called "get member functions" Simple retrieval of member data mutator member functions Allow object to change data Manipulated based on application
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-34 Separate Interface and Implementation User of class need not see details of how class is implemented Principle of OOP : information hiding, abstraction User only needs declaration Called "interface" for the class Put in header files (.h ) Implementation of class (definition) hidden Member function definitions elsewhere User need not see them Put in implementation files (.cpp )
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-35 Structures versus Classes Structures Typically all members public No member functions Classes Typically all data members private Interface member functions public Technically, same Perceptionally, very different mechanisms
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-36 Thinking Objects Focus for programming changes Before : algorithms center stage OOP : concept (data and operation) is focus Algorithms still exist They simply focus on their data Are "made" to "fit" the data Are encapsulated into the data types they manipulate Designing software solution Define variety of objects and how they interact and use one another’s data and methods
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-37 Summary 1 Structure is collection of data elements of different types Class is used to combine data and functions into single unit: notion of class/object Member variables and member functions Can be public : accessed outside class Can be private : accessed only in a member function’s definition Class and structure types can be parameters to functions, basic type to arrays, etc.
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-38 Summary 2 C++ class definition Should separate two key parts Interface what user needs to know Implemented in header file (.h ) Implementation Details of how the class works Definitions of methods (member functions) Implemented in the implementation file (.cpp )
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-39 Inheritance
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-40 Learning Objectives Inheritance Basics Derived classes, with constructors protected : qualifier Redefining member functions Non-inherited functions Programming with Inheritance Assignment operators and copy constructors Destructors in derived classes Multiple inheritance
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-41 Introduction to Inheritance Object-oriented programming Powerful programming technique Generally provides abstraction mechanism called inheritance General form of class is defined Specialized versions then inherit properties of general class And add to it/modify it’s functionality for it’s appropriate use
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-42 Inheritance Basics A class inherits members from another class Base class "General" class from which others derive Derived class Automatically has base class’s: Member variables Member functions By transition, also inherits from all ancestor classes Can then add additional member functions and variables, or override inherited functions
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-43 Derived Classes Consider example: Class of Employees Composed of: Salaried employees Hourly employees Each is a "subset" of employees “is a”, or “kind of” relationship Another might be those paid fixed wage each month or week Each potentially has a different way to calculate the pay, and require different data, thus require different classes
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-44 Derived Classes Don’t "need" type of generic "employee" Since no one’s just an "employee“ There is no generic way to calculate pay General concept of employee is helpful All have names All have social security numbers Associated functions for these "basics" are same among all employees So "general" class can contain all these general "things" about employees This is the concept of “base class”
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-45 Employee Class Many members of Employee class apply to all types of employees Accessor functions Mutator functions Most data items: SSN Name Pay We won’t have "objects“, i.e. “instances”, of this class, however
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-46 Employee Class Consider the printCheck() function: Will always be "redefined" in derived classes to match the different ways to calculate the pay for different kinds of employees Makes no sense really for "undifferentiated" employee, as Employee does not store enough information to calculate a pay So function printCheck() in Employee class outputs: "printCheck called for generic Employee!! Aborting…"
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-47 Deriving from Employee Class Derived classes from Employee class: Automatically have all member variables Automatically have all member functions Derived class said to "inherit" members from base class Can then redefine existing members and/or add new members
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-48 Display 14.3 Interface for the Derived Class HourlyEmployee (1 of 2)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-49 Display 14.3 Interface for the Derived Class HourlyEmployee (2 of 2)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-50 HourlyEmployee Class Interface Note definition begins same as any other #ifndef directive Includes required libraries and namespaces Also includes employee.h, supposing that it Employee is defined in another file. And, the heading: class HourlyEmployee : public Employee { … Specifies "publicly inheriting" from Employee class
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-51 HourlyEmployee Class Additions Derived class interface only lists new or "to be redefined" members Since all others inherited are already defined i.e.: "all" employees have ssn, name, etc. HourlyEmployee adds: Constructors wageRate, hours member variables setRate(), getRate(), setHours(), getHours() member functions
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-52 HourlyEmployee Class Redefinitions HourlyEmployee redefines: printCheck() member function This "overrides" the printCheck() function implementation from Employee class Its definition must be in HourlyEmployee class’s implementation As do other member functions declared in HourlyEmployee ’s interface New and "to be redefined"
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-53 Inheritance Terminology Common to simulate family relationships Parent class Refers to base class Child class Refers to derived class Ancestor class Class that’s a parent of a parent … Descendant class Opposite of ancestor
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-54 Constructors in Derived Classes Base class constructors are NOT inherited in derived classes But they can be invoked within a derived class’ constructor Which is all we need! Base class constructor must initialize all base class member variables Those inherited by derived class So derived class constructor simply calls it This way, this part is always initialized in the same manner
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-55 Derived Class Constructor Example Consider syntax for HourlyEmployee constructor definition: HourlyEmployee::HourlyEmployee(string theName, string theNumber, double theWageRate, double theHours) : Employee(theName, theNumber), wageRate(theWageRate), hours(theHours) { //Deliberately empty } Portion after : is "initialization section" Includes invocation of Employee constructor
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-56 Another HourlyEmployee Constructor A second constructor’s definition: HourlyEmployee::HourlyEmployee() : Employee(), wageRate(0), hours(0) { //Deliberately empty } Default version of base class constructor is called (no arguments) Should always invoke one of the base class’s constructors
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-57 Constructor: No Base Class Call Derived class constructor should always invoke one of the base class’s constructors If you do not: Default base class constructor automatically called Equivalent constructor definition: HourlyEmployee::HourlyEmployee() : wageRate(0), hours(0) { }
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-58 Pitfall: Base Class Private Data Derived class "inherits" private member variables But still cannot directly access them Not even through derived class member functions! Private member variables can ONLY be accessed "by name" in member functions of the class they’re defined in.
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-59 Pitfall: Base Class Private Member Functions Same holds for base class member functions Cannot be accessed outside interface and implementation of base class Not even in derived class member function definitions
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-60 Pitfall: Base Class Private Member Functions Impact Larger impact here vs. member variables Member variables can be accessed indirectly via accessor or mutator member functions Member functions simply not available This is "reasonable" Private member functions should be simply "helper" functions Should be used only in class they’re defined
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-61 The protected Qualifier visibility classification of class members As private and public Allows access "by name" in derived class But nowhere else Still no access "by name" in other (non-derived) classes In class it’s defined acts like private Considered protected in derived class To allow future derivations Many feel this "violates" information hiding
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-62 Redefinition of Member Functions Recall interface of derived class: Contains declarations for new member functions Also contains declarations for inherited member functions to be changed, i.e. redefined Inherited member functions NOT declared: Automatically inherited unchanged Implementation of derived class will: Define new member functions Redefine inherited functions as declared
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-63 Redefining vs. Overloading Very different! Redefining in derived class: SAME parameter list Essentially "re-writes" the same function Overloading: Different parameter list (nothing else) Defined "new" function that takes different parameters Overloaded functions must have different signatures
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-64 A Function’s Signature Recall definition of a "signature": Function’s name Sequence of types in parameter list Including order, number, types Signature does NOT include: Return type const keyword &
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-65 Accessing Redefined Base Function When redefined in derived class, base class’s definition not "lost" Can specify its use: Employee JaneE; HourlyEmployee SallyH; // calls Employee’s printCheck() function JaneE.printCheck(); // calls HourlyEmployee printCheck() function SallyH.printCheck(); // calls Employee’s printCheck() function SallyH.Employee::printCheck(); Not typical, but useful sometimes
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-66 Functions that are not Inherited All "normal" functions in base class are inherited in derived class Exceptions: Constructors (though they are automatically called) Destructors (idem) Copy constructor But if not defined, generates "default" one Recall need to define one for pointers! Assignment operator If not defined : default one is generated (same with pointers)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-67 Assignment Operators and Copy Constructors Recall: overloaded assignment operators and copy constructors NOT inherited But can be used in derived class definitions Typically MUST be used across an inheritance hierarchy! Similar to how derived class constructor invokes base class constructor Absolutely necessary for classes with pointer data members
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-68 Assignment Operator Example Given "Derived" is derived from "Base": Derived& Derived::operator =(const Derived & rightSide) { //Copying the members of the Base class Base::operator =(rightSide); //coping the members of Derived } Notice code line Calls assignment operator from base class This takes care of all inherited member variables Would then set new variables from derived class
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-69 Copy Constructor Example Consider: Derived::Derived(const Derived& Object) : Base(Object), … {…} After : is invocation of base copy constructor Sets inherited member variables of derived class object being created Note Object is of type Derived; but it’s also of type Base, so argument is valid
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-70 Destructors in Derived Classes If base class destructor functions correctly Easy to write derived class destructor When derived class destructor is invoked: Automatically calls base class destructor! So no need for explicit call So derived class destructors need only be concerned with derived class variables And any data they "point" to Base class destructor handles inherited data automatically
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-71 Destructor Calling Order Consider: class B derives from class A class C derives from class B A B C When object of class C goes out of scope: Class C destructor called 1 st Then class B destructor called Finally class A destructor is called Opposite of how constructors are called
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-72 "Is a" vs. "Has a" Relationships Inheritance Considered an "Is a" class relationship e.g., An HourlyEmployee "is a" Employee A Convertible "is a" Automobile A class contains objects of another class as it’s member data Considered a "Has a" class relationship e.g., One class "has a" object of another class as it’s data
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-73 Protected and Private Inheritance New inheritance "forms“, vs public inheritance Protected inheritance: class SalariedEmployee : protected Employee {…} public members in base class become protected in derived class Private inheritance: class SalariedEmployee : private Employee {…} All members in base class become private in derived class
Friends Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-74 In principle, private and protected members of a class cannot be accessed from outside the class in which they are declared A friend (function or class) of a class may access the members designated as private or protected. Friends are functions or classes declared as such within a class Widely criticized for being a "rogue feature" Makes the language more complex Contradicts the information hiding principle
Friends example (free function) // friend free function #include using namespace std; class CRectangle { private: int width, height; public: void set_values (int, int); int area () {return (width * height);} friend CRectangle duplicate (CRectangle); }; Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-75
Friends example (free function) void CRectangle::set_values (int a, int b) { width = a; height = b; } CRectangle duplicate (CRectangle rectparam) { CRectangle rectres; rectres.width = rectparam.width*2; rectres.height = rectparam.height*2; return (rectres); } int main () { CRectangle rect, rectb; rect.set_values (2,3); rectb = duplicate (rect); cout << rectb.area(); return 0; } Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-76
Friends example (class) #include using namespace std; class CSquare; //Forward declaration class CRectangle { private: int width, height; public: int area () {return (width * height);} void convert (CSquare a); }; class CSquare { private: int side; public: void set_side (int a) {side=a;} friend class CRectangle; }; Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-77
Friends example (class) void CRectangle::convert (CSquare a) { width = a.side; height = a.side; } int main () { CSquare sqr; CRectangle rect; sqr.set_side(4); rect.convert(sqr); cout << rect.area(); return 0; } Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-78
Friends example (member function) #include using namespace std; class B; // Forward declaration class A { private: int a; public: A() { a=0; } void show(A& x, B& y); }; class B { private: int b; public: B() { b=6; } friend void A::show(A& x, B& y); }; Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-79
Friends example (member function) void A::show(A& x, B& y) { cout << "A::a=" << x.a << endl; cout << "B::b=" << y.b << endl; } int main() { A a; B b; a.show(a,b); return 0; } Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-80
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-81 Multiple Inheritance Derived class can have more than one base class! Syntax just includes all base classes separated by commas: class derivedMulti : public base1, base2 {…} Possibilities for ambiguity are endless! Dangerous undertaking! Some believe should never be used Similar/different vs. Java’s interfaces
Multiple inheritance (2 examples) class Animal {...}; class Mammal : public Animal {...}; class WingedAnimal : public Animal {...}; class Bat : public Mammal, WingedAnimal {...}; class Worker : public Person {…}; class Musician : public Person, Worker {…}; class StudentMusician : public Person, Musician, Worker {…}; Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-82
Multiple inheritance Ambiguities arise when conflicting members are inherited from different classes. Diamond problem: two inherited classes inherit from a common class. Solved using virtual inheritance Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-83
Virtual Members Some member function of a class are meant to be redefined in its derived classes : virtual member function, or virtual function. precede its declaration with the keyword virtual Upon a polymorphic call, the most specific version is called. Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-84
Virtual members (example) #include using namespace std; class CPolygon { protected: int width, height; public: void set_values (int a, int b) { width=a; height=b; } virtual int area () { return (0); } }; class CRectangle: public CPolygon { public: int area () { return (width * height); } }; class CTriangle: public CPolygon { public: int area () { return (width * height / 2); } }; Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-85
Virtual members (example) int main () { CRectangle rect; CTriangle trgl; CPolygon poly; CPolygon * ppoly1 = ▭ CPolygon * ppoly2 = &trgl; CPolygon * ppoly3 = &poly; ppoly1->set_values (4,5); ppoly2->set_values (4,5); ppoly3->set_values (4,5); cout area() << endl; //20 cout area() << endl; //10 cout area() << endl; //0 return 0; } Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-86
Pure virtual functions A member function can also be made pure virtual by appending it with = 0 after the closing bracket and before the semicolon. Objects can not be created of a class with a pure virtual function and are called abstract classes. Such abstract data types can only be derived from. Any derived class inherits the virtual function as pure and must override it (and all other pure virtual functions) with a non-pure virtual function for objects to be created from the derived class, or else it is also itself an abstract class. An attempt to create an object from a class with a pure virtual function or inherited pure virtual function will be flagged as a compile-time error. Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-87
Pure virtual functions (example) #include using namespace std; class Animal { public: Animal(const string & name) : name(name) { } virtual const string talk() = 0; const string name; }; Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-88
Pure virtual functions (example) class Cat : public Animal { public: Cat(const string & name) : Animal(name) { } virtual ~Cat() { } virtual const string talk() { return "Meow!"; } }; class Dog : public Animal { public: Dog(const string & name) : Animal(name) { } virtual ~Dog() { } virtual const string talk() { return "Arf! Arf!"; } }; Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-89
Pure virtual functions (example) int main() { Animal * animals [] = { new Cat("Missy"), new Cat("Mr.Bojangles"), new Dog("Lassie") }; for(int i = 0; i < 3; i++) cout name << ": " talk() << endl; for(int i = 0; i < 3; i++) delete animals[i]; return 0; } // prints the following: // Missy: Meow! // Mr. Bojangles: Meow! // Lassie: Arf! Arf! Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-90
Virtual Inheritance Base classes may be declared as virtual: virtual inheritance. Virtual inheritance ensures that only one instance of a base class exists in the inheritance graph Avoids some of the ambiguity problems of multiple inheritance (diamond problem, or diamond inheritance) Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-91
Virtual Inheritance (example) class Animal { public: virtual void eat(); }; class Mammal : public Animal { public: virtual void walk(); }; class WingedAnimal : public Animal { public: virtual void flap(); }; // A bat is a winged mammal class Bat : public Mammal, public WingedAnimal {...}; Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-92
Virtual Inheritance (example) int main(){ Bat bat; bat.eat(); //ambiguous: requires either of the following!! bat.WingedAnimal::eat(); bat.Mammal::eat(); return(0);} Internally, inheritance is simply a matter of putting parent and child class one after the other in memory. Thus a Bat object is stored as: ( Animal,Mammal,Animal,WingedAnimal,Bat ) which makes Animal duplicated. Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-93
Virtual Inheritance solution class Animal { public: virtual void eat(); }; class Mammal : public virtual Animal { public: virtual void walk(); }; class WingedAnimal : public virtual Animal { public: virtual void flap(); }; // A bat is still a winged mammal class Bat : public Mammal, public WingedAnimal {}; Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-94
Virtual Inheritance (example) int main(){ Bat bat; bat.eat(); //non-ambiguous!! bat.WingedAnimal::eat(); //same as above bat.Mammal::eat(); //same as above return(0);} Here, a Bat object is stored as: (*Animal,Mammal,*Animal,WingedAnimal,Bat) Both *Animal are vtable pointers to the same Animal memory block Thus, no ambiguity in this case. Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-95
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-96 Summary 1 Inheritance provides code reuse Allows one class to "derive" from another, adding features Derived class objects inherit members of base class And may add members Private member variables in base class cannot be accessed "by name" in derived Private member functions are not inherited
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-97 Summary 2 Can redefine inherited member functions To perform differently in derived class Protected members in base class: Can be accessed "by name" in derived class member functions Overloaded assignment operator not inherited But can be invoked from derived class Constructors are not inherited Are invoked from derived class’s constructor
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-98 constructors const qualifier inline functions static qualifier
Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-99 Learning Objectives Constructors Definitions Calling More Tools const parameter modifier Inline functions Static member data
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Constructors Initialization of objects Initialize some or all member variables Other actions possible as well A special kind of member function Automatically called when object declared Very useful tool Key principle of OOP
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Constructor Definitions Constructors defined like any member function Except: 1. Must have same name as class 2. Cannot return a value; not even void!
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Constructor Definition Example Class definition with constructor: class DayOfYear { public: //Constructor initializes month & day DayOfYear(int monthValue, int dayValue); void input(); void output(); … private: int month; int day; }
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Constructor Notes Notice name of constructor: DayOfYear Same name as class itself! Constructor declaration has no return-type Not even void! Constructor in public section It’s called when objects are declared If private, could never declare objects from the exterior!
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Calling Constructors Declare objects: DayOfYear date1(7,4), date2(5,5); Objects are created here Constructor is called Values in parentheses passed as arguments to constructor Member variables month, day initialized: date1.month 7 date2.month 5 date1.day 4 date2.day 5
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Constructor Equivalency Consider: DayOfYear date1, date2; date1.DayOfYear(7, 4);// ILLEGAL! date2.DayOfYear(5, 5);// ILLEGAL! Seemingly OK… CANNOT call constructors like other member functions!
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Constructor Code Constructor definition is like all other member functions: DayOfYear::DayOfYear(int newMonth, int newDay) { month = newMonth; day = newDay; } Note same name around :: Clearly identifies a constructor Note no return type Just as in class definition
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Alternative Definition Previous definition equivalent to: DayOfYear::DayOfYear(int monthValue, int dayValue) : month(monthValue), day(dayValue) {…} Third line called "Initialization Section" Body left empty Preferable definition version
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Constructor Additional Purpose Not just initialize data Body doesn’t have to be empty In initializer version Validate the data! Ensure only appropriate data is assigned to class private member variables Powerful OOP principle
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Overloaded Constructors Can overload constructors just like other functions Recall: a signature consists of: Name of function Parameter list Provide constructors for all possible argument-lists Particularly "how many"
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Class with Constructors Example: Display 7.1 Class with Constructors (1 of 3)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Class with Constructors Example: Display 7.1 Class with Constructors (2 of 3)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Class with Constructors Example: Display 7.1 Class with Constructors (3 of 3)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Constructor with No Arguments Can be confusing Standard functions with no arguments: Called with syntax: callMyFunction(); Including empty parentheses Object declarations with no "initializers": DayOfYear date1;// This way! DayOfYear date(); // NO! What is this really?
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Explicit Constructor Calls Can also call constructor AGAIN After object declared Recall: constructor was automatically called then Can call via object’s name; standard member function call Convenient method of setting member variables Method quite different from standard member function call
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Explicit Constructor Call Example Such a call returns "anonymous object“, which can then be assigned DayOfYear holiday(7, 4); Constructor called at object’s declaration Now to "re-initialize": holiday = DayOfYear(5, 5); Explicit constructor call Returns new "anonymous object" Assigned back to current object
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Default Constructor Defined as: constructor w/ no arguments One should always be defined Auto-Generated? Yes & No If no constructors AT ALL are defined Yes If any constructors are defined No If no default constructor: Cannot declare: MyClass myObject; With no initializers
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Class Type Member Variables Class member variables can be any type Including objects of other classes! Type of class relationship Powerful OOP principle Need special notation for constructors So they can call "back" to member object’s constructor
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Class Member Variable Example: Display 7.3 A Class Member Variable (1 of 5)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Class Member Variable Example: Display 7.3 A Class Member Variable (2 of 5)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Class Member Variable Example: Display 7.3 A Class Member Variable (3 of 5)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Class Member Variable Example: Display 7.3 A Class Member Variable (4 of 5)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Class Member Variable Example: Display 7.3 A Class Member Variable (5 of 5)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Parameter Passing Methods Efficiency of parameter passing Call-by-value Requires copy be made Overhead Call-by-reference Placeholder for actual argument Most efficient method Negligible difference for simple types For class types clear advantage Call-by-reference desirable Especially for "large" data, like class types
Copyright 2006 Pearson Addison-Wesley, Joey Paquet The const Parameter Modifier Large data types (typically classes) Desirable to use pass-by-reference Even if function will not make modifications Protect argument Use constant parameter Also called constant call-by-reference parameter Place keyword const before type Makes parameter "read-only" Attempts to modify result in compiler error
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Use of const All-or-nothing If no need for function modifications Protect parameter with const Protect ALL such parameters This includes class member function parameters Good practice, as it provides useful information
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Inline Functions For non-member functions (free functions): Use keyword inline in function declaration and function heading For class member functions: Place implementation (code) for function IN class definition automatically inline Use for very short functions only Code actually inserted in place of call Eliminates overhead More efficient, but only when short!
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Inline Member Functions Member function definitions Typically defined separately, in different file Can be defined IN class definition Makes function "in-line" Again: use for very short functions only More efficient If too long “code bloating”
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Static Members Static member variables All objects of class "share" one copy One object changes it all see change Useful for "tracking" How often a member function is called How many instances (objects) of a class exist at given time Place keyword static before type Must be initialized outside of class definition, even if private Can only be initialize once, hence not in the constructor Initialization is expected in the same file where the class declaration resides (not necessarily though)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Static Functions Member functions can be static If no access to object data needed And still "must" be member of the class Make it a static function Can then be called outside class From non-class objects: E.g., Server::getTurn(); As well as via class objects Standard method: myObject.getTurn(); Can only use static data and functions!
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Static Members Example: Display 7.6 Static Members (1 of 4)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Static Members Example: Display 7.6 Static Members (2 of 4)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Static Members Example: Display 7.6 Static Members (3 of 4)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Static Members Example: Display 7.6 Static Members (4 of 4)
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Nested classes A class can be declared inside another class, either as public or private If private, it can only be used inside of the outer class If public, it can be used outside of the outer class as OuterClass::InnerClass The inner class’ name is local to the outer class
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Nested classes class Outerclas { public: … private: class InnerClass { … }; … };
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Local classes A class definition can also be defined inside a function definition, called a “local class” Its name is local to the block where it is defined, e.g. the function definition block Cannot contain static members, as it would not make much sense
Polymorphism in C++ Polymorphism enables one common interface with different implementations Enables objects to act differently under different circumstances. Ability of objects belonging to different classes to respond to method calls of the same name, each one according to an appropriate type-specific behavior. In cases where type can be inferred at compile time, polymorphism is static. In cases where types cannot be inferred at compile time, polymorphism is dynamic, requiring run-time late binding or dynamic binding. Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-137
Static polymorphism Function overloading Defining functions with the same name that have different meanings depending on their parameters. Inheritance with function redefinition Right function to call is determined by the type of object involved in the call. Operator overloading Defining operators that can act upon different types Class and function templates Defining classes that embed elements of a variable type. Defining functions that act upon data of a variable type. Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-138
Dynamic polymorphism Virtual member functions, used from pointers to objects Right function to call is determined by the type of object being pointed to, calling the member function of the most specific class. As we may be using a pointer to an object of a superclass, this requires dynamic (run-time) analysis. Managed by a virtual method table (vtable). Copyright 2006 Pearson Addison-Wesley, Joey Paquet 2-139
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Summary 1 Constructors: automatic initialization of class data Called when objects are declared Constructor has same name as class Default constructor has no parameters Should always be defined Class member variables Can be objects of other classes Require initialization-section
Copyright 2006 Pearson Addison-Wesley, Joey Paquet Summary 2 Constant call-by-reference parameters More efficient than call-by-value Can inline very short function definitions Can improve efficiency Static member variables Shared by all objects of a class