Govind Murari Upadhyay Assistant Professor IITM, Janakpuri, Delhi

Object Oriented Programming Using C++ UNIT-2

1

Classes
A class is a way to bind the data and its associated functions together. It allows the data (and functions) to be hidden, if necessary from external use. When defining a class, we are creating a new abstract data type that can be treated like any other built-in data type. Generally, a class specification has two parts: 1. Class declaration 2 . Class function definitions The class declaration describes the type and scope of its members. The class function definitions describe how the class functions are implemented.
2

Classes
class identifier {access specifier: // Body of class having data members statements; //and functions members enclosed by curly braces {}. }; //The class declaration ends with the semicolon. The class body comprises data members and function members. The data members comprise abstract data that applies to all the object of class and is relevant to the aim of the program. The common characteristics of objects of class are described by the function members of the class.
3

Definition of Member Functions in a Class

Eg. Suppose it is required to assign the values of 10 and 13 to the X and Y coordinates of a point and display the same. Class point { private: int x; int y; public: void getxy (int x_cord, int y_cord); void showxy(); }; Here the member functions getxy() and shoxy() have been incorporated as member functions of the class. The member functions can be declared in two ways: i) outside the class definition ii) inside the class definition Irrespective of the place of definition, the function should perform the same task. Therefore, the code for the function body would be identical in both the cases.
4

DEFINING A MEMBER FUNCTION OUTSIDE THE CLASS

For defining a function outside the class body one has to use the scope resolution operator (::). An illustration is given below. type class_name :: Function_name (type parameter1, - - -, - - -, type parameter n) { statements ; } // function body Here type refers to the type of the data returned by the function, it is followed by name of the class, then the scope resolution operator followed by function name and parameters in brackets.

Program
This is followed by body of function in braces{}. #include <iostream> class Market { // start of class declaration public: void Display(); // function prototype }; // end of class void Market::Display () //function definition outside the class {cout<< Welcome To This Market << endl; cout << Here is the price List <<endl; } void main() //main program {Market L1; // L1 is declared an object of class market L1.Display(); // L1 calls function display }
6

Inside the Class Definition

A method of defining a member function is to replace the function declaration by the actual function definition inside the class. Small functions may be defined inside the class definition. Note that as the member functions are defined inside the class definition, there are no semicolons after the function definitions. When a function is defined inside a class, it is treated as an inline function. #include <iostream.h> class point { private: int x; int y; public: void getxy (int x_cord, int y_cord) { x = x_cord; y = y_cord; } 7

void showxy(); }; // end of class void point :: showxy() { cout << X coordinate << x << endl; cout << Y coordinate << y << endl; } void main() { point p; point q; p.getxy(10,12); p.showxy(); q.getxy(15,25); q.showxy(); } //end of main

The Scope Resolution Operator

As you know, the :: operator links a class name with a member name in order to tell the compiler what class the member belongs to. However, the scope resolution operator has another related use: it can allow access to a name in an enclosing scope that is "hidden" by a local declaration of the same name. For example, consider this fragment: int i; // global i void f() { int i; // local i i = 10; // uses local i ... } As the comment suggests, the assignment i = 10 refers to the local i. But what if function f() needs to access the global version of i? It may do so by preceding the i with the :: operator, as shown here.

int i; // global i void f() { int i; // local i ::i = 10; // now refers to global i .. .}

10

Information (Data) Hiding:

Data is hidden inside the class, so that it cannot be accessed even by mistake by any function outside the class. C++ imposes a restriction to access both the data and functions of a class. It is achieved by declaring the data part as private. All the data and functions defined in a class are private by default. #include<iostream.h> class part { private: int modelno, partno; float cost; public: void setpart(int mn, int pn, int c) { Modelno=mn; Partno=pn; Cost=c; } Void showpart() { cout<< Model :<< modelno<<endl; cout<< Number :<< partno<<endl; cout<< Cost :<<cost<<endl; - -;
11

void main() { part p1, p2; p1.setpart(1996, 23, 1250.50); p2.setpart(2000, 243, 2350.50); cout<< first part details :<<endl; p1.showpart(); cout<< second part details :<<endl; p2.showpart(); }

12

