Classes and

Objects
LECTURE 2
Constant object and constant 2

member function

 Constant object
 Whose data member values cannot be changed
 Can invoke constant member function only
 Declared as,
 const class_name object_name;
Constant object and constant 3

member function
 Constant member function
 Function in which data members remain constant
 Uses ‘const’ as suffix in function declaration/definition
 Return_type function_name(arg/s) const;
class alpha main()
{ int a; { 4
public: alpha s1 ;
alpha() : a(10) { } const alpha s2;
void display() s1.display();
{ //s2.display(); cannot invoke non-const func
a+=10; s1.show();
cout<<a<<endl; s2.show();
} }
void show()const
{
// a+=10; not permitted
cout<<a<<endl;
}
};
Static data member 5

 Only one copy of that member is created for the entire class and
is shared by all the objects of that class, no matter how many
objects are created.
 It is declared as,
 static data_type member;
 Accessible within class and have lifetime of entire program.
 It is initialized outside the class because its scope is not limited
to class but entire program.
 Data_type class_name :: member =value;
 OR
 Data_type class_name :: member; // takes zero value by default
 int item :: count ; //count defined
class item
int main( )
{
static int count; //count is static
{ 6
item a,b,c;
int number;
a.get_count( );
public: The output would be
b.get_count( ); count:0
void getdata()
c.get_count( ); count:0
{
count:0
number=count++; After reading data
a.getdata( ); count: 3
}
b.getdata( ); count:3
void getcount(void)
count:3
c.getdata( );
{
cout<<”count:”;
cout«"after reading data : "«endl;
cout<<count<<endl;
a.get_count( );
}
b.gel_count( );
};
c.get count( );
return(0);
}
Static member function 7

 Can access static data members only

 Toinvoke static member function, we do not need to
access through object using member access
operator(.) but rather uses class name with scope
resolution operator because it refers to entire class
rather than specific object
 Class_name:: static_function();
class test static void showcount()
{
int code;
{ cout<<"count="<<count<<endl; }
};
8
static int count; // static member variable
public: int test:: count; count=2
count=3
test()
object member : 1
{ int main() object member : 2
code=++count; object member : 3
{ count=3
test t1,t2; Object 3 destroyed
} Object 2 destroyed
test :: showcount ( ); Object 1 destroyed
void showcode() test t3;
{ test:: showcount( );
cout<<"object member : "<<code<<endl;
} t1.showcode( ) ;
~test() t2.showcode( );
{ t3.showcode( );
cout<<"Object "<<code<<" destroyed"<<endl; test:: showcount( );
count--; return(0);
} }
‘this’ pointer 9

 When a member function(non static) is called, it is automatically

passed an implicit argument that is a pointer to the invoking object
(that is, the object on which the function is called). This pointer is
called this.
 ‘this’ pointer contains the address of that object

class alpha
{ public:
void showaddress()
{ cout<<this<<endl; }
};
main()
{ alpha s1 ;
s1.showaddress();
}
‘this’ pointer 10

 The private variable ‘a’ can be used directly inside a

member function, like a=123;
 We can also use the following statement to do the same
job.
 this → a = 123

 Also used to remove ambiguity among data members

class alpha
{ int a;
public:
void setdata(int a)
{ this-> a = a; }
‘this’ pointer 11

 It acts as implicit argument to all member function. Hence

can be used to return object.

comp comp::add( comp c2)

{
real += c2.real;
this->imag += c2.imag;
return *this;
}
Which is invoked as c3=c1.add(c2)
Pointer to object and member access 12

 As in basic data types and array, pointers can also point to

object as well
 Class_name *object;
 Uses indirection operator(->) for accessing members as,
 object->member; // (*object).member
class alpha
{ public:
void showaddress()
{ cout<<this<<endl; }
};
main()
{ alpha s;
alpha *sp =&s;
sp->showaddress(); // or , (*sp).showaddress();
}
DMA for object and object array 13

 For single object,  For array of objects,

main() main()
{ alpha *sp1; { int n;
sp1=new alpha; cin>>n;
sp1->showaddress(); alpha *sp[20];
for(int i=0;i<n;i++)
alpha *sp2=new alpha; {
sp2->showaddress(); sp[i]=new alpha;
sp[i]->showaddress();
} }
}
Friend functions 14

 Non-member function defined outside the class but

can access all data members of class
 Prototype appears within the class(either in private or
public section)
 Prototype is preceded by keyword “friend”
 takes object as argument (or create object) as it
cannot access private data members directly
 Invoked as normal function without object because it
is non-member function and does not belong to a
class
 Friend functions 15

 1. It can access private members of a class

float mean (sample s)
class sample {
{ return (float(s.a+s.b)/2.0);
}
int a, b;
public: main ( )
void setvalue( ) { a=25;b=40;} {
sample x;
friend float mean( sample s); x . setvalue( );
}; cout<<"mean value=“
<<mean(x)<<endl;
}
Friend functions 16
 2. It can act as bridge between two or more classes
class abc; //forward declaration
void max( xyz m, abc n)
class xyz {
{ int x; if(m . x >= n.a)
public: cout<<m.x;
else
void setvalue(int i) { x = i; } cout<< n.a;
friend void max (xyz,abc); }
};
int main( )
class abc
{
{ int a; abc j;
public: j . setvalue( 10);
void setvalue( int i) {a=i; } xyz s;
s.setvalue(20);
friend void max(xyz,abc); max( s , j );
}; }
Friend functions 17
 Member function of one class can be friend of another.

class B;
class A void A::show(B &x)
{ {
public: cout<<x.b;
void show(B&); }
};
main()
{
class B A m;
{ int b; B n;
public: m.show(n);
B():b(20){ } }
friend void A::show(B&);
};
Friend Class 18

 A friend class can access all the private and protected data
members of the class to which it is friendly.
 Member function of the friendly class becomes the friend
function to the class to which it is friendly.
 Friend class is not mutual. That is, if the first class becomes
friend to second class, then it is not necessary that second
class is also friend to first class.
Friend Class 19
class B; void A::show(B &x)
class A {
cout<<a<<x.b;
{ int a;
}
public:
A():a(10){ }
main()
void show(B&);
{
}; A m;
B n;
m.show(n);
class B }
{ int b;
public: Note:1. friend class A can access
private member of B
B():b(20){} 2. Member function of class A
friend class A; becomes friend of B which can
access data of B.
};