structures, classes and objects handling data and objects unit - 03

Structures, Structures, Classes and Classes and

ObjectsObjectsHandling data and objectsHandling data and objects

Unit - 03Unit - 03

Unit IntroductionUnit Introduction

This unit covers structures, classes This unit covers structures, classes and objectsand objects

Unit ObjectivesUnit Objectives

After covering this unit you will After covering this unit you will understand…understand…

StructuresStructures ClassesClasses Static data and member functionsStatic data and member functions Differences between structures and Differences between structures and

classesclasses ReferencesReferences Friend functions and classesFriend functions and classes

StructuresStructures

Following will be discussed in order Following will be discussed in order to understand structures:to understand structures: Declaration Declaration DefinitionDefinition Using structuresUsing structures Nested structuresNested structures

Declaring StructuresDeclaring Structures structstruct keyword is used for declaration keyword is used for declaration A structure is collection of variables A structure is collection of variables

and methodsand methods In a structure, variables can have In a structure, variables can have

different data typesdifferent data types Can have private, protected and public Can have private, protected and public

access specifiersaccess specifiers The default access specifier is The default access specifier is publicpublic Semicolon “;” comes in the end to Semicolon “;” comes in the end to

complete structure declarationcomplete structure declaration

Example: Declaring Example: Declaring StructuresStructures

#include <iostream.h>#include <iostream.h>

struct SPartstruct SPart

{{

private:private:

int partType; int partType; // type of part, by default public// type of part, by default public

public:public:

float cost; float cost; // cost of part, be default public// cost of part, be default public

int GetPartType()int GetPartType()

{{

return partType;return partType;

}}

}; }; // semicolon indicates end of declaration// semicolon indicates end of declaration

Defining StructuresDefining Structures

With declarationWith declaration A structure can be defined while declaring A structure can be defined while declaring

the structurethe structure Structure Tag (which is used to name the Structure Tag (which is used to name the

structure) is not required, if a structure structure) is not required, if a structure variable is defined while declaring the variable is defined while declaring the structurestructure

Without declarationWithout declaration Structures can be defined separately after Structures can be defined separately after

declarationdeclaration

Example: Defining Example: Defining StructuresStructures// declaring and defining together// declaring and defining together

structstruct // tag is not required here// tag is not required here

{{

int partType; int partType; // type of part// type of part

float cost; float cost; // cost of part// cost of part

} part;} part; // declared and defined// declared and defined

// declaring and defining separately// declaring and defining separately

struct SMachine struct SMachine // tag is required to define it separately// tag is required to define it separately

{{

int machineType; int machineType; // type of machine// type of machine

float cost;float cost; // cost of machine// cost of machine

};}; // declared only// declared only

SMachine machine; SMachine machine; // defined now// defined now

Using StructuresUsing Structures Structure can be initialised either by: Structure can be initialised either by:

putting values in it; orputting values in it; or assigning other structure of same typeassigning other structure of same type

A structure variable can be assigned A structure variable can be assigned to other if they are instance of same to other if they are instance of same structurestructure

Assigning different structure types Assigning different structure types (even though they have exactly the (even though they have exactly the same data types) is not allowed and same data types) is not allowed and will generate an errorwill generate an error

Using Structures (contd.)Using Structures (contd.) Structures are initialised using Structures are initialised using

curly bracescurly braces Dot (Dot (..) operator is used to access ) operator is used to access

the variablesthe variables

Example: Using Example: Using StructuresStructures

// Initialising a structure variables// Initialising a structure variables

# include <iostream.h># include <iostream.h>

struct SPartstruct SPart

{{

int partType; int partType; // type of part// type of part

float cost; float cost; // cost of part// cost of part

};};

void main()void main()

{{

SPart part1 = {12,23.56}; SPart part1 = {12,23.56}; // Initializing variables// Initializing variables

SPart part2;SPart part2;

part2 = part1;part2 = part1;

part2.cost = 13.5f;part2.cost = 13.5f; // cost variable accessed// cost variable accessed

}}