DECLARATION OF CLASS
The form of code used for declaring a class is illustrated below. class X // class is keyword, X is the name of class { private: //access label private memberA; // memberA is a private member of class X. protected: // access label protected memberB; // MemberB is protected member ...... // dotted line stands for other data or functions public: //access label public ...... memberC; //memberC is a public member private: //a access label may be repeated memberD; // memberD is also a private member of class X };
13

ACCESS SPECIFIERS private, protected and public

PRIVATE: The class members written under the access label private are accessible by class function members or friend functions and the functions of friend classes. The keyword friend provides this special privilege to the function or class declared as friend in the class body. The data or functions declared private cannot be accessed from outside the class. The objects of the class can access the private members only through the public function members of the class. This property of class is also called information hiding. However, with the help of pointers one can indirectly access private data members provided the class contains at least one public data member. Generally data members are declared private. The intention is to hide as much information about data and implementation of class as possible. This also helps against accidental change in object data members. The functions members are in general declared public. 14

PROTECTED: The class members declared protected are accessible by the function members of same class and friend functions and friend classes as well as by functions of derived classes. For all other operations protected members are similar to private members. PUBLIC: The class members declared public are accessible from inside or outside the class. Some of the public functions of class provide interface for accessing the private and protected members of the class. For instance, initialization of a class object with private or protected data is always carried through public functions. Some public function also provide interface for other classes.
15

class with only one public function

#include <iostream> class Market // Market is name of class. { //The , marks beginning of class declaration. public: // Access label public void Display() // Definition of a public function Display () { cout<< Welcome To This Market << endl; cout << Here is the price List <<endl;} }; void main() // start of main program. {Market L1; // declaration of object L1 of class Market L1.Display(); // Function linked with object L1 }
16

INITIALIZING PRIVATE DATA MEMBERS

An object of a class is constructed when its data members are initialized. If data is declared private, the initialization is carried by a public function which may be a constructor function. The data members x, y and z are declared private. For accessing the private data members we need a public function. For defining the same function outside the class body, first we have to declare its prototype in the class as, void Setprice (int , int , int ); and put the definition outside the class as given below. void Market ::Setprice (int a , int b , int c ) {x = a, y = b , z = c ;} The general practice is to declare the function prototype inside the class and to define the same outside the class. The difference between the two is that functions defined inside the body of class are taken as inline functions while the ones defined outside the class body are called at the time of execution.
17

Program
#include <iostream.h> class Market { private : int x,y,z; public: void Display1() ,cout<< Welcome! Here is the price List << endl;void Setprice (int a, int b, int c) // function defined in class {x = a, y = b, z = c;} void Display2 () ,cout<< Price of item1 = << x<<endl; cout<< Price of item2 = << y<<endl; cout<< Price of item3 = << z<<endl; } }; void main() { Market L1; L1.Setprice (4,6,2); // Object L1 is initialized by function // setprice() L1. Display1(); // Functions called by using dot operator. L1.Display2(); }

18

initializing public data members

#include <iostream.h> class Rect { // beginning of class public: int x ,y; // data declared public int Area( ) {return x*y; } }; // End of class int main() { Rect R1; //R1 is an object of class Rect R1.x = 8; // accessing data members directly R1.y = 5; cout << Area = << R1.Area()<<endl; cout << Length = << R1.x <<endl; cout<< Width = << R1.y << endl; return 0 ; }
19

CLASS WITH AN ARRAY AS DATA MEMBER

The class data or functions may have arrays. In the following program the private data is an array. #include <iostream.h> class List { private : //Access label private int x[4]; // Array data public: void Display1() // Definition of function Display1() ,cout<< Welcome To This Market << endl; cout << Here is the price List <<endl;void Setprice (int x [4] ); void Display2() // Definition of function Display2() {for (int i = 0; i<4; i++) cout<< Price of item <<i+1<< = << x*i+<<endl; }; // End of class
20

void List ::Setprice (int a[4] ) // Definition of Setprice () { for ( int j = 0; j< 4; j++) x[j] = a [j] ; } void main() { List L1; // L1 is an object of class List int P[4] = {6,5,4,8} ; L1.Setprice(P) ; // P is const pointer to the array L1. Display1(); L1.Display2(); }

21

CLASS WITH AN ARRAY OF STRINGS AS DATA MEMBER

