Copyright 2006 Pearson Addison-Wesley, 2008-2013 Joey Paquet 2-1 Concordia University Department of Computer Science and Software Engineering COMP345 Advanced

Copyright 2006 Pearson Addison-Wesley, 2008-2013 Joey Paquet 2-1

Concordia University

Department of Computer Science and Software Engineering

COMP345

Advanced program design with C++

Lecture 2: Classes


Learning Objectives

Structures

Classes Inheritance

Encapsulation

Information hiding

Friends

Inline functions

Static members


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


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 typesdouble balance; double interestRate;int term;

};


Declare Structure Variable

With structure type defined, now declarevariables 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"


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


Structure Example: Display 6.1 A Structure Definition (1 of 3)






Structure Pitfall

Semicolon after structure definition ; MUST exist:

struct WeatherData{

double temperature;double windVelocity;

}; // REQUIRED semicolon!

Required since you "can" declare structurevariables in this location

e.g. this declares a variable upon struct declaration:

struct WeatherData{…} myData;


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


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


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


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


Class Definitions

Defined similar to structures Example:

class DayOfYear //name of new class type{ public: //information hiding

void output(); //member functionint month;int day;

};

Notice only member function’s prototype Function declaration Function’s implementation is elsewhere, unless inline


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()


Class Member Access

Members accessed same as structures

today.monthtoday.day

To access member function:

today.output();


Class Member Functions

Must define or "implement" class memberfunctions

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


Class Member Functions Definition

Notice output() member function’sdefinition (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


Complete Class Example: Display 6.3 Class With a Member Function (1 of 4)








Dot and Scope Resolution Operator

Used to specify "of what thing" they aremembers

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”.


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


Encapsulation

Any data type includes Data (range of data) Operations (that can be performed on data)

Example:int data type has:Data range : +-32,767Operations: +,-,*,/,%,logical,etc.

Same with classes But WE specify data, and the operations to

be allowed on our data, using methods and operators


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)


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.


Public and Private Members

Data in class almost always designatedprivate 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"


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


Public and Private Example 2

Given the previous exampleDeclare object:DayOfYear today;

Object today can ONLY accesspublic members

cin >> today.month;// NOT ALLOWED!cout << today.day; // NOT ALLOWED!

Must instead call public operations:today.input();today.output();


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


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


Separate Interface and Implementation

User of class need not see details of howclass 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)


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


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


Summary 1

Structure is collection of data elements of different types

Class is used to combine data and functionsinto 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.


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)


Inheritance


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


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


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 functionsand variables, or override inherited functions


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


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 thesegeneral "things" about employees This is the concept of “base class”


Employee Class

Many members of Employee class applyto 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


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…"


Deriving from Employee Class

Derived classes from Employee class: Automatically have all member variables Automatically have all member functions

Derived class said to "inherit" membersfrom base class

Can then redefine existing membersand/or add new members


Display 14.3 Interface for the Derived Class HourlyEmployee (1 of 2)


Display 14.3 Interface for the Derived Class HourlyEmployee (2 of 2)


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 Employeeclass


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


HourlyEmployee Class Redefinitions

HourlyEmployee redefines: printCheck() member function This "overrides" the printCheck() function

implementation from Employee class

Its definition must be in HourlyEmployeeclass’s implementation As do other member functions declared inHourlyEmployee’s interface

New and "to be redefined"


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


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 allbase 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


Derived Class Constructor Example

Consider syntax for HourlyEmployeeconstructor 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


Another HourlyEmployee Constructor

A second constructor’s definition:

HourlyEmployee::HourlyEmployee(): Employee(), wageRate(0), hours(0)

{//Deliberately empty

}

Default version of base class constructoris called (no arguments)

Should always invoke one of the baseclass’s constructors


Constructor: No Base Class Call

Derived class constructor should alwaysinvoke 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)

{ }


Pitfall: Base Class Private Data

Derived class "inherits" private membervariables But still cannot directly access them Not even through derived class member

functions!

Private member variables can ONLY beaccessed "by name" in member functions of the class they’re defined in.