StructuresStructures Nesting can be to any level (nth Nesting can be to any level (nth

level)level) Dot (Dot (..) operator is used to access ) operator is used to access

the each inner levelthe each inner level When the inner most level is When the inner most level is

reached, the dot (.) operator will reached, the dot (.) operator will be used to access the variables be used to access the variables and functions and functions

Example: Nested Example: Nested StructuresStructures

// Example of Structure nesting// Example of Structure nesting

# include <iostream.h># include <iostream.h>

struct SDistancestruct SDistance

{{

int feet; int feet;

float inches;float inches;

};};

struct SRoomstruct SRoom

{{

SDistance length;SDistance length;

SDistance width;SDistance width;

};};

Example: Nested Structures Example: Nested Structures (contd.)(contd.)


{{

SRoom dining = {{10,120},{10,120}} SRoom dining = {{10,120},{10,120}} // Initializing// Initializing

SRoom study; SRoom study;

study.length.feet = 10; study.length.feet = 10; // Assigning values// Assigning values

study.length.inches = 120;study.length.inches = 120;

study.width.feet = 10;study.width.feet = 10;

study.width.inches = 120;study.width.inches = 120;

}}

Classes in C++ Classes in C++

Following will be discussed in order Following will be discussed in order to understand Classes in C++:to understand Classes in C++: Classes and objectsClasses and objects Access specifiersAccess specifiers Member functionsMember functions ConstructorsConstructors DestructorsDestructors Static class dataStatic class data

Classes and ObjectsClasses and Objects Classes are the infrastructures Classes are the infrastructures

while objects are runtime utilisation while objects are runtime utilisation of those infrastructuresof those infrastructures

A class has functions and dataA class has functions and data Member functions and data can be Member functions and data can be

of type private, public or protectedof type private, public or protected Default access specifier is Default access specifier is privateprivate Variables cannot be initialised Variables cannot be initialised

during declaration (as you can in during declaration (as you can in Java)Java)

Example: A Simple ClassExample: A Simple Class// demonstrates an object// demonstrates an object


class SmallObj class SmallObj // Specify a class name// Specify a class name

{{

private:private:

int m_SomeData; int m_SomeData; // Class data// Class data

public:public:

void SetData(int data) void SetData(int data) // member function to set data// member function to set data

{{

m_SomeData = data;m_SomeData = data;

}}

void ShowData() void ShowData() // member function to display data// member function to display data

{{

cout << “\nData is “ << m_SomeData;cout << “\nData is “ << m_SomeData;

}}

};};

Example: A Simple Class Example: A Simple Class (contd.)(contd.)


{{

SmallObj s1, s2; SmallObj s1, s2; // defining two objects// defining two objects

s1.SetData(1234); s1.SetData(1234); // calling member function to set data// calling member function to set data

s2.SetData(5677);s2.SetData(5677);

s1.ShowData(); s1.ShowData(); // calling member function to display// calling member function to display

// data// data

s2.ShowData();s2.ShowData();

}}

ConstructorsConstructors

Constructor is a class method with Constructor is a class method with exactly the same name as class exactly the same name as class namename

A constructor may accept A constructor may accept argument(s) but does not return argument(s) but does not return anything, not even anything, not even voidvoid

They are called when an instance of They are called when an instance of the class is createdthe class is created

A default constructor does not A default constructor does not accept any argumentaccept any argument

Constructors (contd.)Constructors (contd.)

If a default constructor is not provided, If a default constructor is not provided, compiler assumes there exists but it does compiler assumes there exists but it does not do anythingnot do anything

Constructors can be overloaded in their Constructors can be overloaded in their argument type and number of argumentsargument type and number of arguments

In constructors, variables can be In constructors, variables can be initialised to a default valueinitialised to a default value

A copy constructor is used when objects A copy constructor is used when objects are copiedare copied

Example: ConstructorsExample: Constructors#include <iostream.h>#include <iostream.h>

class Customer class Customer // Specify a class name// Specify a class name