#include <iostream.h> #include<string.h> class List { private : int x[4]; // Array data char Names[4][20] ; // two dimensional array public: void Display1() ,cout << Here is the Marks List <<endl;void Setmarks(int x [4] ); // Declaration of function void Setnames (char Names[4][20] ); // Declaration of function void Display2() // Function defined inside the class. {for (int i = 0; i<4; i++) cout<< Marks obtained by <<Names *i+<< = << x*i+<<endl;}; // End of class
22

void List :: Setmarks (int a[4] ) //Definition of setmarks () {for ( int j = 0; j< 4; j++) // outside the class x[j] = a [j] ;} void List:: Setnames(char b[4][20] ) //Definition of Setnames {for ( int m = 0 ; m<4; m++) // outside the class {for (int p = 0 ; p<20; p++) Names[m][p] = b[m][p] ;} } void main() { List L1; char Students [4] [20] ; cout<<Enter the names of 4 students: ; for( int i =0; i< 4;i++) cin.getline ( Students[i],20); // Reading names from keyboard cout<<Enter Marks.<< endl; int P [4]; for (int k =0; k<4;k++) cin>> P[k]; {L1.Setmarks(P) ; // Putting in an array parameter L1.Setnames (Students);} // Putting in string parameter L1.Display1(); L1.Display2(); }

23

Nesting of Member Functions

A member function of a class can be called only by an object of that class using a dot operator. However, there is an exception to this. A member function can be called by using its name inside another member function of the same class. #include <iostream> using namespace std; class set { int m, n; public: void input(void); void display(void); int largest(void); };
24

int set :: largest(void) { if(m >= n) return(m); else return(n); } void set :: input(void) { coat "Input values of m and n" \n"; cin m n; } void set :: display(void) { cout Largest value largest() \n"; } int main() { set A; A.input(); A.display(); return 0; }

// calling member function

25

CLASS CONSTRUCTOR AND DESTRUCTOR FUNCTIONS

A constructor function is a public function and has same name as that of the class. It is used to initialize the object data variables or assign dynamic memory in the process of creation of an object of the class so that the object becomes operational. Whenever a new instance or an object of the class is declared the constructor is automatically invoked and allocates appropriate size of memory block for the object. The constructor function simply initializes the object. It does not return any value. It is not even void type. So nothing is written for its type. The general characteristics of constructor functions are given below.
(i) Constructor function has same name as that of the class. (ii) It is declared as a public function. (iii) It may be defined inside the class or outside the class. If it is defined outside the class its prototype must be declared in the class body. (iv) It does not return any value, nor it is of type void. So no type is written for it. 26 (v) The constructor is automatically called whenever an object is created.

destructor
The destructor function removes the object from the computer memory after its relevance is over. For a local object the destructor is called at the end of the block enclosed by the pair of braces { } wherein the object is created and for a static object it is called at the end of main() function. It releases the memory occupied by the object and returns it to heap. The destructor function also has same name as class but it is preceded by the tilde symbol (~) and has no parameters. It is a good programming practice to provide a destructor explicitly. If it is not provided explicitly in the program it is provided by the system.

27

#include <iostream.h> class Cubicle { private: int x, y, z; public: Cubicle ( int , int, int ); //constructor prototype int volume() {return ( x*y*z);} }; // End of class Cubicle::Cubicle(int a, int b, int c ) // Constructor {x = a, y = b, z = c ; // defined outside class cout<<constructed called<<endl;int main() { Cubicle cube1(3,3,3) ; // object 1 with arguments 3,3,3 Cubicle cube2(4,5,6); //object 2 Cubicle cube3 (2,4,5); //object 3 cout << Volume of cube1 = <<cube1.volume()<<\n; cout << Volume of cube2 = <<cube2.volume()<<\n; cout << Volume of cube3 = <<cube3.volume()<<\n; return 0 ; }
28

Program

TYPES OF CONSTRUCTORS
At least one parameter should be different or at least of different type. The different types of constructors are listed below. (i) Default Constructor (ii) Parameterized Constructor (iii) Copy constructor Default constructor A constructor that accepts no parameters is called the default constructor. The default constructor for class A is A::A(). If no such constructor is defined, then the compiler supplies a default constructor.

29

Parameterized Constructors
The constructors that can take arguments are called parameterized constructors. #include <iostream.h> class integer{ int m, n; public: integer(int, int); // constructor declared void display(void) { cout<<m = <<m<<\n; cout<<n = <<n<<\n; } }; integer :: integer(int x, int y) // constructor defined { m = x; n = y; }

