Object oriented concept
CLASS & OBJECT
Class definition :
Class is user defined data types ,& it contains its own collection of data
member & member function .
Syntax
Class class_name
{ Access specifier // private , public or protected
Data member // local variable declaration
Member function // function to access data member of class
}; // class is terminated by semi colon
Where class : is keyword
Access specifier : In general access specifiers are the access restriction
imposed during the derivation of different subclasses from the base class.
Public - The members declared as Public are accessible from
outside the Class through an object of the class.
Protected - The members declared as Protected are accessible from
outside the class BUT only in a class derived from it.
Private - These members are only accessible from within the class.
No outside Access is allowed.
Example
Class Add
{ int a,b,sum; // data member Adarsh
Public Void sum () // member function lakshetty
{ cout<< “ enter the value for a & b \n”
Cin>>a >>b;
Asst Prof Adarsh Lakshetty BKEC , Dept of CSE Page 1
Object oriented concept
};
Object
Object is an instance of class
Syntax
Class_name object_name ;
Example
In above class add object is created as
Add a; // object a is created
Access data & member function for class
Dot (.) operator is used to access the access & initialize data member &
member function of class
class Studentcse
{
public: int rollno;
string name;
}; Adarsh
lakshetty
Void main()
{
Studentcse A;
Studentcse B;
// initial values for data member of class studentcse using object A
A.rollno=1;
A.name="Adarsh";
Asst Prof Adarsh Lakshetty BKEC , Dept of CSE Page 2
Object oriented concept
// initial values for data member of class studentcse using object B
B.rollno=2;
B.name="vishal";
cout <<"Name and Roll no of object A is: "<< A.name << "-" <<A.rollno;
cout <<"Name and Roll no of object B is: "<< B.name << "-" << B.rollno;
}
Output
Name and Roll no of object A is: Adarsh
Name and Roll no of object B is: vishal
CONSTRUCTOR
A constructor is a special type of member function that initializes
an object automatically when it is created. Compiler identifies a given
member function is a constructor by its name and the return type.
Rules of Constructors
1. Constructor should be same name as the class and declared in the
public section of the class.
2. Constructors are invoked automatically whenever the object is
created.
3. Constructors do not have return type.
4. Constructor can not be inherited, but from the derived class we can
call the base class constructors.
5. Constructor can not be virtual.
6. It is not possible to refers to the address of constructors.
7. It is not possible to use the constructor as member of union if the object
is created with constructor.
8. constructor can be overloaded
9. Tt allocate memory for class
Syntax Adarsh
lakshetty
Class class_name
{ data member
Public: class_name( ) // constructor
{
Asst Prof Adarsh Lakshetty BKEC , Dept of CSE Page 3
Object oriented concept
Body of constructor
}
Member function
} ; End of class
Types of Constructors in C++
Constructors are of three types:
1. Default Constructor
2. Parametrized Constructor
Default Constructors
Default constructor is the constructor which doesn't take any argument.
It has no parameter.
Class cse
{
Public: cse( )
{
Cout<<” Default constructor is invoked”;
}
}
Parameterized Constructors
These are the constructors with parameter. Using this Constructor you
can provide different values to data members of different objects, by
passing the appropriate values as argument.
Class CSE
{
Adarsh
Public: CSE(int a)
{ lakshetty
Cout<<”square of number “<<a<<”is=”<<(a*a);
}}
Asst Prof Adarsh Lakshetty BKEC , Dept of CSE Page 4
Object oriented concept
Destructors
Destructor is a special class function which destroys the object as soon as
the scope of object ends. The destructor is called automatically by the
compiler when the object goes out of scope.
The syntax for destructor is same as that for the constructor, the class
name is used for the name of destructor; with a tilde ~ sign as prefix to
it.
class CSE
{
public: ~CSE() // defining destructor for class
{
// statement
}
};
class A
{
A() // constructor
{
cout << "Constructor one called";
}
~A() // destructor
{
cout << "Destructor one called";
}
};
int main()
{
A obj1; // Constructor Called
int x=1
if(x) Adarsh
{
lakshetty
A obj2; // Constructor Called
} // Destructor Called for obj2
} // Destructor called for obj
Asst Prof Adarsh Lakshetty BKEC , Dept of CSE Page 5
Object oriented concept
Output
Constructor called
Constructor called
Destructor called
Destructor called
Member function declaration outside the class
Class cube
{ int a;
Public: cube(int x)
{ a=x;
}
int cub( ); // member function declared
};
int cube :: cub( ) // member function outside the class
{ return (a*a*a);
}
Main( )
{ cube c(5);
Cout<<”cube of given number is “<<a<<”is :”<<c.cub;
}
Inline function
is a function which when invoked requests the compiler to replace the calling
statement with its body. A keyword inline is added before the function name
to make it inline. It is an optimization technique used by the compilers as it
saves time in switching between the functions otherwise. Member functions of a
class are inline by default even if the keyword inlineis not used.
Syntax
Adarsh
Inline return_type function_name (parameter list)
lakshetty
{ body of inline }
Asst Prof Adarsh Lakshetty BKEC , Dept of CSE Page 6
Object oriented concept
Inline functions provide following advantages:
1) Function call overhead doesn’t occur.
2) It also saves the overhead of push/pop variables on the stack when
function is called.
3) It also saves overhead of a return call from a function.
4) When you inline a function, you may enable compiler to perform
context specific optimization on the body of function. Such optimizations
are not possible for normal function calls. Other optimizations can be
obtained by considering the flows of calling context and the called
context.
5) Inline function may be useful (if it is small) for embedded systems
because inline can yield less code than the function call preamble and
return.
Inline function disadvantages:
1) The added variables from the inlined function consumes additional
registers, After in-lining function if variables number which are going to
use register increases than they may create overhead on register
variable resource utilization. This means that when inline function body
is substituted at the point of function call, total number of variables used
by the function also gets inserted. So the number of register going to be
used for the variables will also get increased. So if after function inlining
variable numbers increase drastically then it would surely cause an
overhead on register utilization. Adarsh
2) If you use too many inline functions then the size of the lakshetty
binary executable file will be large, because of the duplication of same
code.
Asst Prof Adarsh Lakshetty BKEC , Dept of CSE Page 7
Object oriented concept
3) Too much inlining can also reduce your instruction cache hit rate,
thus reducing the speed of instruction fetch from that of cache memory
to that of primary memory.
4) Inline function may increase compile time overhead if someone
changes the code inside the inline function then all the calling location
has to be recompiled because compiler would require to replace all the
code once again to reflect the changes, otherwise it will continue with old
functionality.
5) Inline functions may not be useful for many embedded systems.
Because in embedded systems code size is more important than speed.
6) Inline functions might cause thrashing because inlining might
increase size of the binary executable file. Thrashing in memory causes
performance of computer to degrade.
#include <iostream>
using namespace std;
inline int exp(int x, int y, int z)
{
return (x + y) * z;
}
int main()
{
cout << exp(4,5,7) << endl;
cout << exp(4,5,6) << endl;
cout << exp(4,7,5) << endl;
cout << exp(7,4,6) << endl;
return 0;
Adarsh
}
lakshetty
Output:
63 54 55 66
Asst Prof Adarsh Lakshetty BKEC , Dept of CSE Page 8
Object oriented concept
Friend Functions
The private member data of a class can be accessed only by member
functions of that class.
Declaration of friend function
class Box {
double width;
public:
double length;
friend void printWidth( Box box );
void setWidth( double wid );
};
Example on friend function
#include <iostream.h>
class Box {
double width;
public:
friend void printWidth( Box box );
void setWidth( double wid );
};
// Member function definition
void Box::setWidth( double wid ) {
width = wid;
}
// Note: printWidth() is not a member function of any class.
void printWidth( Box box ) {
Adarsh
/* Because printWidth() is a friend of Box, it can
lakshetty
directly access any member of this class */
cout << "Width of box : " << box.width <<endl;
Asst Prof Adarsh Lakshetty BKEC , Dept of CSE Page 9
Object oriented concept
// Main function for the program
int main() {
Box box;
// set box width without member function
box.setWidth(10.0);
// Use friend function to print the wdith.
printWidth( box );
return 0;
}
Output
Width of box : 10
Namespace
Namespace are used to group the entities like class , variable , object
function under a name .namespace helps to divide global scope into sub
scopes where each sub scope has its own name
#include<iostream>
Using namespace std;
Namespace ns1
Int a=5;
} Adarsh
lakshetty
Asst Prof Adarsh Lakshetty BKEC , Dept of CSE Page 10
Object oriented concept
Namespace ns2
Char a[]=”hello”;
int main ()
Cout<<ns1::a<<endl;
Cout<<ns2::a<<endl;
Return 0;
}
Output : 5
hello
Adarsh
lakshetty
Asst Prof Adarsh Lakshetty BKEC , Dept of CSE Page 11