{{

private:private:

int m_CustomerId; int m_CustomerId; // Class data// Class data

public:public:

Customer() Customer() // no-arg or default constructor // no-arg or default constructor

{{

m_CustomerId = 0; m_CustomerId = 0; // default customer ID// default customer ID

}}

Customer(int newCustomerId) Customer(int newCustomerId) // one-arg constructor // one-arg constructor

{{

m_CustomerId = newCustomerId;m_CustomerId = newCustomerId;

}}

};};

Example: ConstructorsExample: Constructorsvoid main()void main()

{{

Customer ordinaryCustomer; Customer ordinaryCustomer; // creating instance using// creating instance using

// default constructor// default constructor

Customer registeredCustomer(49); Customer registeredCustomer(49); // creating instance// creating instance

// using one-arg constructor// using one-arg constructor

}}

Copy ConstructorCopy Constructor

Copy constructor is used when Copy constructor is used when objects are copiedobjects are copied

Default copy constructor performs Default copy constructor performs shallow copyshallow copy

Explicit copy constructor can be Explicit copy constructor can be provided to perform deep copyprovided to perform deep copy

Shallow and Deep CopyShallow and Deep Copy

m_pAddressm_pAddress

name : e1name : e1

City : LHRCity : LHRState : PunjabState : PunjabCountry : PKCountry : PK

AddressAddress


name : e1name : e1


AddressAddress


name : e1name : e1


AddressAddress


name : e2name : e2


AddressAddress


name : e2name : e2

Initially Shallow Copy Deep Copy

EmployeeEmployee EmployeeEmployee

EmployeeEmployee

EmployeeEmployee

EmployeeEmployee

Example: Copy Example: Copy ConstructorConstructor

struct SAddressstruct SAddress

{{

char* city;char* city;

char* state;char* state;

char* country;char* country;

SAddress() SAddress()

{{

city = "";city = "";

state = "";state = "";

country = "";country = "";

}}

void DisplayAddress()void DisplayAddress()

{{

cout << city << ", " << state << ", " << country cout << city << ", " << state << ", " << country << endl; << endl;

}}

};};

Example: Copy Constructor Example: Copy Constructor (contd.)(contd.)

class Employeeclass Employee

{{

private:private:

SAddress* m_pAddress;SAddress* m_pAddress;

char* m_Name;char* m_Name;

public:public:

Employee()Employee()

{{

m_pAddress = 0;m_pAddress = 0;

}}

~Employee()~Employee()

{{

delete m_pAddress;delete m_pAddress;

}}

Example: Copy Constructor Example: Copy Constructor (contd.)(contd.) void SetAddress(char* city, char* state, void SetAddress(char* city, char* state,

char* country)char* country)

{{

m_pAddress = new SAddress();m_pAddress = new SAddress();

m_pAddress->city = city;m_pAddress->city = city;

m_pAddress->state = state;m_pAddress->state = state;

m_pAddress->country = country;m_pAddress->country = country;

}}

SAddress* GetAddress()SAddress* GetAddress()

{{

return m_pAddress; return m_pAddress;

}}

void SetName(char* name)void SetName(char* name)

{ {

m_Name = name; m_Name = name;

} }


char* GetName()char* GetName()

{ {

return m_Name; return m_Name;

}}

void Display()void Display()

{{

cout << m_Name << " -- ";cout << m_Name << " -- ";

m_pAddress->DisplayAddress();m_pAddress->DisplayAddress();

}}

// this copy constructor performs deep copy// this copy constructor performs deep copy

Employee(Employee& e) Employee(Employee& e)

{{

m_pAddress = new SAddress();m_pAddress = new SAddress();

m_pAddress->city = e.GetAddress()->city;m_pAddress->city = e.GetAddress()->city;

m_pAddress->state = e.GetAddress()->state;m_pAddress->state = e.GetAddress()->state;

m_pAddress->country = e.GetAddress()->country;m_pAddress->country = e.GetAddress()->country;

}}

};};


void main() void main()