30

int main() { integer int1(0,100); // constructor called Implicitly integer int2 = integer(25, 75); //constructor called explicitly cout "\nOBJECT1 "\n;int1.display(); cout "\n08JECT2 \n; int2.display(); return 0; }
31

Copy constructor
A constructor can accept a reference to its own class as a parameter. Program of all types of constructors #include <iostream.h> class Cubicle { private: int x, y, z; public: Cubicle () { x = 3, y = 4, z = 2 ; // default constructor cout << Default constructor called.;~ Cubicle () { cout<< Destructor called to remove object.\n; }
32

Cubicle (int a, int b, int c ){x = a, y = b , z= c; cout << Parametric constructor called. ;Cubicle (Cubicle & cubeA) // copy constructor definition { x = cubeA.x , y = cubeA.y , z = cubeA.z ; cout << \nCopy constructor called. ;int volume() {return ( x*y*z);} // definition of function volume }; // End of class int main() {{ Cubicle cube1; //scope of cube1 is this program block{} cout << \nVolume of cube1 = <<cube1.volume() <<\n ;Cubicle cube2(6,5,4) ; // Scope main() cout << \nVolume of cube2 = <<cube2.volume(); { Cubicle cube3 (cube2) ; //Scope of cube3 is this block {} cout << \nVolume of cube3 = << cube3.volume( )<<\n;return 0 ; }
33

THE this POINTER

The word this is a keyword of C++ and is the name of pointer to an object of a class. When an object is created, the compiler creates this pointer which keeps the address of the object. Pointer this is not a part of object but object has access to it or we can say an object has access to its own address. When the object calls a member function of the class, this pointer becomes implicit argument of the function and the function processes the data of the object.
#include <iostream.h> class Cuboid { public: Cuboid(int L,int W,int H ){this ->x=L ,(*this).y=W ,this->z=H;} // the above function is constructor int surface_area( ); int volume( );
34

void Display1() // Displays private data of object. ,cout <<x = <<this->x <<, y = <<this->y << , z = <<(*this).z <<endl;void Display2() {cout << this<<endl; } // gives value of this private: int x ,y, z; // private data }; // end of class int Cuboid::surface_area() // definition of surface area {return 2*(x*y +y*z +z*x);} int Cuboid::volume() // definition of volume {return x*y*z ;} int main() { Cuboid C1(5,6,4), C2(7,8,5) ; // C1 and C2 are two objects C1.Display1(); C1.Display2(); // value of this pointer for C1 cout <<&C1<<endl; // Address of C1 C2. Display1(); C2. Display2(); // value of this for C2 cout << &C2<<endl; // Address of object C2 cout << Volume of cuboid C1 = <<C1.volume()<<\n; cout<< Volume of cuboid C2 = << C2.volume()<<\n; cout<<Surface area of C1 = << C1.surface_area()<<\n; cout<<Surface area of C2 = << C2.surface_area()<<\n; return 0 ; }
35

FRIEND FUNCTION TO A CLASS

A friend function to a class has access to all the members of the class whether these are private, protected or public . This characteristic makes it useful in many applications, particularly, in overloading of operators. However, the free access to all the members of a class goes against its frequent use, because, it dilutes the information hiding capability of the class. Since friendship is granted by the class, therefore, the class declaration should contain the declaration that the function is friend of the class. A friend function is not a member function of the class in which it is declared as friend, and hence a friend function is defined outside the class body. It starts with keyword friend followed by the type of function and identifier (name) for the function which is followed by a list of types of parameters of the function enclosed in parentheses (). It ends with a semicolon.
36

The following points should be noted about friend functions to classes. 1. If a function F is friend to class B, then F can access all the members of class B. 2. The friendship is granted by the class and not extracted by the function. Therefore, the friend function has to be so declared in the body of the class as illustrated above. 3. Function prototype of friend function preceded by keyword friend is declared inside the class body but the function is defined outside the class body. 4. Friend function is not a member function of the class to which it is friend. Therefore, the scope resolution operator is not required while defining the friend function outside the class body. 5. A class may have any number of friend functions. And a function may be friend to any number of classes. 6. A friend function may be declared any where in the class. The access specifiers, i.e. public, protected or private do not affect a friend function.
37

Program
#include <iostream.h> class Rect { friend int Area(const Rect &a); // friend function Area int x,y; // private by default public: Rect (int L, int W){ x = L,y = W;} // constructor function }; // end of class int Area (const Rect &b) // definition of friend function {return b.x*b.y;}; // scope resolution operator not needed int main() { Rect R1(5,6), R2(3,4) ; //declaration of two objects R1 and R2 cout << Area of R1= << Area ( R1 ) <<\n; cout << Area of R2 = << Area ( R2 )<<\n; return 0 ; }
38

ONE FUNCTION FRIEND OF MANY CLASSES

A function may be friend to many classes. This is illustrated in the following program in which a function Display() is declared friend to two classes, i.e. class Sqr and class Rect. #include <iostream> using namespace std; class Sqr; //pre-declaration of class class Rect { // class Rect int x,y; // private by default public: Rect ( int A, int B) { x = A, y = B;} int area ( ) {return x*y;} friend void Display ( Rect R, Sqr S ); // friend function to Rect };

39

class Sqr { // class Sqr int side; // private by default public: Sqr (int C){ side = C;} int Area ( ) {return side*side;} friend void Display (Rect R , Sqr S ); // friend function to Sqr }; //end of class void Display ( Rect R, Sqr S) // Definition of friend function ,cout <<Area of rect = << R.area()<<endl; cout <<Area of Square = << S.Area()<< endl;int main() {Rect R1(10,5); Sqr S1 (10); Display ( R1, S1 ); return 0 ; }
40

FRIEND CLASSES
When all or most of the functions of a class need access to data members and function members of another class, the whole class may be declared friend to the class. For instance, if the functions of a class say class A need to access the public, private and protected members of another class say class B, the class A may be Class B { friend class A; //declaration that class A is friend of B Private: statements friend class C; //declaration that class C is friend of B public: Other_statements; };
41

CHARACTERISTICS OF FRIEND CLASSES

The following characteristics of friend classes should be noted. 1. If a class A is a friend of class B, then functions of A can access all the members of B. 2. If class A is a friend of class B, it does not mean that class B is also friend of class A. The C++ friendship is not reciprocal. 3. Friendship is granted by the class whose members are to be accessed. If a class A is friend of class B, it has to be so declared in the definition of class B. 4. If class A is friend of class B and class B is friend of class C, it does not mean that class A is also friend of class C or class B is friend of class A or class C is friend of class B or class A. The C++ friendship is neither transmitted nor it is reciprocal. 5. A class may be friend to more than one class. And a class may have more than one class as friends. There is no limit on the number of friends of a class.

42

Program
#include <iostream.h> class Cuboid { friend class paint; // Declaration of friend class public: void sides(int , int, int); int Area(); int volume(); int x , y, z; }; //end of class Cuboid void Cuboid:: sides (int L, int W, int H ) {x = L, y = W,z = H; } // Setting the sides of Cuboid int Cuboid::Area() //Definition of area {return 2*(x*y +y*z +z*x);}

43

int Cuboid::volume() // definition of volume {return x*y*z ;} class paint{ //declaration of friend class paint private: int R; public: paint () { R = 1;} // default constructor paint ( int S) { R = S;} // parametric constructor Cuboid C; // C is the object of class Cuboid int area (){return C.Area ();} int cost(int R , Cuboid C ) // R is the rate and C is object {return R* C.Area () ;} // of Cuboid. cost() is a function }; int main() {Cuboid C1 ; // C1 is object of class Cuboid C1.sides (5,6,5 ); paint P1 ; // P1 is object of class paint int k = 4; cout << Volume of C1 = <<C1.volume()<<\n; cout<<Surface area of C1 = <<C1.Area()<<\n; cout<<Cost of painting P1 = << P1.cost(k, C1)<<\n; return 0 ; }
44

POINTER TO A CLASS
Pointer to a class may be declared in the same way as it is done for integer or double numbers. Let us have a class by name List and let L1 be an object of this class. Let ptr be the pointer to the class. For declaration of pointer to List we may write the code as below. List L1 ; // declaration that L1 is an object of class List List *ptr; // declaration of pointer to List ptr = &(List) L1; // assignment of value to ptr The last line may as well be written as ptr = &List (L1);

45

#include <iostream.h> class List { private : int x,y; //let x = the no of items, y = price of one item. public: void Setdata (int a, int b ) //A public function to access x,y. {cout << Enter number of items : ; cin >>a ; cout <<Enter price of one item : ; cin >> b ; x = a, y = b; } void Display1 ( ) {cout<<Number of items = <<x <<endl; } void Display2 () {cout<<Price of each item = <<y <<endl ; } void Display3 () {cout<<Cost of <<x<< items at the rate of <<y<<per item = <<x*y<<endl;} }; // End of class void main() { List L1 ; List *ptr; // pointer to List ptr = &(List) L1; // assigning address of class object int i,j; (*ptr).Setdata (i,j); //values to be assigned by user ptr -> Display1 (); // (*ptr) and ptr-> are equivalent. ptr -> Display2(); (*ptr).Display3(); }
46

POINTERS TO FUNCTION MEMBERS OF A CLASS

#include <iostream.h> class Rect { int x ,y; // private by default public: void Setsides ( int L,int W ){ x = L ,y = W ;} int Area( ) // Definition of function Area {return x*y;} }; // end of class int main() { Rect R1,R2,R3; void (Rect:: *ptrSet)(int,int) = & Rect :: Setsides; (R1.*ptrSet) (20,15); cout << Area of R1 = << R1.Area()<<endl; (R2.*ptrSet) (20,30); //object R2 calls function by its pointer cout << Area of R2 = << R2.Area()<<endl; Rect *ptr3 = &R3; // declaring pointer to object R3 of class (ptr3 ->*ptrSet)(16,10); //calling function by pointer to object cout << Area of R3 = << R3.Area()<<endl; return 0 ; }
47

POINTER TO DATA MEMBER OF A CLASS

#include <iostream.h> class Rect { friend int Area(Rect a); // friend function int x, y; // data members private by default public: friend double cost(Rect a, double); // another friend function Rect (int L,int W){ x = L,y = W;} // constructor }; // end of class int Area (Rect b) // Definition of area using pointers { int Rect :: *ptrx = &Rect :: x; //ptrx is pointer for x int Rect :: *ptry = &Rect :: y; // ptry is pointer for y Rect *ptrb = &b; // ptrb is pointer to object b return b.*ptrx * b.*ptry ;}; double cost(Rect b , double m) {return b. x* b. y * m ;} int main() { double n = 4.5; Rect R1(5,6), R2(3,4) ; cout << Area of R1= << Area (Rect (R1)) <<\n; cout << Area of R2 = << Area (Rect (R2))<<\n; cout << Cost for R1 = <<cost (Rect (R1),n) <<\n; return 0 ; }
48

STATIC DATA MEMBERS OF A CLASS

Objects of a class keep their own copy of data members of class. In certain situations a part of data may be same for all objects of a class. In such cases instead of every object keeping an individual copy of this data, it would be prudent if one copy of the data is shared by all the objects of class, because, this would save memory space, particularly, when the common data is large. For such applications the common data may be declared static. The static data may be declared under any one of the three access specifiers, i.e. public, protected or private. A public static data member may be accessed directly through any object of the class because it is same for all the objects. The code comprises the object name followed by dot operator followed by name of data member. Static data member declared private or protected may be accessed through the corresponding public functions of the class.

49

#include <iostream.h> class Cuboid { public: static int x; // x declared static Cuboid( int W ): y(W) {} // constructor static void Display ( ) // static function ,cout << Height of all objects is = << z <<endl;int surface_area( ); int volume( ); private: int y; static int z ; // static variable }; // end of class int Cuboid :: x = 10; int Cuboid :: z = 5; int Cuboid::surface_area() {return 2*(x*y +y*z +z*x);}
50

int Cuboid::volume() {return x*y*z ;} int main() { Cuboid C1(6), C2(3) ; cout << C1.x = << C1.x << , C2.x = <<C2.x <<endl; Cuboid :: Display( ); // function call without an object cout << Volume of cuboid C1 << C1.volume()<<\n; cout<< Volume of cuboid C2 = << C2.volume()<<\n; cout<<surface area of C1 = << C1.surface_area()<<\n; cout<<surface area of C2 = << C2.surface_area()<<\n; return 0 ; }

51

STATIC FUNCTION MEMBER OF A CLASS

A function member of a class may also be declared static provided its arguments are also declared static or if it does not access any non-static member of the class. The pointer this associated with every object of class is applicable only to non-static function members of the class. The static function members of class do not have this pointer. #include <iostream.h> class Cuboid { public: Cuboid(int H):z(H) {} //constructor static int Base_area (){ return x*y;} // static function int surface_area( ); int volume( ); private: static int x , y; // x and y declared static int z ; }; // end of class 52

int Cuboid :: x = 5; // static data member int Cuboid :: y =8 ; // static data member int Cuboid::surface_area() // definition of surface_area () {return 2*(x*y +y*z +z*x);} int Cuboid::volume() // definition of function volume() {return x*y*z ;} int main() { Cuboid C1(5), C2(8) ; cout<<Base area of all objects = << Cuboid::Base_area()<<endl; cout << Volume of cuboid C1 << C1.volume()<<\n; cout<< Volume of cuboid C2 = << C2.volume()<<\n; cout<<Surface area of C1 = << C1.surface_area()<<\n; cout<<Surface area of C2 = << C2.surface_area()<<\n; return 0 ; }
53

Local Classes
Classes can be defined and used inside a function or a block. Such classes are called local classes. Examples:
void test(int a) // function { ......... ......... class student // local class { ............... ............... //Class definition }; ............. student s1 (a); // create student object .............. // use student object }

Local classes can use global variables (declared above the function) and static variables declared inside the function but cannot use automatic local variables. The global variables should be used with the scope operator (::). There are some restrictions in constructing local classes. They cannot have static data members and member functions must be defined inside the local classes. Enclosing function cannot access the private members of a local class. However, we can achieve this by declaring the enclosing function as a friend.
54

DYNAMIC MEMORY MANAGEMENT FOR CLASS OBJECTS

OPERATORS NEW AND DELETE The operator new allocates memory from the free store called heap while the operator delete does just the opposite, it releases the memory by deleting the object. The released memory is added to heap for other uses. For allocation of memory for an array we have the operator new[] and corresponding operator delete[] for removing the array and releasing the memory. For class objects new may be used for allocating memory for single object while new[] may be used for creating an array of class objects. Similarly single object is removed from memory by operator delete and array of objects are removed by delete[] operator. It must be noted that when new [] is used for allocation of memory, for releasing the memory we must use delete [] and not simply delete. For example if you have created an array of objects by new[] and if you use simply delete to remove the array, it will only delete the first object of the array, the remaining objects would not get deleted. So it will be only partial release of memory.
55

#include <iostream.h> class List { private : double x ; // x = weight in kg, y = price of one kg. double y; public: void Setdata (double a, double b ) {x = a; y = b; } void Display ( ) ,cout<< Weight = ; cin >> x; cout<< Price = ; cin >>y; cout<< Cost of <<x<<kg at the rate of <<y<< per kg = <<x*y<<endl;}; void main() {double i,j; List *ptr= new List ; // use of new operator (*ptr).Setdata (i,j); ptr -> Display (); // (*ptr) and ptr-> are equivalent. delete ptr; }
56

#include <iostream.h> class List { private : int x,y; // x = the no of items, y = price of one item. public: void Setdata (int a, int b ) {x = a; y = b; } void Display ( ) { cout<< Number of items = ; cin >> x; cout<< Price of each item = ; cin >>y; cout<< Cost of <<x<< items at the rate of <<y<< per item = <<x*y<<endl;}; // End of class void main() { List *ptr= new List[3]; //pointer to List for (int k=0; k<3; k++) ,cout<< For item Number <<k+1<<endl; int i=0,j=0; //for user input of data (*ptr).Setdata (i,j); ptr -> Display ();} // (*ptr) and ptr-> are equivalent. delete[]ptr; }
57

REFERENCES
Reference for a variable is also an alias or just another name for the same variable. The variable name and its reference-name both point to the same block of memory where the value of variable is stored. You must note that any change in the value of reference also changes the value of variable. For creating a reference first write the type of the variable for which the reference is being created then write reference operator (&) followed by the name or identifier for the reference. Name of reference may be decided in the same way as it is done for any variable.

58

#include <iostream.h> int main() {int n = 100 ; double Weight = 35.6; char ch = S; int& Count = n ; // Count is a reference to n. double& W =Weight; // W is a reference to weight. char& T = ch; // T is reference to ch. cout<<n = <<n<< \t&n = <<&n <<\n; cout<<Count = <<Count<< \t &Count = <<&Count << endl; cout<< Weight = <<Weight << , &Weight = << &Weight<<\n; cout<< W = << W<< \t &W = << &W<<\n\n; cout<<ch = <<ch <<\t T = << T <<endl; T = Z; n = 50; //The value of reference n is changed to 50 W = 12.5; // The value of reference W is changed to 12.5 cout<< n = <<n << \tCount =<< Count <<endl; cout << W = << W<< \tWeight = << Weight << endl; cout << ch = << ch << \t T = << T << endl; return 0; } 59

NESTED CLASSES
A class may be declared inside another class. The access specifiers work on nested class in the same way as they act on other functions. In the following illustrative program class Z is declared in class Y in the public domain and class Y is in turn is declared in class X in public domain. All the three classes have private data for which appropriate constructor functions are provided in each class. The objects of each of these are declared in the main() and values assigned to them.

60

#include <iostream> using namespace std; class X {private: int x ; public: X (int a ) {x = a;} int getx () { return x ;} class Y // nested class Y declared in class X {private: int y; public : Y( int b ) {y = b;} int gety (){return y ;} class Z // class Z declared in class y { private: int z ; public : Z (int c ) { z = c;}
61

int getz () { return z;} }; // end of class Z }; // end of class Y }; // end of class X int main() { X x_object (5); X::Y y_object (10); X::Y::Z z_object (20); cout<<x_object = <<x_object.getx() <<endl; cout << y _object = << y_object.gety()<<endl; cout<< z_object = <<z_object.getz()<<endl; return 0 ; }

62

THE inline FUNCTIONS

When a program consists of a large numbers of functions considerable time of computer is wasted in the function call routine that it has to follow. When a function is called, the processor saves the present status of the current program, evaluates the function and returns to resume the ongoing program. In case of frequently occurring small functions the overburden of function call may be considerable and can make the program inefficient. So the concept of inline function is evolved. We define the function only once in the program. It is preceded with key word inline as illustrated below. The compiler substitutes the code of the function where ever it is called in the program. An illustration of an inline function definition is given below. inline int Cube(x) {return x*x*x ;}

63

 The inlining does not work for the following situations : 1. For functions returning values and having a loop or a switch or a goto statement. 2. For functions that do not return value and having a return statement. 3. For functions having static variable(s). 4. If the inline functions are recursive (i.e. a function defined in terms of itself). 1. 2. 3. 4. The benefits of inline functions are as follows: Better than a macro. Function call overheads are eliminated. Program becomes more readable. Program executes more efficiently.

64

THE inline FUNCTIONS

#include<iostream.h> inline int Power(int x, int n) // inline function { int P = 1; // definition for (int i =0; i<n ; i++) P *=x; return P; } int main() { int A = 2, B = 3, C =5; cout<< A square = << Power(A,2); // function call cout << \nB to the power 4 = << Power(B,4); // function call cout<<\nC to the power 3 = << Power(C,3)<<endl;//function call return 0; }
65

Function Overloading

Function overloading is the process of using the same name for two or more functions. The secret to overloading is that each redefinition of the function must use either different types of parameters or a different number of parameters. It is only through these differences that the compiler knows which function to call in any given situation
66

#include <iostream.h> int myfunc(int i); // these differ in types of parameters double myfunc(double i); int main() { cout << myfunc(10) << " "; // calls myfunc(int i) cout << myfunc(5.4); // calls myfunc(double i) return 0; } double myfunc(double i) { return i; } int myfunc(int i) { return i; }
67

Default Function Arguments

A function can be called without specifying all its arguments. The function declaration must provide default values for those arguments that are not specified. A C++ function prototype can declare that one or more of the functions parameters have default values. When a call to the function omits the corresponding arguments, the compiler inserts the default values where it expects to see the arguments.

68

Garbage collection
Garbage collection is an automatic memory management feature in many modern programming languages, such as Java and languages in the .NET framework. In older programming languages, such as C and C++, allocating and freeing memory is done manually by the programmer. Memory for any data that can't be stored within a primitive data type, including objects, buffers and strings, is usually reserved on the heap. When the program no longer needs the data, the programmer frees that chunk of data with an API call. Because this process is manually controlled, human error can introduce bugs in the code. Memory leaks occur when the programmer forgets to free up memory after the program no longer needs it.
69

70