Pitfall: Base Class Private Member Functions Same holds for base class

member functions

Cannot be accessed outside interface andimplementation of base class

Not even in derived class member function definitions


Pitfall: Base Class Private Member Functions Impact Larger impact here vs. member variables

Member variables can be accessed indirectlyvia 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


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


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


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


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 &


Accessing Redefined Base Function

When redefined in derived class, baseclass’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


Functions that are not Inherited

All "normal" functions in base class areinherited 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)


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 constructorinvokes base class constructor

Absolutely necessary for classes with pointer data members


Assignment Operator Example

Given "Derived" is derived from "Base":

Derived& Derived::operator =(const Derived & rightSide){

//Copying the members of the Base classBase::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


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


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 beconcerned with derived class variables And any data they "point" to Base class destructor handles inherited data

automatically


Destructor Calling Order

Consider:class B derives from class Aclass C derives from class B

A B C

When object of class C goes out of scope: Class C destructor called 1st

Then class B destructor called Finally class A destructor is called

Opposite of how constructors are called


"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 classas it’s member data Considered a "Has a" class relationship e.g., One class "has a" object of another

class as it’s data


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


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 <iostream>

using namespace std;

class CRectangle {

private:

int width, height;

public:

void set_values (int, int);

int area () {return (width * height);}

friend CRectangle duplicate (CRectangle);

};


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; }


Friends example (class)#include <iostream>


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; };


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; }


Friends example (member function)#include <iostream>


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); };


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; }



Multiple Inheritance

Derived class can have more than onebase 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 {…};


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


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.


Virtual members (example)#include <iostream>


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); } };


Virtual members (example)

int main () {

CRectangle rect;

CTriangle trgl;

CPolygon poly;

CPolygon * ppoly1 = &rect;

CPolygon * ppoly2 = &trgl;

CPolygon * ppoly3 = &poly;

ppoly1->set_values (4,5);



cout << ppoly1->area() << endl; //20



return 0; }


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.


Pure virtual functions (example)

#include <iostream>

#include <string>

#include <vector>


class Animal {

public:

Animal(const string & name) : name(name) { }

virtual const string talk() = 0;

const string name; };



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!"; } };



int main() {

Animal * animals [] = { new Cat("Missy"),

new Cat("Mr.Bojangles"),

new Dog("Lassie") };

for(int i = 0; i < 3; i++)

cout << animals[i]->name << ": "

<< animals[i]->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!


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)


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 {...};


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.


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 {};


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.



Summary 1

Inheritance provides code reuse Allows one class to "derive" from another,

adding features

Derived class objects inherit members ofbase class And may add members

Private member variables in base classcannot be accessed "by name" in derived

Private member functions are not inherited


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


constructors

const qualifier

inline functions

static qualifier


Learning Objectives

Constructors Definitions Calling

More Tools const parameter modifier Inline functions Static member data


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


Constructor Definitions

Constructors defined like any member function

Except:

1. Must have same name as class

2. Cannot return a value; not even void!


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;}


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!


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 5date1.day 4 date2.day 5


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!


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


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


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


Overloaded Constructors

Can overload constructors just like other functions

Recall: a signature consists of: Name of function Parameter list

Provide constructors for all possibleargument-lists Particularly "how many"


Class with Constructors Example: Display 7.1 Class with Constructors (1 of 3)






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?


Explicit Constructor Calls

Can also call constructor AGAIN After object declared

Recall: constructor was automatically called then

Can call via object’s name; standard memberfunction call

Convenient method of setting member variables

Method quite different from standard member function call


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


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


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


Class Member Variable Example: Display 7.3 A Class Member Variable (1 of 5)










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


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


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


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!


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”


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)


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!


Static Members Example: Display 7.6 Static Members (1 of 4)








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


Nested classes

class Outerclas{ public: … private: class InnerClass { … }; …};


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.


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.


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).



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


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

Documents

Copyright 2006 Pearson Addison-Wesley, 2008-2013 Joey Paquet 2-1 Concordia University Department of Computer Science and Software Engineering COMP345 Advanced