{{

Employee e1;Employee e1; // no-arg constructor is called// no-arg constructor is called

e1.SetName("E1");e1.SetName("E1");

e1.SetAddress("LHR", "Punjab", "PK");e1.SetAddress("LHR", "Punjab", "PK");

e1.Display();e1.Display();

Employee e2 = e1;Employee e2 = e1; // copy constructor is called// copy constructor is called

e2.SetName("E2");e2.SetName("E2");

e2.GetAddress()->city = ”ISB";e2.GetAddress()->city = ”ISB"; // change city for e2// change city for e2



}}

DestructorsDestructors

Called when an instance of the class is Called when an instance of the class is destroyeddestroyed

Destructor is a class method starting Destructor is a class method starting with tilde (with tilde (~)~) and have exactly the and have exactly the same name as class namesame name as class name

Destructors are used to release Destructors are used to release resources held by the instance (object)resources held by the instance (object)

Destructor does not accept any Destructor does not accept any argumentargument

Destructors (contd.)Destructors (contd.)

Destructor does not return anything, Destructor does not return anything, not even not even voidvoid

Destructors can not be overloadedDestructors can not be overloaded Memory allocated by the instance is Memory allocated by the instance is

released after calling the destructorreleased after calling the destructor Automatically called when the object Automatically called when the object

goes out of scopegoes out of scope

Example: DestructorsExample: Destructors#include <fstream.h>#include <fstream.h>

class MyFileHandlerclass MyFileHandler

{{

private: private:

ofstream m_file;ofstream m_file;

public:public:

MyFileHandler()MyFileHandler()

{ {

m_file.open(“myFile.txt”, ios::binary); m_file.open(“myFile.txt”, ios::binary);

}}

~MyFileHandler()~MyFileHandler()

{{

m_file.close; m_file.close;

}}

Example: Destructors Example: Destructors (contd.)(contd.)

void WriteToFile(int buff[1000])void WriteToFile(int buff[1000])

{{

m_file.write((char*)buff, 1000*sizeof(int));m_file.write((char*)buff, 1000*sizeof(int));

}}

};};


{{

int myData[1000];int myData[1000];

MyFileHandler myFileHandler;MyFileHandler myFileHandler;

for(int j=0; j < 1000; j++)for(int j=0; j < 1000; j++)

{{

myData[j] = j;myData[j] = j;

}}

myFilehandler.WriteToFile(myData);myFilehandler.WriteToFile(myData);

}}

// as myFileHandler goes out of scope, destructor is called// as myFileHandler goes out of scope, destructor is called

// and the file is closed// and the file is closed

Member FunctionsMember Functions

Member functions are methods of a class, Member functions are methods of a class, could be:could be: private, private, protected or protected or publicpublic

Can be declared and defined together or Can be declared and defined together or separatelyseparately

Inline function’s code is expanded where Inline function’s code is expanded where it is called and differ in normal function it is called and differ in normal function calling mechanismcalling mechanism

Example: Member Example: Member FunctionsFunctions


class Employee class Employee // Specify a class// Specify a class

{{

private:private:

int m_EmployeeId; int m_EmployeeId; // Class data// Class data

int m_EmployeeAge;int m_EmployeeAge;

protected:protected:

// implicit inline function // implicit inline function

void ShowAge() void ShowAge() // Member function to show// Member function to show

{ { // Employee age// Employee age

cout << “\nAge is “ << m_EmployeeAge;cout << “\nAge is “ << m_EmployeeAge;

}}

Example: Member Functions Example: Member Functions (contd.)(contd.)

public:public:

void SetId(int id) void SetId(int id) // Member function to set id// Member function to set id

{{

m_EmployeeId = id;m_EmployeeId = id;

}}

void ShowId(); void ShowId(); // Declaration only// Declaration only

void SetAge(int age); void SetAge(int age); // Declaration only// Declaration only

};};

void Employee::ShowId() void Employee::ShowId()

{{

cout << “\nId is “ << m_EmployeeId;cout << “\nId is “ << m_EmployeeId;

}}

// explicit inline function// explicit inline function

inline void Employee::SetAge(int age) inline void Employee::SetAge(int age)

