1

Objects and Classes in C++

Lesson #4

Note: CIS 601 notes were originally developed by H. Zhu for NJIT DL Program. The notes were subsequently revised by M. Deek.

2

Content

Class/Object Definition Member Access Member Functions (inline, const) Object Copy C++ program= .h +.cpp

3

Classes and their instances Class ::=<Id, Ds, Ops, Intfc>; Object ::= <Oid, Cid, Body>. In C++:

class class_name{ Member_list };//Class

Member_List::=MemberVariables|MemberFunctions

class_name identifier;//Object

4

Class Definitionclass Point {

public:

int GetX(); // return the value of x

int GetY(); // return the value of y

void SetX(int valX) {x=valX;}; // set x

void SetY(int valY) {y=valY;}; //set y

private:

int x,y;//coordinates

}

5

Class Point (Member Functions)

int Point::GetX() { return x; }; int Point::GetY() { return y;

};

6

Class Members A class object contains a copy of

the data defined in the class. The functions are shared. The data are not.

5 10 x y

20 10 x y50 60 x y

Point(int, int) int getX() int getY()

P

Q

R

Point P(5,10);Point Q(20,10);Point R(50,60);

7

Point Objects

Point P, P2;

P.SetX(300);

cout << “x= ”<< P.GetX();

P2 = p;

//ex4point.cpp

8

9

Controlling Member Access

