Shahid Bajwa
ROLL# I-4894209
CELL NO 03454666382
INTRODUCTION
Procedural programming
Conventional programming using high level languages such as COBOL, C and FORTAN are known as procedural oriented programming. Procedural programming employs top down programming approach where a program is viewed as a sequence of task to be performed. A number of functions are written to implement these tasks
Characteristics of POP
1. Emphasis is on doing things.
2. Large program are divided into smaller one known as function.
3. Most of the functions share global data.
4. Functions transfer data from one from to another.
5. Employs top down approach in program design.
6. Data move openly around the system from function to function.
Limitation of POP against OOP
1. POP emphasis is on doing things (algorithm) but OOP emphasis is on data rather than procedure.
2. In a multi-function program many important data items are placed as global so that they may be accessed by all the functions. Global data are more vulnerable to an inadvertent change by a function. This provides an opportunity for bugs to creep in.
3. The procedural approach doesn't model real world problems very well. This is because functions are action oriented and do not really corresponds to the elements of the problem.
4. In POP functions transform data from one form to another but in OOP new data and functions can be easily added whenever necessary.
5. Data move openly around the system from functions to functions in POP but in OOP data is hidden and cannot be accessed by external functions.
OBJECT ORIENTED PROGRAMMING (OOP)
OOP as an approach that provides a way of modularizing programs by creating partition memory area for both data and function those can be used as templates for creating copies of such modules on demand. Object is considered to be partitioned area of computer memory that stores data and set up operations that excess data. Object can be used in variety of different program without any modification.
FEATURES OF OOP'S:
1. Emphasis is on data rather than procedure.
2. Program is divided into objects.
3. Data structure is designed such that they characterize the objects.
4. Data is hidden and cannot be accessed by external function.
5. Function that operates on the data of objects is tied together in data structure.
6. Object may communicate with each other through functions.
7. New data and function can be easily added whenever necessary.
8. Follow bottom up approach.
OBJECT ORIENTED LANGUAGE:
OOL can be classified into two categories:
1. Object based programming language.
2. Object oriented programming language.
Object based programming language is the style of programming that primarily supports encapsulation and object identity. Its features are:
1. Data encapsulation.
2. Data hiding and access mechanism.
3. Automatic initialization and clear up of objects.
4. Operator loading.
Object oriented programming language incorporates all of object based programming features along with two additional features namely inheritance and dynamic binding.
BASIC CONCEPTS OF OOP
OOP's should include the following things:
1. Object
2. Class
3. Data abstraction and encapsulation
4. Inheritance
5. Polymorphism
6. Dynamic
7. Message passing
1. Object:
· Basic run time entities in object oriented system.
· Program object should be present such that they match closely with real world object
· Each object contains data and code object to manipulate data
| Object: student |
| Data: |
| Name DOB Marks |
| Function: |
| Total(); Average(); Display(); |
2. Class:
Class is the collection of object of similar type.
E.g. mango, apple and orange are the object of class fruit.
3. Data abstraction and encapsulation:
· The wrapping up of data and functions into a single unit (called class) is known as encapsulation.
· Data encapsulation is the most striking feature of a class.
· The data is not accessible to the outside world and only those functions which are wrapped in the class can access it. These functions provide the interface between objects, data and the program. This encapsulation to the data from direct access from program is called data hiding or information hiding.
· Abstraction refers to the act of representing essential features without including the background details or explanation.
· Class used the concept of abstraction and are defined as list of abstraction attributes such as size, weight cost function to operate on these attribute.
· Since the classes use the concept of data abstraction they are known as abstract data type (ADT).
4. Inheritance:
· Inheritance is the process by which objects of one class acquires the properties of objects of another class.
· It supports the concept of hierarchical classification.
· The concept of inheritance provides the idea of reusability.
5. Polymorphism:
· It is a Greek term means ability to take more than one form.
· An operation may exhibit different behavior in different instances. The behavior depends upon the types of data used in the operation.
· Polymorphism is extensively used in implementation of inheritance.
Types: 1. Operator overloading
2. Function overloading
1. Operator overloading
· The process of making an operator to exhibit different behavior in different instances is known as operator overloading.
· For two numbers the operator '+' will generate a sum.
· If overloaded the operands in strings will produce the third string by concatenation. For e.g. Hello + world = Helloworld
2. Function overloading
· Using a single function name to perform different types of tasks is known as function overloading.
6. Dynamic binding:
Binding refers to the linking of a procedure called to the code to be executed in response to the call.
Dynamic binding also known as late binding means that the code associated with a given procedure called is not known until the time of the call at the run time.
It is associated with polymorphism and inheritance.
7. Message passing:
Steps involved in message passing are:
· Creating classes that define objects and their behavior.
· Creating objects from class definition.
· Establishing communication among object.
E.g. employee. salary (name)
Benefits of OOP's:
Object orientation contributes to the solution of many problems associated with the development and quality of software products. The new technology promises greater programmer productivity, better quality of software and lesser maintenance cost. It implies the concept of code reusability. The principal advantages are:
1. Through inheritance we can eliminate redundant code and extend the use of existing.
2. Classes.
3. We can build programs from the standard working modules that communicate with one another, rather than having to start writing the code from scratch. This leads to saving of development time and higher productivity.
4. The principle of data hiding helps the programmer to build secure programs that cannot be invaded by code in other parts of the program.
5. It is possible to map objects in the problem domain to those in the program.
6. It is possible to have multiple instances of objects to coexist without any interference.
7. It is easy to partition the work in a project based on objects.
8. The data centered design approach enables us to capture more details of a model in implement-able form.
9. Object oriented systems can be easily upgraded from small to large systems.
10. Message passing techniques for communication between objects makes the interface description with external systems much simpler.
11. Software complexity can be easily managed.
APPLICATION OF OOP'S:
Application of OOP's technology has gained importance in all most all areas of computing including real time business system. The promising areas are:
· Real time systems.
· Simulation and modeling.
· Object oriented data base.
· Hypertext, hypermedia and expert text.
· AI and expert system.
· Neural networks and parallel programming.
· Decisions support and office automation systems.
· CIM/CAM/CAD systems.
FUNCTION
void show (); //function declaration
main ()
{
show (); //function call
}
void show ()
{
--------- //function body
---------
---------
}
main ()
{
__________
__________
}
In C, above statement is valid because the main () in C dose not return any value i.e. the function is void type.
In C++, the main () function return a value of type int to the operating system. Therefore explicitly define main () function as the matching of
int main ()]
Function prototype
· Gives the compiler the details about the functions such as the number and the type of return values.
· It is declaration statement
type function_name (argument_list):
E.g. int area (int x, int y);
float volume (int x, int y, int z);
· Function can also declared as empty argument list as in the following example:
Void display ();
It means that the function doesn't pass any parameters. It is similar to
Void display (void);
PASSING VARIABLES IN A FUNCTION:
1. PASSING BY VALUE.
2. PASSING BY REFERENCE.
3. PASSING BY ADRESS.
1. Passing by value
In it, value is passed directly into a function and function creates new variables to hold the values of these variable argument then the actual arguments remained unaltered.
//pass by value
#include<iostream.h>
void swap(int a,int b)
{
int temp=a;
a=b;
b=temp;
cout<<"\na="<<a<<" and b="<<b;
}
void main()
{
int x=9,y=7;
cout<<"\n\n\nbefore swapping x="<<x<<" and y="<<y;
swap(x,y);
cout<<"\nafter swapping x="<<x<<" and y="<<y;
}
/*output
before swapping x=9 and y=7
a=7 and b=9
after swapping x=9 and y=7 */
2. Pass by address:
It is done through the use of pointer.
//pass by adress
#include<iostream.h>
#include<conio.h>
void swap(int *a,int *b)
{
int temp=*a;
*a=*b;
*b=temp;
cout<<"\na="<<*a<<" and b="<<*b;
}
void main()
{
int x=9,y=7;
clrscr();
cout<<"\n\n\nbefore swapping x="<<x<<" and y="<<y;
swap(&x,&y);
cout<<"\nafter swapping x="<<x<<" and y="<<y;
getch();
}
/*output
before swapping x=9 and y=7
a=7 and b=9
after swapping x=7 and y=9 */
3. Pass by reference
We can pass parameter in C++ by reference. While we pass arguments by nickname, the formal arguments in the called function become aliases (nickname) to the calling function i.e. function is actually working on original data.
//pass by reference
#include<iostream.h>
#include<conio.h>
void swap(int &a,int &b)
{
int temp=a;
a=b;
b=temp;
cout<<"\na="<<a<<" and b="<<b;
}
void main()
{
int x=9,y=7;
clrscr();
cout<<"\n\n\nbefore swapping x="<<x<<" and y="<<y;
swap(x,y);
cout<<"\nafter swapping x="<<x<<" and y="<<y;
getch();
}
/*output
before swapping x=9 and y=7
a=7 and b=9
after swapping x=7 and y=9 */
CALLING FUNCTION:
· CALL BY VALUE.
· CALL BY REFERENCE.
1. Call by value:
· Function call passes arguments by value
· Called function creates new set of variables and copies the values of argument into them.
· Function dose not have access to the actual variables in the calling program and can only work on the copies of values.
//call by value
#include<iostream.h>
#include<conio.h>
int sum(int a,int b)
{
int temp;
temp=a+b;
return temp;
}
void main()
{
int x,y,z;
clrscr();
cout<<"\nenter x "<<endl;
cin>>x;
cout<<"\nenter y "<<endl;
cin>>y;
z=sum(x,y);
cout<<"\nsum="<<z;
getch();
}
/*output
enter x
(let) 4
enter y
(let) 5
sum=9
*/
2. Call by reference:
It is used to alter the values of the original variables in the calling program. Function actually works on aliases.
//call by reference
#include<iostream.h>
#include<conio.h>
void swap(int &a,int &b)
{
int temp=a;
a=b;
b=temp;
cout<<"\na="<<a<<" and b="<<b;
}
void main()
{
int x=9,y=7;
clrscr();
cout<<"\n\n\nbefore swapping x="<<x<<" and y="<<y;
swap(x,y);
cout<<"\nafter swapping x="<<x<<" and y="<<y;
getch();
}
/*output
enter x
(let) 4
enter y
(let) 5
sum=9
*/
RETURN IN FUNCTION:
- RETURN BY VALUE.
- RETURN BY REFERENCE.
1. Return by value:
Syntax:
int sum(int x, int y)
{
int z=x+y;
return z;
}
2. Return by reference:
Syntax:
int & max(int &x, int &y)
{
if (x>y)
return x;
else
return y;
}
- Return type of max () is int&.
- The function return reference to x or y (and not the value)
- The function call such as max (a, b) will yield a reference to either a or b depending on their values.
- max (a, b) =-1; is legal and assigns -1 to a if it is large otherwise -1 to b.
Q. Write a program that illustrate pass by reference and return by reference.
#include<iostream.h>
#include<conio.h>
int &max(int &a,int &b)
{
if(a>b)
return a;
else
return b;
}
void main()
{
int x,y;
clrscr();
cout<<"enter the first value ";
cin>>x;
cout<<"\nenter the second value ";
cin>>y;
cout<<"\nThe greater is "<<max(x,y);
getch();
}
/*output
enter the first value (let)5
enter the second value (let)4
The greater is 5
*/
TYPES OF FUNCTION:
- PASS AND RETURN
- NO PASS BUT RETURN
- PASS BUT NO RETURN
- NO PASS AND NO RETURN
1. Pass and return
//value and return
#include<iostream.h>
#include<conio.h>
#include<math.h>
float sum(int x, int n)
{
float sum=0;
for(int i=1;i<=n;i++)
sum+=(float)pow(x,i)/i;
return sum;
}
void main()
{
int x,n;
clrscr();
cout<<"enter value for x ";
cin>>x;
cout<<"how many terms ";
cin>>n;
cout<<"sum="<<sum(x,n);
getch();
}
/*
output
enter value for x (12)
how many terms (2)
sum=84
*/
2. No pass but return
/no value with return
#include<iostream.h>
#include<conio.h>
#include<math.h>
float sum()
{
int x,n;
float sum=0;
clrscr();
cout<<"enter value for x";
cin>>x;
cout<<"how many terms";
cin>>n;
for(int i=1;i<=n;i++)
sum+=(float)pow(x,i)/i;
cout<<sum;
return sum;
}
void main()
{
cout<<"sumis"<<sum();
getch();
}
3. Pass but no return:
//value with no returns
#include<iostream.h>
#include<conio.h>
#include<math.h>
void sum(int x, int n)
{
float sum=0;
clrscr();
for(int i=1;i<=n;i++)
sum+=(float)pow(x,i)/i;
cout<<"sum is"<<sum;
getch();
}
void main()
{
int x,n;
clrscr();
cout<<"enter value for x";
cin>>x;
cout<<"how many terms";
cin>>n;
sum(x,n);
getch();
}
4. No pass and no return
//no value no return
#include<iostream.h>
#include<conio.h>
#include<math.h>
void sum()
{
int x,n;
float sum=0;
clrscr();
cout<<"enter value for x";
cin>>x;
cout<<"how many terms";
cin>>n;
for(int i=1;i<=n;i++)
sum+=(float)pow(x,i)/i;
cout<<sum;
getch();
}
void main()
{
sum();
}
SCOPE RESOLUTION OPERATOR (::):
C++ supports a mechanism to excess a global variable from a function in which a local variable is defined with the same name as a global variable. It is achieved using scope resolution operator.
Syntax: :: global variable
It directs the compiler to excess the global variable instead of local variable with the same variable name.
//use of scope resolution operator
#include<iostream.h>
#include<conio.h>
int x=5; //global variable
void main()
{
int x=10; //local variable
clrscr();
cout<<"local varable is "<<x;
cout<<"\nglobal variable is "<<::x;
getch();
}
/*
output
local variable is 10
global variable is 5
*/
REFERENCE VARIABLE:
A reference variable provides alias that is alternative name of the variable i.e. previously defined.
// example of reference variable
#include<iostream.h>
#include<conio.h>
void main()
{
int x=5;
clrscr();
int &y=x; //y is alias of x
cout<<"x="<<x;
y++;
cout<<"\nx="<<x;
getch();
}
/*
output
x=5
x=6
*/
INLINE FUNCTION:
While inline function is called the inline code of the function is inserted at the place of the function call and compiled with other source code together. By using inline function execution time is reduced because there is no transfer and return back to control. But if function have long code inline function isn't suitable.
· It saves memory.
· The function needn't be duplicated in memory
· It is analogous to macros in C. the major drawback with macros is that they are not really function and therefore the usual error checking doesn't occur during compilation.
Some of situations where inline expansion may not work are:
1. For function returning values if a loop, a switch or goto exists.
2. For functions not returning values, if a return statement exists.
3. If function contain static variables.
4. If inline functions are recursive.
//example of inline
#include<iostream.h>
#include<conio.h>
inline float mul(float x, float y)
{
return(x*y);
}
inline double div(double p,double q)
{
return (p/q);
}
void main()
{
float a=12.5;
float b=9.82;
clrscr();
cout<<"multiplication="<<mul(a,b);
cout<<"\ndivision="<<div(a,b);
getch();
}
/*
output
multiplication=122.75
division=1.272912
*/
DEFAULT ARGUMENTS:
· C++ allows us to call a function without specifying all its arguments. In such case the function assigns a default value to the program which doesn't have a matching argument in the function call.
· Default values are specified when the function is declared.
· We must add the default from right to left.
//example of default argument
#include<iostream.h>
#include<conio.h>
void tot(int m1=40,int m2=40,int m3=40);
void main()
{
clrscr();
tot(); //display 120
tot(45); //display 125
tot(45,55); //display 140
tot(75,85,96); //display 226
getch();
}
void tot(int m1,int m2,int m3)
{
cout<<"\ntotal marks="<<m1+m2+m3;
}
/*
output
display 120
display 125
display 140
display 226
*/
FUNCTION OVERLOADING:
Function overloading refers to the use of same function name for different task. While an overloaded function is called the function with matching argument and return type is invoked.
int max(int, int);
int max(int, int, int);
float max(float, float);
A function call first matches the prototype having the same number and type of arguments and then calls the appropriate function for execution. A best match must be unique.
The function selection involves the following steps:
1. The complier first tries to find an exact match in which the type of actual arguments are the same and used that function.
2. If an exact match is not found, the complier uses integral promotion to the actual arguments such as-char to int float to double to find match.
3. When either of them fails, the complier tries to use built in conversion (the impulsive assignment conversion) to the actual arguments and then uses the function where match is unique. If the conversion is possible to have multiple messages then the compiler will generate the error message. E.g.
long square(long n);
double square(double x);
A function call such as square(10) will cause an error because int arguments can be converted to either long are double.
4. If all the slopes fail then the complier will try the s=user defined conversion in combination with integral promotion and built in conversion to find the unique match(). User defined conversion are often used in handling class and object.
//example of function overloading
#include<iostream.h>
#include<conio.h>
int volume(int s)
{
return(s*s*s);
}
double volume(double r, int h)
{
return(3.14159*r*r*h);
}
long volume(long l,int b, int h)
{
return(l*b*h);
}
void main()
{
clrscr();
cout<<volume(10)<<endl;
cout<<volume(2.5,8)<<endl;
cout<<volume(1001,75,15)<<endl;
getch();
}
CLASS AND OBJECT
· C++ was developed by Bjarne Stroustrup at AT and T bell laboratory USA in early 1980's
· Initial name of C++ is "C with class".
· A class is an extension of the idea of structure used in C.
· Class is a new way of creating and implanting a user defined data type.
struct student
{
char name[20];
int roll_number;
float total_number;
};
struct student s1,s2,s3;
Difference between structure and class:
- By default the member of class are private while by default the member of structure are public.
- Generally class holds both data and function and structure is used for holding data. But structure can also hold both data and function.
Bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
A class is a user-defined data type that includes different member data and associated member function to access all those data. In OOP, data and function are put in a class called as encapsulation. When defining a class we are creating a new data type that can be treated like a built in data type ( int, char, float). Generally class has two parts:
Specifying a class:
Specifying a class:
A. CLASS DECLARATION.
B. FUNCTION DEFINITION
- Class declaration:
The class declaration describes the type and scope of its members. The function definition defines how the class functions are implemented. The general syntax for class declaration:
Class class-name
{
private:
data-type variable;
-----
public:
return-type function-name(a1, a2, a3,….)
{
//function body
}
};
The class declaration is similar to struct definition. The body of class is enclosed within braces and terminated by a semicolon. The class body contains the declaratio0n of variable and function called as members. They can be grouped under two sections: 1. Private.
2. Public.
Private and public are known as visibility level. By using the keyword private we can hide data so that only member functions can access those data outside the class (non-member cannot access). The keyword public is used so that public members can be accessed by any function outside the class. In OOP, generally data are made private and functions are made public.
Defining member function
A member function can be defined in two ways:
1. INSIDE THE CLASS DEFINITION.
2. OUTSIDE THE CLASS DEFINITION.
- Inside the class definition:
The member function are defined inside the class are considered as inline function automatically (no need of keyword inline).
Void getdata (char n[], int a, float fp)
Void showdata()
- Outside the class definition:
The member functions that are declared inside the class can be defined outside the class definition. The function definition outside the class definition consists of the function header with associated class.
Syntax:
Return-type class-name::function-name(a1,a2)
{
//function body
}
MEMORY ALLOCATION:
When a class is declared memory is not allocated to the data member of a class but when an object is created memory is allocated to its data member but not to member function. The member functions are same for all objects and there is no need of allocating a separate copy for each and every object created using the same class specification. Separate storage is allocated for every objects data members since they contain different values. However different object share the same member function among them.
STATIC DATA MEMBER:
A data member of a class can be qualified as static. The properties of static member variables as follows:
· It is initialized to zero when the first object of its class is created. No other initialization is permitted.
· Only one copy of that member is created for the entire class and is shared by all the object of that class no matter how many object is created.
· It is visible only within the class but its lifetime is in the entire program.
//Example of static data member
#include<iostream.h>
class item
{
static int count;
int number;
public:
void getdata (int a)
{
number=a;
count++;
}
Note:Int item::count;
This is necessary because static data members are stored separately rather than as a part of object.
STATIC MEMBER FUNCTIONS:
A member function that is declared static is called static member function. It has following properties:
· A static function can have access to only static members, function or variable.
· A static member function can be called using the class name instead of its objects.
Class-name::function-name
//example of static data function
#include<iostream.h>
#include<conio.h>
class test
{
static int count; //static member variable
int code;
public:
void getcode()
{
code=count++;
}
void showdata()
{
cout<<"object member:"<<code<<endl;
}
static void showcount()
{
cout<<"count:"<<count<<endl;
}
};
int test::count; //syntax ( MUST DO THIS )
//DEFINITION OF STATIC DATA MEMBER
void main()
{
test t1,t2,t3; //initialize count=0
clrscr();
t1.getcode(); //output code=1
t2.getcode(); //output code=2
test::showcount();
t3.getcode(); //output code=3
t1.showdata(); //output count=1
t2.showdata(); //output count=2
t3.showdata(); //output count=3
t1.showcount(); //output count=3
t2.showcount(); //output count=3
t3.showcount(); //output count=3 */
getch();
}
OBJECTS AS FUNCTION ARGUMENTS:
Like any other data-type, an object may be used as a function argument. This can be done in two ways:
· A copy of the entire object is passed to the function (pass by value).
· Only the address of the object is transferred to the function (pass by reference)
//objects as function arguement(pass but not return)
#include<iostream.h>
#include<conio.h>
class complex
{
private:
int real,imag;
public:
void getdata()
{
cout<<"enter real part";
cin>>real;
cout<<"\nenter the imaginary part";
cin>>imag;
}
void showdata()
{
cout<<"\n real="<<"+"<<"immaginary="<<"="<<real<<immaginary;
}
void add( complex c1,complex c2)
{
real=c1.real+c2.real;
imag=c1.imag+c2.imag;
}
};
void main()
{
clrscr();
complex c1,c2,c3;
c1.getdata();
c2.getdata();
c3.add(c1,c2);
c1.showdata();
cout<<"+";
c2.showdata();
cout<<"=";
c3.showdata();
getch();
}
Returning object:
//example of returning object
#include<iostream.h>
#include<conio.h>
class complex
{
float real;
float imag;
public:
void getdata()
{
cout<<"enter real part";
cin>>real;
cout<<"enter imaginary part";
cin>>imag;
}
void showdata()
{
cout<<"real:"<<real<<endl;
cout<<"imaginary:"<<imag<<endl;
}
complex sum(complex c2)
{
complex temp;
temp.real=real+c2.real;
temp.imag=c2.imag+imag;
return temp;
}
};
int main()
{
complex c1,c2,c3;
clrscr();
c1.getdata();
c2.getdata();
c3=c1.sum(c2);
c3.showdata();
getch();
return 0;
}
FRIEND FUNCTION:
The functions that are declared with the keyword friend are known as friend function. The concept of encapsulation and data hiding dictate that non-member function should not be allowed to access an object private member. Non-member function of a class cannot access the member of class but by making use of friend function we can achieve the function.
Syntax:
Class class-name
{
private:
---------
public:
friend return-type function-name(arg1,arg2)
----------
};
Characteristics of friend function:
- It is not in the scope of class with which it has been declared as friend.
- Since it is not in the scope of the class it cannot be called using the objects of the class
- It can be invoked like a normal function without the help of any object. And also there is no need of scope resolution.
- Unlike member function it cannot access the member names directly and has to use an object name and dot (.) membership operator with each member name.
- It can be declared either in the public or the private part of the class without affecting its member.
- Normally friend function takes object as argument.
- It can be declared in public or private part of the class.
|
//example of fruend function
#include<iostream.h>
#include<conio.h>
class sample
{
int a,b;
public:
void setvalue()
{
a=2501;b=40;
}
friend float mean(sample s);
};
float mean(sample s)
{
return((s.a+s.b)/2.0);
}
void main()
{
clrscr();
sample x;
x.setvalue();
cout<<"mean value="<<mean(x);
getch();
}
FRIEND AS BRIDGE
If we want to operate on object of two different classes, the function may take objects of two classes as arguments and operate on their private data. For this we have to make use of friend function that can act as bridge between classes.
//friends as bridge
#include<iostream.h>
#include<conio.h>
class second; //declaration
class first
{
private:
float data1;
public:
void setdata(float x)
{
data1=x;
}
friend float sum(first a, second b);
};
class second
{
private:
float data2;
public:
void setdata(float x)
{
data2=x;
}
friend float sum(first a,second b);
};
float sum(first a,second b)
{
return(a.data1+b.data2);
}
void main()
{
first a;
clrscr();
second b;
a.setdata(15.88);
b.setdata(15.12);
cout<<"sum="<<sum(a,b);
getch();
}
FRIEND CLASS:
The member function of a class can be all made friends at a same time when we make the entire class a friend.
//friend classes
#include<iostream.h>
#include<conio.h>
class first
{
private:
int data1;
public:
void setdata(int x)
{
data1=x;
}
friend class second;
};
class second
{
private:
int data2;
public:
void showfirst(first a)
{
cout<<"data1="<<a.data1;
}
};
void main()
{
first a;
clrscr();
second b;
a.setdata(15);
b.showfirst(a);
getch();
}
CONSTRUCTOR AND DESTRUCTOR
`Constructor is a special member function of a class whose task is to allocate memory as well as initialize the object of its class. It is special because its name is the same as the class name. The constructor is invoked whenever an object of its associated class is created. It is called constructor because it constructs the values of data members of the class. It is possible to define class without constructor in such case the run time system calls a dummy constructor that performs no action when its object is created.
Syntax:
Class test
{
private:
--------;
public:
test() //constructor
{
---------
}
};
CHARACTERISTICS OF CONSTRUDTOR:
1. They should be declared in the public section.
2. They are invoked automatically when the object are created.
3. They have arguments but no return type.
4. They cannot be inherited, though the derived class can call the base class constructor.
5. Like other C++ function, they can have default arguments.
6. A constructor cannot be virtual.
7. We cannot refer to their address.
8. An object with a constructor cannot be used as a member of a union.
9. They make implicit calls to the operator new and delete when memory allocation is required.
TYPES OF CONSTRUCTOR:
- DEFAULT CONSTUCTORS.
- USER DEFINED CONSTRUCTORS.
- COPY CONSTUCTORS.
1. Default constructors:
If initialization of data of object is required while creating an object then the programmer has to define own constructor for that purpose. The name for constructor should always be same as class. It is possible to have more than one constructor in classes that are defined by different number of arguments. This is known as constructor overloading.
//constructor overloading
#include<iostream.h>
#include<conio.h>
class account
{
private:
int accno;
float balance;
public:
account() //constructor 1
{
accno=1024;
balance=5000.50;
}
account(int acc) //constructor 2
{
accno=acc;
balance=4000.25;
}
account(int acc,float bal) //constructor 2
{
accno=acc;
balance=bal;
}
void showdata()
{
cout<<"\n account no="<<accno;
cout<<"\n balance="<<balance;
}
};
void main()
{
account a1;account a2(1026);
clrscr();
account a3(1028,6000.6);
cout<<"\nthe data for a1"<<" is";
a1.showdata();
cout<<"\nthe data for a2"<<" is";
a2.showdata();
cout<<"\nthe data for a3"<<" is";
a3.showdata();
getch();
}
3. Copy constructor:
The copy constructor creates an object as an exact copy of another object. In copy constructor newly created object is equal to another existing object of a same class.
Class test
{
private:
--------
public:
test(test &t);
---------
};
test t1;
test t2=t1; //copy constructor
test t3(t1); // copy constructor
//copy constructor
#include<iostream.h>
#include<conio.h>
class test
{
private:
int data;
public:
test(int x)
{
data=x;
}
test(test &t)
{
data=t.data;
}
void showdata()
{
cout<<"data="<<data<<endl;
}
};
void main()
{
test t1(55);
clrscr();
test t2=t1;
test t3(t1);
t1.showdata();
t2.showdata();
t3.showdata();
getch();
}
Destructors:
While an object is no longer needed it can be destroyed. Destructor is called while an object is to be destroyed. Those functions complement the operation performed by constructor. Like constructor, destructor is member function whose name is same as class name but is preceded by tilde (~) sign.
A destructor can have neither text argument nor returns any value.
Class test
{
private:
…………
public:
test(){………} //constructor
~test(){……….} //destructor
};
//destructors
#include<iostream.h>
#include<conio.h>
class test
{
public:
test()
{
cout<<"\n control is in constructor";
}
~test()
{
cout<<"\ncontrol is in destructors";
}
};
void main()
{
clrscr();
test t;
cout<<"\nfunction main terminating......";
//destructor is called when t goes out of scope.
getch();
}
|
Parameterized constructors:
Just like other function constructor can be invoked with a list of argument such constructors are called parameterized constructors.
Syntax:
Class sample
{
private:
-------------
public:
sample(int data)
{
----------
}
};sample s1(3),s2(5); //3 and 5 are passed as parameter.
Calling constructors:
Calling constructor can be done by two ways:
- By calling the constructor explicitly.
- By calling the constructor implicitly.
integer int1=integer(0,100); //explicit call
integer int1(0,100); //implicit call
//eg of parameterized constructor and its calling type
#include<iostream.h>
#include<conio.h>
class integer
{
int m,n;
public:
integer(int,int);
void display()
{
cout<<"m="<<m<<endl;
cout<<"n="<<n<<endl;
}
};
integer::integer(int x,int y)
{
m=x;
n=y;
}
void main()
{
integer int2=integer(25,75); //called explicitly
clrscr();
integer int1(0,100); //called implicitly
cout<<"object 1"<<endl;
int1.display();
cout<<"object 2"<<endl;
int2.display();
getch();
}
/*OUTPUT
object 1
m=0
n=100
object 2
m=25
n=75*/
Dynamic constructor:
Allocation of memory to objects at the time of their construction is known as dynamic constructor of objects. It enables the system to allocate the right amount of memory for each object when the objects are not of the same size, thus resulting in the saving of memory. The memory is allocated with the help of the new operator.
OPERATOR OVERLOADING AND TYPE CONVERSION:
The mechanism of giving special meanings to an operator is called operator overloading. The operator such as +, -, /, +=, >, <, <<, >> etc. are designed to operator only on standard data types in structured programming language such as C. The operator + can be used to perform string concatenation operation besides the addition operation on integer, floating point etc.
Operator overloading provides a flexible option for creation of new definition for most of the C++ operator. We can overload all c++ operator except the following:
- class member access operator(., .*)
- scope resolution operator(::)
- size operator(sizeof)
- condition operator(?:)
Even though the semantic(meaning) of the operator can be extended, we cannot change its syntax(grammar) when an operator is overloaded, its original meaning is not lost. The grammatical rule such as precedence, associatively etc. of the operator remains the same for overloaded operator.
Hence, we see that operator overloading concepts are applied for extending capability of operators to operate on user defined data and for data conversion. The key word "operator" is used for overloading C++ operator.
The general form of an operator function is
Syntax:
return_type operator operation_symbol( argument list)
{
//function body
}
The keyword operator indicates that the operator symbol following it, is the C++ operator to be overloaded to operate on member of its fixed class.
· Operator function must be either member function or friend function.
· A basic difference between them is that a friend function will have only one argument for unary operator and two for binary operator while a member function has no argument for unary operator and only one for binary operator.
PROCESS OF OVERLOADING:
It involves the following steps:
- Create a class that defines the data type that is to be used in the overloading operations.
- Declare the operator function that is operator + in the public part of the class. It may be either a member function or friend function.
- Define the operator function to implement the required operation.
UNARY OPERATOR OVERLOADING:
We can overload unary operator to an objects in the same way as is applied to an int or float variable. The syntax for overloading the unary operator is
return_type operator operator_symbol()
{
//function body
}
Overloading without explicit argument to an operator function is known as unary operator overloading.
//unary operator overloading
#include<iostream.h>
#include<conio.h>
class counter
{
private:
int count;
public:
counter(){count=0;}
int getcount(){return count;}
void operator ++()
{
count++;
}
};
void main()
{
counter c1,c2;
cout<<"\nc1="<<c1.getcount();
cout<<"\nc2="<<c2.getcount();
c1++;
cout<<"\nc1="<<c1.getcount();
c2++;
c2++;
cout<<"\nc2="<<c2.getcount();
getch();
}
Output
C1=0
C2=0
C1=1
C2=2
BINARY OPERATOR OVERLOADING:
Overloading with single explicit argument is known as binary operator overloading.
Binary overloaded operator function takes the first object as an implicit operand and the second operand must be passed explicitly.
The data member functions of first objects are accessed without using the dot operator.
//binary operator overloading
#include<iostream.h>
#include<conio.h>
class complex
{
private:
int real ,imag;
public:
void getdata()
{
cout<<"enter real part";
cin>>real;
cout<<"enter imaginary part";
cin>>imag;
}
void showdata()
{
cout<<real<<"+i"<<imag;
}
complex operator+(complex c2)
{
complex temp;
temp.real=real+c2.real;
temp.imag=imag+c2.imag;
return temp;
}
};
void main()
{
complex c3,c2,c1;
clrscr();
c1.getdata();
c2.getdata();
c3=c2+c1;
c3.showdata();
getch();
}
OVERLOADING WITH FRIEND FUNCTION:
While overloading with friend function unary operators take one explicit argument and binary operator takes two explicit arguments.
Syntax:
friend return_type operator operator_symbol(argument list)
{
//body of function
}
//operator overloading with friend function
#include<iostream.h>
#include<conio.h>
class complex
{
private:
int real ,imag;
public:
void getdata()
{
cout<<"enter real part";
cin>>real;
cout<<"enter imaginary part";
cin>>imag;
}
void showdata()
{
cout<<real<<"+i"<<imag;
}
friend complex operator+(complex c1,complex c2)
{
complex temp;
temp.real=c1.real+c2.real;
temp.imag=c1.imag+c2.imag;
return temp;
}
};
void main()
{
complex c3,c2,c1;
clrscr();
c1.getdata();
c2.getdata();
c3=c2+c1;
c3.showdata();
getch();
}
MANUPALATION OF STRING USING OPERATOR
//Overloaded +operator
#include<iostream.h>
#include<conio.h>
#include<string.h>
const int sz=80;
class string
{
char str[sz];
public:
string()
{
strcpy(str," ");
}
string(char s[])
{
strcpy(str,s);
}
void display()
{
cout<<str;
}
string operator+(string ss)
{
if(strlen(str)+strlen(ss.str)<sz)
{
string temp;
strcpy(temp.str,str);
strcat(temp.str,ss.str);
return temp;
}
else
cout<<"\nstring overflow";
}
};
void main()
{
string s1="\nhappy holi";
string s2=" happy new year!\n";
string s3;
clrscr();
s1.display();
cout<<endl;
s2.display();
s3.display();
s3=s1+s2;
s3.display();
getch();
}
STREAM OPERATOR OVERLOADING
#include<iostream.h>
#include<conio.h>
class demo
{
private:
char name[25];
int age;
public:
friend istream&operator>>(istream &is,demo&obs);
friend ostream&operator>>(ostream &os,demo&obs);
};
istream&operator>>(istream &is,demo&obs)
{
is>>obs.name;
is>>obs.age;
return is;
}
ostream & operator<<(ostream & os,demo&obs)
{
os>>obs.name;
os>>obs.age;
return os;
}
void main()
{
demo b;
cout<<"enter name and age";
cout<<endl;
cin>>b;
cout<<"printing the value";
cout<<b<<endl;
getch();
}
DATA CONVERSION:
FOR BUILT IN DATA TYPE:
For built in data type conversion from one form to another form is done by two ways:
- Implicit conversion.
- Explicit conversion.
- Implicit conversion:
The type of data to the right of an assignment operator is automatically converted to the type of the variable to the left.
It is also called automatic type conversion.
It uses promotion ruler.
Eg. Int m;
float x=3.14159;
m=x;
Hence, x is converted to an integer before its value is assigned to m. Thus the fraction part is truncated (terminated).
- Explicit conversion
It is done by type casting.
Syntax:
type_name(expression);
E.g. average=sum/float (i);
FOR USER DEFINED DATA-TYPE:
Since the user defined data types are designed by us to suit our requirement the compiler does not support automatic type conversions. For such data type we must therefore design the conversion routines by ourselves if such operations are required.
Three types of situations might arise in the data conversion between incompatible types. They are:
- Conversion from basic type to class type.
- Conversion from class type to basic type.
- Conversion from class type to another class type.
- Conversion from basic type to class type.
To convert basic type to user defined type the conversion function should exist in the class in the form of constructor.
Constructor (basic_type) { ;}
- Conversion from user defined-type to basic type.
To convert user defined-type to basic type there should exist operator function in the class.
Operator basic-type(){}
//conversion
#include<iostream.h>
#include<conio.h>
class meter
{
float length;
public:
meter(){length=0.0;}
/*code for conversion from basic to user defined type*/
meter(float initlength)
{
length=initlength/100.0;
}
/*code conversion from user defined to basic type*/
operator float()
{
float lencms;
lencms=length*100.0;
return lencms;
}
void getlen()
{
cout<<"\nenter lengthin meter\n";
cin>>length;
}
void showdata()
{
cout<<"length in meter=\n"<<length;
}
};
void main()
{
meter m1;
float len1;
cout<<"enter length in cms\n";
cin>>len1;
m1=len1; //convert from basic to user defined type
m1.showdata();
meter m2;
float len2;
m2.getlen();
len2=m2; //user defined to basic type
cout<<"\nlength is:\n"<<len2;
getch();
}
- Conversion from one class to another class.
Method 1:
Conversion routine in source class: operator function
Method 2:
Conversion routine in destination class: constructor
EXAMPLE:
//conversion from one class to another class
//conversion from celsius to farenheit
#include<iostream.h>
#include<conio.h>
class feh //destination class
{
float temp;
public:
feh(){}
feh(float t)
{
float temp=t;
}
};
class cel //source class
{
float temp;
public:
cel(){}
cel(float t)
{
temp=t;
}
operator feh()
{
float res;
res=9.0*temp/5+32;
return feh(res);
}
};
void main()
{
feh f1;
cel c1(100);
f1=c1; // OR F1=(FEH)C1;
getch();
}
//conversion from one class to another class
#include<iostream.h>
#include<conio.h>
class feh //destination class
{
float temp;
public:
feh(){}
feh(float c)
{
float res=c.gettemp();
temp=9.0*res/5+32;
}
};
class cel //source class
{
float temp;
public:
cel(){}
cel(float t)
{
temp=t;
}
float gettemp()
{
return temp;
}
};
void main()
{
feh f1;
cel c1(100);
f1=c1; // OR F1=(FEH)C1;
getch();
}
INHERITANCE
Inheritance is a technique of building new classes from the existing classes. It is a technique of organizing information in a hierarchical form just like a child inheriting the features of its parent. Inheritance is a prime feature of OOPs.
In the process of inheritance, the existing classes are called base classes and the new classes that are derived from the existing classes are called derived classes.
When a class is derived from a base class, the derived class inherits all the characteristics of base class and can add new features as refinements and improvements.
The great advantage of inheritance is reusability which ensures ease of distributing class libraries. It improves the program reliability.
A base class is also called ancestor, parent or super class and derived class is also called as descendent, child or subclass.
WHEN TO USE INHERITANCE:
The following principles have to be followed to promote the use of inheritance in programming:
- Most common use of inheritance and sub-classing is for specialization i.e. to obtain specific classes from classes having general properties.
- To guarantee that classes maintain a certain common interface i.e. they implement the same method.
- Unlike generalization sub-classing for extension adds some new methods to those of parent class hence the functionality is less strongly tied to the existing parents methods.
- Using generalization technique a sub-class extends the behavior of super class to create a more general kind of object. Here the sub-class has overridden some properties of the base class.
- In sub-classing for limitation the behavior of sub-class is more restricted than the behavior of super-class. It is done while inheriting from base class which should not or cannot be modified.
- Sub-classing of variance is useful when two or more class have similar implementation but not having any hierarchical relationship between the concept represented by the classes.
- Sub-classing by combination occurs when a sub-class represents a combined feature from two or more parent class.
SINGLE INHERITANCE: PUBLIC
………..
MULTILEVEL INHERITANCE
………..
MULTIPLE INHERITANCES:
……
AMBIGUITY RESOLUTION IN INHERITANCE:
Occasionally we may face problem in using the multiple inheritance when a function with same name inheritance appears in more than one base class. Consider the following example:
………….
Here the reference display() is ambiguity because the compiler doesn't know whether display() function refer to member in class base1 or class base2. This ambiguity can be resolved by two ways:-
1). Using scope resolution operator
2). Using overriding.
1). Using scope resolution operator:
d.base1::display(); //function call
d.base2::display(); // function call
2). Using overriding:
Ambiguity can also be resolved by overriding i.e. the member can be redefined in the derived class.
……………..
In this example when we invoked the function display() since there is a function with the same name in the derived class also. Directly the display() function from derived class executed ignoring the display() of the base class. But since inside the display() function of derived class we have called display() function of both base classes so they also be executed.
This type of property where the function from derived class get executed directly when there are function with same name in both base and derived class is function overriding.
HIERARCHICAL INHERITANCE:
…………..
HYBRID INHERITANCE:
………
A PROCTECTED MEMBER can be accessed by member functions in its own class or in any other class derived from its own class. It cannot be accessed from functions outside these classes such as main(). It ensures that the class is inheritance ready.
……………
VIRTUAL BASE CLASS:
………….
Child would have duplicate set of members inherited from grand parent. This introduces ambiguity and should be avoided.
The duplication of inherited members due to these multiple path can be avoided virtual base class as virtual base class while declaring the direct or intermediate base class.
Syntax:
Class A
{………….};
Class B1:virtual public A
{………….};
Class B2:virtual public A
{………….};
Class C: public B1, public B2
{………….}; //only one copy of A will be inherited.
ABSTRACT CLASS:
An abstract class is one that is not used to create objects.
It is designed only to act as a base class (to be inherited by derived class).
…………….
CONSTRUCTOR AND DESTRUCTOR IN INHERITANCE:
Constructor plays an important role in initialization of an object data member and allocating required resources such as memory. The derived class need not have a constructor as long as the base class has no argument constructor. However if the base class has constructor with argument (1 or more), then it is mandatory (necessary) for the derived class to have a constructor and pass the argument to the base class constructor. In the application of inheritance, object of derived class are usually created instead of base class. When an object of derived class is created constructor of base class is executed first and later the constructor of derived class is executed.
1). Constructor only in base class:
When there is no argument constructor in base class then it is automatically called when the object of derived class is initialized.
……………………….
2).Constructor only in derived class:
Here the base class object (if created) used the compiler supplied constructor whereas the object created using derived class use the user supplied constructor.
…………………..
3). Constructor in both derived and base class:
In this case, the derived class object calls the no-argument constructor of base class first and then calls the no-argument constructor of its own class.
………………
4). Multiple constructors in base class and single constructor in derived class:
………………..
In this case, if the class is derived without maintaining any argument then the default constructor (i.e. no-argument) of the base class is invoked during the instantiation of derived class object (with or without argument) no matter how many constructor with arguments are present in base class.
5). Constructor in base and derived class without default constructor:
Complier looks for no argument constructor by default in the base class then it should meet the following conditions.
a). The base class must have no argument constructor if it is used to derived another class where this class is used as base class without any explicit argument.
b). If the base class does not have a default constructor then they must be explicitly invoked during derived class constructor definition otherwise the complier generate errors.
………………………
In the above program, the complier generates the following error:
"Cannot find default constructor to initialize the base class".
This error can be overcome by explicit invocation of the constructor of base class during definition of derived class constructor as shown below:
………………….
6). Constructor in a multiple inheritances class:
In multiple inherited classes, the constructors of the base classes are called during the inheritance (i.e. during the definition of derived class) no mater the order of their definition in the program.
……………………..
NOTE:
If the derived class is obtained from virtual and non-virtual class then the constructor of virtual class is invoked first even if it is specified after the non-virtual class during the definition of derived class.
……………
7). Constructor in multilevel inheritance:
In multilevel inheritance if an object of the class which is at the bottom of the level is instantiated the constructor is invoked in the order from top to bottom (up to the class whose object is instantiated.
………………
8). Destructor in derived class:
Unlike constructor, destructor in the class hierarchy (parent and child class) is invoked in the reverse order of the constructor invocation. I.e. whenever an object goes out of scope the destructor of that class whose constructor was executed last while building the object of the derived class will be executed first. If a destructor is absent in any class in the hierarchy of classes, then the destructor of that class is not invoked.
………………….
No comments:
Post a Comment