{{

m_EmployeeAge = age;m_EmployeeAge = age;

}}

Example: Member Functions Example: Member Functions (contd.)(contd.)


{{

Employee manager, worker; Employee manager, worker; // defining two objects// defining two objects

manager.SetId(1001); manager.SetId(1001); // calling member function to// calling member function to

// set Id// set Id

worker.SetId(5001); worker.SetId(5001); // calling member function to// calling member function to

// set Id // set Id

manager.SetAge(45); manager.SetAge(45); // calling member function to set// calling member function to set

// manger’s age// manger’s age

wroker.SetAge(45); wroker.SetAge(45); // calling member function to set// calling member function to set

// worker’s age// worker’s age

}}

Static DataStatic Data

Static data could be any typeStatic data could be any type Also called class dataAlso called class data Lifetime is the entire programLifetime is the entire program Shared among all objects of the same Shared among all objects of the same

class class Static data members are accessed using Static data members are accessed using

class name and class name and :::: operator operator In C++ static data is declared inside the In C++ static data is declared inside the

class and defined outside the classclass and defined outside the class

Example: Static DataExample: Static Dataclass Counter class Counter // Specify a class// Specify a class

{{

private:private:

int m_Count; int m_Count; // class data// class data

public:public:

void IncrementCount()void IncrementCount()

{{

m_Count++; m_Count++;

}}

int GetTotalCount()int GetTotalCount()

{{

return m_Count;return m_Count;

}}

Counter()Counter()

{{

m_Count = 0;m_Count = 0;

}}

}; };

Example: Static DataExample: Static Data (contd.)(contd.)

class Student class Student

{{

private:private:

int m_StudentId; int m_StudentId; // class data// class data

int m_StudentClass;int m_StudentClass;

static Counter sm_Counter; static Counter sm_Counter; // static counter to hold// static counter to hold // count for all students// count for all students

public:public:

void AddStudent(int id ,int studentClass) void AddStudent(int id ,int studentClass)

{ {

m_StudentId = id;m_StudentId = id;

m_StudentClass= studentClass;m_StudentClass= studentClass;

sm_Counter.IncrementCount(); sm_Counter.IncrementCount(); // increment count// increment count

}}

int GetStudentsCount() int GetStudentsCount() // getting class id// getting class id

{{

return sm_Counter.GetTotalCount();return sm_Counter.GetTotalCount();

}}

Example: Static DataExample: Static Data (contd.)(contd.)

};};

Counter Student::sm_Counter; Counter Student::sm_Counter; // if we don’t write this line// if we don’t write this line // compiler will give error// compiler will give error


{{

Student newStudent;Student newStudent;

Student oldStudent;Student oldStudent;

newStudent.AddStudent(100,10);newStudent.AddStudent(100,10);

oldStudent.AddStudent(23,10);oldStudent.AddStudent(23,10);

cout << “\nTotal = “ << oldStudent.GetStudentsCount();cout << “\nTotal = “ << oldStudent.GetStudentsCount();

} }

Difference Between Structures and Difference Between Structures and ClassesClasses

The default access specifier in class The default access specifier in class is is privateprivate, whereas in structure it is , whereas in structure it is publicpublic

Structures are inherited as Structures are inherited as publicpublic by defaultby default

Classes are inherited as Classes are inherited as privateprivate by by defaultdefault

ReferencesReferences

Available only in C++, not in CAvailable only in C++, not in C One way to pass parameters to function is One way to pass parameters to function is

by referenceby reference The variable passed by reference, if The variable passed by reference, if

altered, changes the actual variable valuealtered, changes the actual variable value & & is used to denote a reference, e.g. &p is used to denote a reference, e.g. &p

(where p is any data type)(where p is any data type) References could be constant, called References could be constant, called

constant referencesconstant references, e.g. const &p, e.g. const &p

Example: ReferencesExample: References// Passing by reference example// Passing by reference example