class class_name{ public: //public membersprotected: //protected members private: //private members };

10

Access RulesType of Member

Member of the Same Class

Friend Member of a Derived Class

Non-Member Function

Private

(Default)

X X

Protected X X X

Public X X X X

11

Access Rules

For public members: You can get to the member by using the

“.” operator. E.g.: p.GetX();

For the other two member types: No!

12

Point class class Point { public:

int GetX(); // return the value of xint GetY(); // return the value of y

void SetX(int valX) {x=valX;}; // set x void SetY(int valY) {y=valY;}; //set y

int y; private: int x; //coordinates}

13

Point class

main() { Point P; P.SetX(300); P.SetY(500); cout <<"P.x="<< P.GetX()<<"\n"; cout <<"P.y="<< P.y<<"\n"; }//ex4point2.cpp

14

15

16

In-line Functions

In-line: functions are defined within the body of the class definition.

Out-of-line: functions are declared within the body of the class definition and defined outside.

inline keyword: Used to defined an inline function outside the class definition.

17

class Point {

public:

…

void setX(int valX) {x=valX;}; // set x

void setY(int valY); //set y

void delta(int, int); //adjust the coordinators

private:

int x,y; //the coordinates

}

void Point::setY(int valY) {y=valY;}

inline void Point::delta(int dx, int dy)

{x +=dx; y+=dy;}

In-line

Out-of-line

Also In-line

Omitting the name is allowed

18

Constant Member Function Guarantees that the state of the current

class object is not modified.

class Point {

public:

…

int getX() const {return x;};

int getY(){return y;};

void setX(int valX) {x=valX;}; // set x

…

}

19

Constant Functions

const Point P1(10, 20);

Point P2(30, 50);

P1.getX();

P2.getX();//a const function can be //called by a non-const object

P1.SetX(100); //error! P1 is a const obj

P2.SetX(100); //ok

20

Constructors

Called to create an object. Default constructors: no parameters.class Point {

public:

Point() {};

// Point() {x=0; y=0;};

…

private:

int x,y; //coordinates

}

Default

Defined with initialization

21

Constructors

Alternate constructors: with parameters Point::Point(int vx, int vy) { setX(vx); setY(vy); cout<<“Point constructor called.\n”; }

22

Constructors

Overloading Constructors: with different parameters

Point(); Point(int, int) are overloaded constructors.

Example: ex4point3.cpp

23

24

25

Constructors

Copy constructors: default ones are created by the compiler automatically.

A local copy of the object is constructed.

Copy constructors can also be defined by the programmer.

26

Objects of a class

Point p; //default Point a(p), b = p; //copy Point c(20,30); //alternate Point figure[3]; //default Point figure[2] = {p,c}; //copy Example: ex4point4.cpp

27

28

29

Pointers to Class Objects

Student *p; p = new Student; if (!p) //could not create Student Point * figure = new Point[10]; //call Point() 10 times Delete [] figure;//7.3.3,p233

30

Destructors

Called when an object is to be deleted.

Defined with the name:~classname(); Example: Ex4point4.cpp

~Point(){cout <<“Destructor called.”;}

31

32

33

Constructors and Destructors with dynamic memory

//Vstring Class#include <string.h>#include <iostream.h>class VString {public: VString( unsigned len = 0 ); // Construct a VString of size <len>. VString( const char * s ); // Construct a VString from a C-style string.

~VString(); // Destructor

34

VStringunsigned GetSize() const; // Returns the number of characters.private: char * str; // character array unsigned size; // allocation size};VString::VString( unsigned len ){ size = len; str = new char[ size+1 ];//Dynamic str[0] = '\0';}

35

VStringVString::VString( const char * s )

{ size = strlen( s );

str = new char[ size+1 ];

strcpy( str, s );}

VString::~VString()

{ delete [] str;}

unsigned VString::GetSize() const

{ return size;}

36

VString

int main()

{VString zeroLen;

VString emptyStr( 50 );

VString aName( "John Smith" );

cout << aName.GetSize() << endl;

return 0;

}//ex4vstring.cpp

37

38

39

Copy Constructors

Makes a duplicate copy of an object of the same class. The default makes a bit-wise copy of the the object.

A copy constructor is invoked automatically when a temporary object is constructed from an existing one.

40

Student#include <iostream.h>

class Student {

public:

Student() { cout << "default constructor,"; }

Student( const Student & s ) { cout << "copy constructor,"; }

~Student() { cout << "destructor,"; }

friend ostream & operator <<( ostream & os, const Student & s )

{ cout << "Student,";

return os;}

};

41

StudentStudent InputNewStudent(){ Student aStudent;//A default constructor //... return aStudent;//A copy constructor}int main(){Student aStudent; //... return aStudent;}//ex4student.cpp

42

43

44

Deep Copy Operation Deep copy—copies the contents of an

object. char name[] = “John Smith”;

char * cp = new char[30];

strcpy(cp,name);

Shallow copy—copy the pointer of an object. char name[] = “John Smith”;

char * cp = name;

45

Student Copy#include "fstring.h"

class Course {

public:

Course( const FString & cname );

private:

FString name;

};

class Student {

public:

Student( unsigned ncourses );

~Student();

46

Student Copyprivate:

Course * coursesTaken;

unsigned numCourses;

};

Student::Student( unsigned ncourses )

{ coursesTaken = new Course[ncourses];

numCourses = ncourses;}

Student::~Student()

{ delete [] coursesTaken;}

47

Student Copy int ncourses = 7;

Student X(ncourses);

Student Y(X);

X

Y

array of course objects

X

Y

array of course objectsIf you’d like the following:

48

Student CopyClass Student {//…Public:Student(const Student & S);//…}Student:: Student(const Student & S){numcourses = S.numCourses; courseTaken = new Course[numcourses]; for (unsigned i =0; i < numcourses; i++) courseTaken[i]= S.courseTaken[I];}

49

Composite Classes

A class which contains data members that are objects of other classes.

When a class contains instances, references, or pointers to other classes, we call it a composite class.

50

Composite Classes

class Transcript{//…};

class Address{//…};

class Student {

public:

…

private:

long id;

Transcript tr;

Address addr;

float gradeAverage;

}

51

Composite Classes class Point { public: Point(); Point( const int xv, const int yv ); private: int x; int y; };

52

Composite Classes

const int MaxVertices = 10; enum Colors {white, blue, green} class Figure{public: Figure(); void SetCenter( const Point & P ); void SetColor( const int colr ); void SetVertex( const int n, const Point & P ); private: Point vertex[MaxVertices]; // array of vertices int vcount; // number of vertices Point center; // center of rotation int color; // color };

53

Composite Classes

int main(){Figure F;F.SetVertex( 0, Point( 1, 1 ));F.SetVertex( 1, Point( 10, 2 ));F.SetVertex( 2, Point( 8, 10 ));F.SetVertex( 3, Point( -2, 2 ));F.SetCenter(Point P( 6, 5 ) );const int FigCount = 5;Figure figList[FigCount]; // array of Figuresfor(int j = 0; j < FigCount; j++) figList[j].SetColor( green );return 0;}

54

Pre-defined Order The constructors for all member objects

are executed in the order in which they appear in the class definition. All member constructors are executed before the body of the enclosed class constructor executes.

Destructors are called in the reverse order of constructors. Therefore, the body of the enclosed class destructor is executed before the destructors of its member objects.

55

#include <iostream.h> class Point { public: Point() { cout << "Point constructor\n"; } ~Point() { cout << "Point destructor\n"; } };

Example: preorder.cpp

56

preorder.cpp const int MaxVertices = 3; class Figure { public: Figure() { cout << "Figure constructor\n"; } ~Figure() { cout << "Figure destructor\n"; } private: Point vertex[MaxVertices]; // array of vertices Point center; }; int main() { Figure F; return 0; }//ex4preorder.cpp

57

58

59

Passing messages

Data members should be private. Public data members violate the

principles of encapsulation. Function members can be public.

60

Axis class Axis { public: void SetTitle( const char * st ); void SetRange( int min, int max ); //... }; class ChartData { public: void Read( istream & inp ); //... };

61

Chart.cpp #include <iostream.h> #include <fstream.h> class Axis { public: void SetTitle( const char * st ); //... }; class ChartData { public: void Read( istream & ); //... };

62

Chart.cpp class Chart { public: Axis & HorizontalAxis() { return horizAxis; } Axis & VerticalAxis() { return verticalAxis; } ChartData & DataSet() { return dataset; } void Draw(); private: Axis horizAxis; Axis verticalAxis; ChartData dataset; };

63

Chart.cpp

int main() { Chart sales; sales.HorizontalAxis().SetTitle( "Revenue" ); sales.VerticalAxis().SetTitle( "Products" ); ifstream infile( "sales.dta" ); sales.DataSet().Read( infile ); return 0; }

64

Initializing Class Members

Constructor-initializer:class_name(argument_lis):member1(ctor_arglist1),member2

(ctor_arglist2),…{//…}

Example: enum Colors{white, blue, green};class Point { public: Point (cons Point &p); //…}

65

Class Figure{ public: Figure(const Point & ctr; Colors aClolor); //… private: Point center; Colors color; } Figure::Figure(const Point & ctr; Colors aClolor) : color(aColor),center(ctr) {color = aColor; Center = ctr; }

Initialization

66

Static Class Members

Declared as “static” Both data and function members may be

declared as static. Only one copy exists. Are controlled by the enclosing class. A static function can only access the static

members and the enumerated constants of a class.

Example: student.cpp

67

Student.cpp typedef unsigned long ulong; class Student { public: Student( ulong id ); // Construct Student from an id number. Student( const Student & S ); // Construct from another Student. ~Student(); static ulong GetCount(); // Return the static instance count. private: static ulong count; // instance count ulong idNum; // identification number };

68

Student.cpp

ulong Student::count = 0; // define, initialize Student::Student( ulong id ) { idNum = id; count++; } Student::Student( const Student & S ) { idNum = S.idNum; count++; } Student::~Student() { count--; } ulong Student::GetCount() { return count; }

69

Student.cpp #include <iostream.h> void MakeStudent() { Student C( 200001L ); cout << Student::GetCount() << endl; // displays "3" } int main() { Student A( 100001L ); cout << Student::GetCount() << endl; // displays "1" Student B( A ); cout << Student::GetCount() << endl; // displays "2" MakeStudent(); // displays "3“, then -1 cout << Student::GetCount() << endl; // displays "2" return 0; }//ex4student2.cpp

70

71

72

An example: Dive// DIVE.H - Dive class definition// Also contains in-line member functions.#include <iostream.h>class Dive {public: Dive( float avg, float diff ); float CalcTotalPoints() const; void Display() const; void SetDifficulty( float diff ); void SetJudgeScore( float score );private: float judgeScore; // average judges score float difficulty; // degree of difficulty};

73

Dive.cpp// DIVE.CPP - Dive class implementation.

#include "dive.h"

Dive::Dive( float avg, float diff ) // Constructor.

{ SetJudgeScore( avg );

SetDifficulty( diff );

}

void Dive::Display() const

{// Display the Dive on the console.

cout << "[Dive]: "

<< judgeScore << ','

<< difficulty << ','

<< CalcTotalPoints()

<< endl;

}

74

Dive.cppvoid Dive::SetDifficulty( float diff ){ if((diff >= 1.0) && (diff <= 5.0)) difficulty = diff; else cerr << "Range error in Dive::SetDifficulty()" << " value: " << diff << endl;}void Dive::SetJudgeScore( float score ){ judgeScore = score;}float Dive::CalcTotalPoints() const{ return judgeScore * difficulty;}

75

Main.cpp#include "dive.h"int main(){ Dive D1( 8.5, 3.0 ); // create 3 dives Dive D2( 9.0, 2.5 ); Dive D3( 8.0, 3.3 ); D1.Display(); // display 3 dives D2.Display(); D3.Display(); D2.SetDifficulty( 3.0 ); // modify difficulty // Display the Dives again. cout << "\nChanging Dive 2\n"; D1.Display(); D2.Display(); D3.Display(); return 0;}ex4dive.cpp

76

77

78

Text File Streams //…Reading ifstream infile(“payroll.dat”); if (!infile) cerr <<“Error:open file.\n”; else { infile >> employeeId >> hoursWorked >> payRate; //… }

79

Text File Streams

infile.close() //close the file infile.open(“payroll.dat”, ios::in); //open while (!infile.eof()) //check the end of file { infile >>employeeId>>hoursWorked>>

payRate; //… }

80

Text File Streams

recLen = 10;

recNum = 3;

offset = (recNum -1) * recLen;

infile.seeg(offset, ios::beg);

char buf[10];

infile.get(buf, 10);

cout<<buf<<endl;

81

Text File Streams

ios::beg //from the beginning ios::end //from the end ios::cur //from the current position infile.seekg(-10, ios::end); infile.seekg(-1, ios::cur); streampos p = infile.tellg(); //current position

82

Text File Streams ofstream ofile(“payroll.dat”, ios::out); … if (!ofile) cerr<<“Error:open file.\n”; else{ ofile << employeeId<<hoursWorked << payRate <<endl;} ofile.open(“payroll.dat”, ios::out); //new for out ofile.open(“payroll.dat”, ios::app); //append

83

Example: Student Registration

Sample data for a student:102234 //student ID

962 //semester (96/2)

CHM_1020 C 3//Section C, 3 credits

MUS_1100 H 1//Section H, 1 credits

BIO_1040 D 4 //Section D, 4 credits

MTH_2400 A 3 //Section A, 3 credits

84

Course.h #include <iostream.h> #include <fstream.h> const unsigned CnameSize = 10; class Course { public: Course(); void Input( ifstream & infile ); void Output( ofstream & ofile ) const; private: char name[CnameSize]; // course name char section; // section (letter) unsigned credits; // number of credits };

85

Course.h

const unsigned MaxCourses = 10; class Registration { public: Registration(); void Input( ifstream & infile ); void Output( ofstream & ofile ) const; private: long studentId; // student ID number unsigned semester; // semester year, number unsigned count; // number of courses Course courses[MaxCourses]; // array of courses };

86

Regist.cpp #include "course.h" Course::Course() { name[0] = '\0';} void Course::Input( ifstream & infile ) { infile >> name >> section >> credits;} void Course::Output( ofstream & ofile ) const { ofile << " Course: " << name << '\n' << " Section: " << section << '\n' << " Credits: " << credits << endl; } Registration::Registration() { count = 0;}

87

Regist.cpp

void Registration::Input( ifstream & infile ) { infile >> studentId >> semester >> count; for(int i = 0; i < count; i++) courses[i].Input( infile ); } void Registration::Output( ofstream & ofile ) const { ofile << "Student ID: " << studentId << '\n' << "Semester: " << semester << '\n'; for(int i = 0; i < count; i++) { courses[i].Output( ofile ); ofile << '\n'; } }

88

Main.cpp #include "course.h" int main() { // Read a Registration object from an input // file and write it to an output file. ifstream infile( "rinput.txt" ); if( !infile ) return -1; Registration R; R.Input( infile ); ofstream ofile( "routput.txt", ios::app ); if( !ofile ) return -1; R.Output( ofile ); return 0; }

89

90

91

92

Readings

Readings Chapter 2 Sections 2.2 - 2.7, Chapter 4, Chapter 7 Section 7.5