The document discusses different types of data members and member functions in classes in C++, including constant, mutable, and static data members, as well as constant, static, overloaded, and inline member functions. It provides examples of how to declare and use these various data members and member functions. It also covers topics like constant member functions, static data members, nested member functions, friend functions and classes, array of objects, and passing objects to functions by value, reference, and pointer.

1. MORE ON CLASSES
AND OBJECTS
Chapter 4

2. Data Members
Types of data member :
 Constant data members.
 Mutable data members.
 Static data members.

3. Member Functions
Different types of member functions:
 Nested Member functions.
 Overloaded member functions.
 Constant member function.
 Member functions with default arguments.
 Inline member functions.
 Static member functions.

4. Constant data members
 The data members whose value cannot be
changed throughout the execution of the
program.
 They are declared by preceding the qualifier
const.
Example:
const int x = 10;

5. Example:
#include<iostream>
void main()
{
const int x = 10;
x++; // error
cout<< x<<endl;
}

6. Mutable data members
 If the need arises such that the constant
member functions has to modify the value of
the data members then the data member has
to be declared by prefixing the keyword
„mutable‟.

7. Example:
#include<iostream>
class x
{
int a ;
mutable int b;
public:
void xyz() const
{
a++; // error
b++; // legal
}
};
void main()
{
X x2;
X2.xyz();
}

8. Constant member function
#include<iostream.h>
void main()
class x
{
{ x x1;
x1.getdata(56);
int a;
Cout<< x1.setdata()<<endl;
public: }
void getdata(int x)
{
a=x;
}
int setdata() const
{
a++; // error
return a;
}
};

9. Static data member
 Those members whose members are
accessed by all the objects of a class.
 It is not own by any object of a class.
 Only one copy of a static data member is
created for a class which can be accessed by
all the objects of that class.

10. Example:
#include<iostream.h>
class x void main()
{
{ x x1,x2;
static int a; x1.display();
x2.display();
int b; x1.getdata(1);
x2.getdata(2);
public: x1.display();
x2.display();
void getdata(int x) }
{
Output:
0
b=x; 0
a++; 2
2
}
void display(void)
{
cout<< a<< endl;
}
};
int x :: a;

11. Static member function
#include<iostream.h>
void main()
class sample
{
{ sample s1,s2;
Sample :: getdata(1)//invoking static member function
static int a;
s1.display();
s2.getdata(2);// invoking static member function using object
s2.display();
public: }
Output:
1
Static void getdata(int x)
2
{
a=x;
}
void display(void)
{
cout<< a<< endl;
}
};
Int sample :: a;

12. Nested member function
#include<iostream>
void main()
class sample {
{ sample e;
t =e.get_data (34);
int x; cout<< t << endl;
public: }
Output:
void get_data(int); Nested member function
void message(char *); 34
};
int sample :: get_data(int a)
{
x=a;
message(“Nested member function”);
return x;
}
void sample :: message(char *s)
{
cout<< s<< endl;
}

13. Overloaded member function
With single class:
Class A
{ Void main()
Public: {
A a1;
void display(void); a1.display(void);
void display(int); a1.display(20);
}
}; Output:
void a :: display(void) Hello
{ 20
cout<< “Hello”<< endl;
}
void a :: display(int d)
{
cout<<d<< endl;
}

14. Overloaded member function
Two different classes.
Class A Void main()
{ {
A a1;
Public:
B b1;
void display(void); a1.display(void);
}; b1.display(void);
Class B }
Output:
{ Hello
Public: World
void display(void);
};
void A :: display(void)
{
cout<< “Hello”<< endl;
}
void B :: display(void)
{
cout<<“World”<< endl;
}

15. Member functions with default
arguments
#include<iostream>
class addition
{
Public:
void add(int, int = 2);
};
void addition :: add(int a, int b)
{
return(a+b);
}
Void main()
{
addition a;
a.add(5,6);
a.add(6);
}
Output
11
8

16. Inline function
Class test
{
void main()
private :
{
int a; test t;
int b; int a,b;
public: cout<<“enter the two numbers” <<
endl;
void set_data(int , int )
cin>> a >> b;
int big() // t.set_data(a,b);
automatic inline function cout<<“the largest number is ” <<
{ t.big() << endl;
if (a > b) }
return a;
else
return b;
}
};
inline void test :: set_data(int x, int y)
{
a=x;
b=y;
}

17. Friend function
 To provide non-member function to access
private data member of a class, c++ allow the
non-member to be made friend of that class.
 Syntax:
friend<data_type> <func_name>();

18. Example
Friend non-member function:
Class sample
{
Int a;
Public:
Friend void change(sample &);
};
Void change(sample &x)
{
x.a= 5;
}
Void main()
{
Sample A;
Change(A);
}

19. Example
 Friend member function:
Void test :: set_data(sample &a, int b)
Class sample; // forward declaration. {
Class test a.x= b;
}
{ Int sample :: get_data(void)
Public: {
Return x;
Void set_data(sample &, int); }
}; Void main()
{
Class sample Sample e;
{ Test f;
f.set_data(5);
Private: Cout<< e.get_data()<< endl;
Int x; }
Public:
Int get_data(void);
Friend void test :: set_data(sample &, int);
};

20. Friend class
 A class is made friend of another class. For
example,
If a class X is a friend of class Y then all the
member function of class X can access the
private data member of class Y.
Declaration:
friend class X;

21. Example of friend class
# include<iostream>
Class Y; void Y :: change_data(X &c, int p, int
q)
Class X {
{ c.X = p;
c.Y = q;
Int x,y;
}
Public: void X :: show_data()
Void show_data(); {
Cout<< x << y << endl;
friend class Y; }
}; Int main()
{
Class Y X x1;
{ Y y1;
Y1.change_data(x1,5,6);
Public:
x1.show_data();
void change_data( X &, int, int); return 0;
}; }

22. Array of class objects
 Array of class objects is similar to the array of
structures.
 Syntax:
Class <class_name>
{
// class body
};
<class_name><object_name[size]>;

23. Example:
Class Employee
{
Char name[20];
Float salary;
Public:
Void getdata();
Void display();
};
Employee e[5];

24. Passing object to functions
 By value
 By reference
 By pointer

25. By value
Here only the copy of the object is passed to the
function definition.
The modification on objects made in the called
function will not be reflected in the calling
function.

26. By reference
Here when the object is passed to the function
definition, the formal argument shares the
memory location of the actual arguments.
Hence the modification on objects made in the
called function will be reflected in the calling
function.

27. By pointer
Here pointer to the object is passed. The
member of the objects passed are accessed
by the arrow operator(->).
The modification on objects made in the called
function will be reflected in the calling function.

28. Example
#include<iostream> void set(A *z,int t)
{
class A z->a = t;
{ }
int a; int main()
public: {
A a1;
void set(A, int); // call by value a1.a = 10;
void set(int, A &); // call by reference cout<<a;
a1.set(a1,5);// by value
void set(A *, int); // call by pointer
cout<<a;
}; a1.set(20,a1);// by reference
cout<<a;
void set(A x,int p)
a1.set(&a1,30);// by pointer
{ cout<<a;
}
x.a = p;
} Output:
10
void set(int q, A &y)
10
{ 20
30
y.a = q;
}

29. Nested class
 Class within a class
 Example:
class A
{
// class body
class B
{
// inner class body
};
}