{{

void IntFrac(const float&, float&, float&);void IntFrac(const float&, float&, float&);

float number,intPart,fracPart;float number,intPart,fracPart;

dodo

{{

cout << “\nEnter a real number:”;cout << “\nEnter a real number:”;

cin >> number;cin >> number;

Intfrac(number,intPart,fracPart);Intfrac(number,intPart,fracPart);

cout << “Integer part is “ << intPartcout << “Integer part is “ << intPart

<< “, fraction part is “ << fracPart;<< “, fraction part is “ << fracPart;

}while (number != 0)}while (number != 0)

}}

Example: References Example: References (contd.)(contd.)

//IntFrac()//IntFrac()

// finds integer and fractional part of the real number// finds integer and fractional part of the real number

void IntFrac(const float& n, float& intp, float& fracp)void IntFrac(const float& n, float& intp, float& fracp)

{{

intp = float(long(n));intp = float(long(n));

fracp = n - intp;fracp = n - intp;

// n can not be changed inside the function as it is // n can not be changed inside the function as it is

// constant reference// constant reference

}}

Friend Classes and Friend Classes and FunctionsFunctions

There are two types of friend modifiers:There are two types of friend modifiers: Class LevelClass Level Function LevelFunction Level

A friend function can access the private A friend function can access the private data of that classdata of that class

A friend function does not belong to a A friend function does not belong to a class, and class, and

Its definition occurs outside the class Its definition occurs outside the class without specifying the class namewithout specifying the class name

Example: Friend Function / Example: Friend Function / ClassClass

// friend function example// friend function example


class Beta;class Beta; // forward declaration of class Beta// forward declaration of class Beta

class Alphaclass Alpha

{{

private:private:

int m_Data; int m_Data; // class private data// class private data

public;public;

Alpha()Alpha()

{ {

m_Data = 3; m_Data = 3;

} // assigning class data} // assigning class data

friend int FriFunc(Alpha,Beta); friend int FriFunc(Alpha,Beta); // declaring friend// declaring friend

// function// function

friend Beta; friend Beta; // Beta is friend of// Beta is friend of

// Alpha// Alpha

};};

Example: Friend Function / Class Example: Friend Function / Class (contd.)(contd.)

class Betaclass Beta

{{

private private

int m_Data; int m_Data; // class private data// class private data

public:public:

Beta()Beta()

{{

m_Data = 7;m_Data = 7;

} } // assigning data// assigning data

void ChangeAlpha(Alpha& a);void ChangeAlpha(Alpha& a);

friend int FriFunc(Alpha,Beta); friend int FriFunc(Alpha,Beta); // declaraing friend// declaraing friend

}; }; // function// function

int FriFunc(Alpha a, Beta b)int FriFunc(Alpha a, Beta b) // friend function// friend function

{{

return (a.m_Data + b.m_Data); return (a.m_Data + b.m_Data);

}}

Example: Friend Function / Class Example: Friend Function / Class (contd.)(contd.)

void Beta::ChangeAlpha(Alpha& a)void Beta::ChangeAlpha(Alpha& a)

{{

a.m_Data = 100;a.m_Data = 100; // change Alpha’s private // change Alpha’s private datadata // as Beta is a friend of // as Beta is a friend of AlphaAlpha

}}


{{

Alpha aa;Alpha aa; // define aa// define aa

Beta bb;Beta bb; // define bb// define bb

cout << FriFunc(aa,bb);cout << FriFunc(aa,bb); // calling friend function// calling friend function

bb.ChangeAlpha(aa);bb.ChangeAlpha(aa); // change Alpha’s private data// change Alpha’s private data // through bb// through bb

cout << FriFunc(aa,bb);cout << FriFunc(aa,bb); // calling friend function// calling friend function

}}

Unit SummaryUnit Summary

In this unit you have covered …In this unit you have covered … StructuresStructures ClassesClasses Static data and member functionsStatic data and member functions ReferencesReferences Friend functions and classesFriend functions and classes

structures, classes and objects handling data and objects unit - 03

Documents

structure structure

declaration structures

structure variable

declaring structures

public float cost cost

default public public

end of declaration slide

defined declaring