Class and object in C++

 Class: A Class is a user defined data type toClass: A Class is a user defined data type to
implement an abstract object. Abstract meansimplement an abstract object. Abstract means
to hide the details. A Class is a combination ofto hide the details. A Class is a combination of
data and functions.data and functions.
 Data is called as data members and functionsData is called as data members and functions
are called as member functions.are called as member functions.

 Abstract data type:-Abstract data type:-
 A data type that separates the logical propertiesA data type that separates the logical properties
from the implementation details called Abstractfrom the implementation details called Abstract
Data Type(ADT).Data Type(ADT).
 An abstract data type is a set of object and anAn abstract data type is a set of object and an
associated set of operations on those objects.associated set of operations on those objects.
 ADT supports data abstraction, encapsulation andADT supports data abstraction, encapsulation and
data hiding.data hiding.

 Examples of ADT are:-Examples of ADT are:-
 BooleanBoolean
 IntegerInteger built in ADTbuilt in ADT
 ArrayArray
 StackStack
 QueueQueue
 Tree search structureTree search structure User definedUser defined
ADTADT
 Boolean {operations are AND,OR,NOT andBoolean {operations are AND,OR,NOT and
values are true and false}values are true and false}
 Queues{operations are create , dequeue,inqueue andQueues{operations are create , dequeue,inqueue and
values are queue elements}values are queue elements}

Class definitionClass definition
 A class definition begins with the keywordA class definition begins with the keyword
classclass..
 The body of the class is contained within a setThe body of the class is contained within a set
of braces,of braces, { } ;{ } ; (notice the semi-colon).(notice the semi-colon).
class class_name
{
….
….
….
};
Class body (data member +
methodsmethods)
Any valid
identifier

 Within the body, the keywordsWithin the body, the keywords private:private: andand
public:public: specify the access level of thespecify the access level of the
members of the class.members of the class.
 the default isthe default is privateprivate..
 Usually, the data members of a class areUsually, the data members of a class are
declared in thedeclared in the private:private: section of the class andsection of the class and
the member functions are inthe member functions are in public:public: section.section.

 Data member or member functions may be public,Data member or member functions may be public,
private or protected.private or protected.
 Public means data members or member functionsPublic means data members or member functions
defining inside the class can be used at outside thedefining inside the class can be used at outside the
class.( in different class and in main function)class.( in different class and in main function)
 Member access specifiersMember access specifiers
 public:public:
 can be accessed outside the class directly.can be accessed outside the class directly.
 The public stuff isThe public stuff is the interfacethe interface..

 private:private:
 Accessible only to member functions of classAccessible only to member functions of class
 Private members and methods are for internalPrivate members and methods are for internal use only.use only.
 Private means data members and member functionsPrivate means data members and member functions
can’t be used outside the class.can’t be used outside the class.
 Protected means data member and memberProtected means data member and member
functions can be used in the same class and itsfunctions can be used in the same class and its
derived class (at one level) (not inmain function).derived class (at one level) (not inmain function).

class class_name
{
private:
…
…
…
public:
…
…
…
};
Public members or methods
private members or methods

 This class example shows how we canThis class example shows how we can
encapsulate (gather) a circle information intoencapsulate (gather) a circle information into
one package (unit or class)one package (unit or class)
class Circle
{
private:
double radius;
public:
void setRadius(double r);
double getDiameter();
double getArea();
double getCircumference();
};
No need for others classes to access
and retrieve its value directly. The
class methods are responsible for
that only.
They are accessible from outside
the class, and they can access the
member (radius)

Class Example (Problem)Class Example (Problem)
#include<iostream.h>#include<iostream.h>
#include<stdio.h>#include<stdio.h>
class studentclass student
{{
int rollno;int rollno;
char name[20];char name[20];
};};
void main()void main()
{{
student s;student s;
cout<<“enter the rollno.:”;cout<<“enter the rollno.:”;
cin>>s.rollno;cin>>s.rollno;
cout<<“enter the name:”;cout<<“enter the name:”;
gets(s.name);gets(s.name);
cout<<“rollno:”<<s.rollno;cout<<“rollno:”<<s.rollno;
cout<<“nname:”;cout<<“nname:”;
puts(s.name);puts(s.name);
}}

Class Example (Solution)Class Example (Solution)
{{
public:public:
};};
{{
cin>>s.rollno;cin>>s.rollno;
gets(s.name);gets(s.name);
cout<<“rollno:”<<s.rollno;cout<<“rollno:”<<s.rollno;
puts(s.name);puts(s.name);
}}

Implementing class methodsImplementing class methods
 There are two ways:There are two ways:
1.1. Member functions defined outside classMember functions defined outside class
 Using Binary scope resolution operator (Using Binary scope resolution operator (::::))
 ““Ties” member name to class nameTies” member name to class name
 Uniquely identify functions of particular classUniquely identify functions of particular class
 Different classes can have member functions with same nameDifferent classes can have member functions with same name
 Format for defining member functionsFormat for defining member functions
ReturnTypeReturnType ClassNameClassName::::MemberFunctionNameMemberFunctionName( ){( ){
……
}}

Member FunctionMember Function
Defining Inside the ClassDefining Inside the Class
{{
public:public:
void getdata()void getdata()
{{
cin>>rollno;cin>>rollno;
gets(name);gets(name);
}}
void putdata()void putdata()
{{
cout<<“rollno:”<<rollno;cout<<“rollno:”<<rollno;
puts(name);puts(name);
}}
};};
{{
s.getdata();s.getdata();
s.putdata();s.putdata();
}}
Data Members (Private : in this example)
Member Functions (Public: in this example)
Calling member function

Member FunctionMember Function
Defining Outside the ClassDefining Outside the Class
{{
public:public:
void getdata();void getdata();
void putdata();void putdata();
};};
void student :: getdata()void student :: getdata()
{{
cin>>rollno;cin>>rollno;
gets(name);gets(name);
}}
void student: :: putdata()void student: :: putdata()
{{
cout<<“rollno:”<<rollno;cout<<“rollno:”<<rollno;
puts(name);puts(name);
}}
{{
s.getdata();s.getdata();
s.putdata();s.putdata();
}}

Characteristics of memberCharacteristics of member
functionfunction
 Different classes have same function name. theDifferent classes have same function name. the
“membership label” will resolve their scope.“membership label” will resolve their scope.
 Member functions can access the private data of theMember functions can access the private data of the
class .a non member function cannot do this.(friendclass .a non member function cannot do this.(friend
function can do this.)function can do this.)
 A member function can call another member functionA member function can call another member function
directly, without using the dot operator.directly, without using the dot operator.

Accessing Class MembersAccessing Class Members
 Operators to access class membersOperators to access class members
 Identical to those forIdentical to those for structstructss
 Dot member selection operator (Dot member selection operator (..))
 ObjectObject
 Reference to objectReference to object
 Arrow member selection operator (Arrow member selection operator (->->))
 PointersPointers

Static membersStatic members
 The data and functions of the class may be declared static inThe data and functions of the class may be declared static in
the class declaration.the class declaration.
 The static data members have similar properties to the C staticThe static data members have similar properties to the C static
variable.variable.
 The static data members is initialized with zero when the firstThe static data members is initialized with zero when the first
object of its class is created. No other initialization isobject of its class is created. No other initialization is
permitted.permitted.
 Only one copy of that member is created for the entire classOnly one copy of that member is created for the entire class
and is shared by all the objects of that class, no matter howand is shared by all the objects of that class, no matter how
many objects are created.many objects are created.
 It is visible only within the class, but its lifetime is the entireIt is visible only within the class, but its lifetime is the entire
program.program.

Static member functionStatic member function
 Like static data members we can also declare staticLike static data members we can also declare static
member functions.member functions.
 A static function can have access to only other staticA static function can have access to only other static
members(functions or variables) declared in themembers(functions or variables) declared in the
same class.same class.
 A static member function can be called using theA static member function can be called using the
class (instead of its objects) as folowsclass (instead of its objects) as folows
 Class name:: function name.Class name:: function name.

Example of static membersExample of static members
#inlcude<iostream.h>#inlcude<iostream.h>
Class testClass test
{{
Int code;Int code;
Static int count;Static int count;
Public:Public:
Void setcode()Void setcode()
{{
Code=++count;Code=++count;
}}
Void showcode()Void showcode()
{{
Cout<<“object number “<<code<<endl;Cout<<“object number “<<code<<endl;
}}
Static void showcount()Static void showcount()
{{
Cout<<“count :”<<count;Cout<<“count :”<<count;
}}
};};
Int test::count;Int test::count;
Int main()Int main()
{{
test t1,t2;test t1,t2;
t1.setcode();t1.setcode();
test::showcount();test::showcount();
test t3;test t3;
test::showcount();test::showcount();
t1.showcode();t1.showcode();
Return 0;Return 0;
}}

Class inside a functionClass inside a function
 When a class declared within a function, it is known asWhen a class declared within a function, it is known as
local classlocal class..
 A local class is known only to that function andA local class is known only to that function and
unknown outside it.unknown outside it.
 All member functions must be defined within the classAll member functions must be defined within the class
declaration.declaration.
 The local class may not use local variables of theThe local class may not use local variables of the
function in which it is declared except static and externfunction in which it is declared except static and extern
local variables declared within the function.local variables declared within the function.
 No static variables may be declared inside a local class.No static variables may be declared inside a local class.
 Due to these restrictions local class is not popular in C++Due to these restrictions local class is not popular in C++
programming.programming.

ObjectsObjects
 An object is an instance of a class.An object is an instance of a class.
 An object is a class variable.An object is a class variable.
 Is can be uniquely identified by its name.Is can be uniquely identified by its name.
 Every object have a state which is represented by theEvery object have a state which is represented by the
values of its attributes. These state are changed byvalues of its attributes. These state are changed by
function which applied on the object.function which applied on the object.

State identity and behavior ofState identity and behavior of
objectsobjects
 Every object haveEvery object have identity , behaviour and stateidentity , behaviour and state..
 The identity of objectThe identity of object is defined by its name, everyis defined by its name, every
object is unique and can be differentiated from otherobject is unique and can be differentiated from other
objects.objects.
 The behavior ofThe behavior of an object is represented by thean object is represented by the
functions which are defined in the object’s class. Thesefunctions which are defined in the object’s class. These
function show the set of action for every objects.function show the set of action for every objects.
 The state of objectsThe state of objects are referred by the data storedare referred by the data stored
within the object at any time moment.within the object at any time moment.

Creating an object of a ClassCreating an object of a Class
 Declaring a variable of a class type creates anDeclaring a variable of a class type creates an objectobject. You. You
can have many variables of the same type (class).can have many variables of the same type (class).
 Also known as InstantiationAlso known as Instantiation
 Once an object of a certain class is instantiated, a newOnce an object of a certain class is instantiated, a new
memory location is created for it to store its data membersmemory location is created for it to store its data members
and codeand code
 You can instantiate many objects from a class type.You can instantiate many objects from a class type.
 Ex) Circle c; Circle *c;Ex) Circle c; Circle *c;
Class itemClass item
{{
………………..
,,,,,,,,,,,,,,,,,,,,,,,,,,
}x,y,z;}x,y,z;
We have to declared objects close to the place where they are neededWe have to declared objects close to the place where they are needed
because it makes easier to identify the objects.because it makes easier to identify the objects.

Object typesObject types
 There are four types of objectsThere are four types of objects
1.1. External (global )objectsExternal (global )objects
1.1. This object have the existence throughout the lifetime of the program andThis object have the existence throughout the lifetime of the program and
having file –scope.having file –scope.
2.2. Automatic(local)objectsAutomatic(local)objects
1.1. Persistent and visible only throughout the local scope in which they arePersistent and visible only throughout the local scope in which they are
created.created.
3.3. Static objectsStatic objects
1.1. Persistent throughout a program but only visible within their local scope.Persistent throughout a program but only visible within their local scope.
4.4. Dynamic objectsDynamic objects
1.1. Lifetime may be controlled within a particular scope.Lifetime may be controlled within a particular scope.

Memory Allocation of ObjectMemory Allocation of Object
{{
int marks;int marks;
};};
rollno – 2 bytes
name- 20 bytes
marks- 2 bytes
24 bytes s

Array of objectsArray of objects
 The array of class type variable is known as array ofThe array of class type variable is known as array of
object.object.
 We can declare array of object as following way:-We can declare array of object as following way:-
Class _name object [length];Class _name object [length];
Employee manager[3];Employee manager[3];
1.1. We can use this array when calling a member functionWe can use this array when calling a member function
2.2. Manager[i].put data();Manager[i].put data();
3.3. The array of object is stored in memory as a multi-The array of object is stored in memory as a multi-
dimensional array.dimensional array.

Object as function argumentsObject as function arguments
 This can be done in two ways:-This can be done in two ways:-
 A copy of entire object is passed to the function.A copy of entire object is passed to the function.
 ( pass by value)( pass by value)
 Only the address of the object is transferred to theOnly the address of the object is transferred to the
function. (pass by reference)function. (pass by reference)

( pass by value)( pass by value)
 A copy of the object is passed to the function, anyA copy of the object is passed to the function, any
changes made to the object inside the function do notchanges made to the object inside the function do not
affect the object used to call function.affect the object used to call function.
 When an address of object is passed, the calledWhen an address of object is passed, the called
function works directly on the actual object used infunction works directly on the actual object used in
the call. Means that any change made in side thethe call. Means that any change made in side the
function will reflect in the actual object.function will reflect in the actual object.
(pass by reference)

Passing ObjectPassing Object
class Complexclass Complex
{{
float real, imag;float real, imag;
public:public:
void getdata( );void getdata( );
void putdata( );void putdata( );
void sum (Complex A, Complex B);void sum (Complex A, Complex B);
};};
void Complex : : getdata( )void Complex : : getdata( )
{{
cout<<“enter real part:”;cout<<“enter real part:”;
cin>>real;cin>>real;
cout<<“enter imaginary part:”;cout<<“enter imaginary part:”;
cin>>imag;cin>>imag;
}}
void Complex : : putdata( )void Complex : : putdata( )
{{
if (imag>=0)if (imag>=0)
cout<<real<<“+”<<imag<<“i”;cout<<real<<“+”<<imag<<“i”;
elseelse
cout<<real<<imag<<“i”;cout<<real<<imag<<“i”;
}}
void Complex : : sum ( complex A, complex B)void Complex : : sum ( complex A, complex B)
{{
real = A.real + B.real;real = A.real + B.real;
imag= A.imag + B.imag;imag= A.imag + B.imag;
}}
void main( )void main( )
{{
Complex X,Y,Z;Complex X,Y,Z;
X.getdata( );X.getdata( );
Y.getdata( );Y.getdata( );
Z.sum(X,Y);Z.sum(X,Y);
Z.putdata( );Z.putdata( );
}}

{{
public:public:
};};
{{
}}
{{
elseelse
}}
void Complex : : sum ( Complex A, Complex B)void Complex : : sum ( Complex A, Complex B)
{{
}}
{{
}}
X Y Z

{{
public:public:
};};
{{
}}
{{
elseelse
}}
{{
}}
{{
}}
5
6
7
8
X Y Z

{{
public:public:
};};
{{
}}
{{
elseelse
}}
{{
}}
{{
}}
5
6
7
8
X Y Z
5
6
7
8
A B

{{
public:public:
void sum(Complex A, Complex B);void sum(Complex A, Complex B);
};};
{{
}}
{{
elseelse
}}
{{
}}
{{
}}
5
6
7
8
12
14
X Y Z
5
6
7
8
A B
+
+
=
=

{{
public:public:
};};
{{
}}
{{
elseelse
}}
void complex : : sum ( Complex A, Complex B)void complex : : sum ( Complex A, Complex B)
{{
}}
{{
}}
12 + 14 i12 + 14 i
5
6
7
8
12
14
X Y Z
5
6
7
8
A B
+
+
=
=

Returning ObjectReturning Object
{{
public:public:
Complex sum (Complex B);Complex sum (Complex B);
};};
{{
}}
{{
elseelse
}}
Complex Complex : : sum (Complex B)Complex Complex : : sum (Complex B)
{{
Complex temp;Complex temp;
temp.real=real + B.real;temp.real=real + B.real;
temp.imag= imag + B.imag;temp.imag= imag + B.imag;
return temp;return temp;
}}
void main ( )void main ( )
{{
Complex X, Y, Z;Complex X, Y, Z;
X.Getdata( );X.Getdata( );
Y. getdata( );Y. getdata( );
Z= X.sum (Y);Z= X.sum (Y);
}}

{{
public:public:
};};
{{
}}
{{
elseelse
}}
{{
}}
{{
}}
X Y Z

{{
public:public:
};};
{{
}}
{{
elseelse
}}
{{
}}
{{
}}
5
6
7
8
X Y Z

{{
public:public:
};};
{{
}}
{{
elseelse
}}
{{
}}
{{
}}
5
6
7
8
X Y Z
7
8
B

{{
public:public:
};};
{{
}}
{{
elseelse
}}
{{
}}
{{
}}
5
6
7
8
X Y Z
7
8
B
12
14
temp

{{
public:public:
};};
{{
}}
{{
elseelse
}}
{{
}}
{{
}}
5
6
7
8
12
14
X Y Z
7
8
B
12
14
temp

{{
public:public:
};};
{{
}}
{{
elseelse
}}
{{
}}
{{
}}
12 + 14 i12 + 14 i
5
6
7
8
12
14
X Y Z
7
8
B
12
14
temp

C++ garbage collectionC++ garbage collection
 In c++ the garbage collection task is accomplised byIn c++ the garbage collection task is accomplised by
mark and sweep algorithm.mark and sweep algorithm.
 In this approach the garbage collector periodicallyIn this approach the garbage collector periodically
examines every single pointer in our program andexamines every single pointer in our program and
find that the memory is still in use. At the end of thefind that the memory is still in use. At the end of the
cycle, any memory that has not been marked iscycle, any memory that has not been marked is
deemed to be not in use and is freed.deemed to be not in use and is freed.

Steps to implement the garbageSteps to implement the garbage
collectioncollection
 Mark and sweep algorithm could be implemented in c++Mark and sweep algorithm could be implemented in c++
if we arere willing to do the following:if we arere willing to do the following:
1.1. Register all pointers with the garbage collector so that itRegister all pointers with the garbage collector so that it
can easily walk through the list of all pointers.can easily walk through the list of all pointers.
2.2. Sub-class all objects from a mix-in class, that allows theSub-class all objects from a mix-in class, that allows the
garbage collectors to mark an object as in-use.garbage collectors to mark an object as in-use.
3.3. Protect concurrent access to objects by making sure thatProtect concurrent access to objects by making sure that
no changes to pointers can occur while the garbageno changes to pointers can occur while the garbage
collector is running.collector is running.

Memory management in c++Memory management in c++
 Ways of memory allocation in c++Ways of memory allocation in c++
 Static memory allocationStatic memory allocation
 The memory allocation for variables ,during compilation timeThe memory allocation for variables ,during compilation time
itself is known as static memory allocation.itself is known as static memory allocation.
 Once the memory allocated at the compile time then it can notOnce the memory allocated at the compile time then it can not
be expanded nor be compressed to accommodate more or lessbe expanded nor be compressed to accommodate more or less
data during program execution.data during program execution.
 The size of memory to be allocated is known before compileThe size of memory to be allocated is known before compile
time and is fixed it can not be altered during execution.time and is fixed it can not be altered during execution.
 Int a[10];Int a[10];

Dynamic memory allocationDynamic memory allocation
 The dynamic memory allocation is carried-out inThe dynamic memory allocation is carried-out in
c++ using two operators “new” and “delete”.thesec++ using two operators “new” and “delete”.these
operators are use to allocate and free memory atoperators are use to allocate and free memory at
run time.run time.
 Dynamic memory allocation helps in memoryDynamic memory allocation helps in memory
saving and easy to change memory allocation.saving and easy to change memory allocation.
 In c++ dynamic memory allocation is control byIn c++ dynamic memory allocation is control by
NEW and DELETE operator.NEW and DELETE operator.
 The new operator return the memory pointer to theThe new operator return the memory pointer to the
pointer variable.pointer variable.

 Syntax:Syntax:
Ptr= new data type;Ptr= new data type;
Delete Ptr;Delete Ptr;
Ptr is pointer and data type is valid data typePtr is pointer and data type is valid data type
 The difference between NEW and malloc function is thatThe difference between NEW and malloc function is that
NEW automatically calculates the size of operand , dos notNEW automatically calculates the size of operand , dos not
use size of operator and NEW does not require an explicituse size of operator and NEW does not require an explicit
type cast.type cast.
 Versions of NEW and DELETEVersions of NEW and DELETE
 in c++ NEW and DELTE should be used like malloc and free toin c++ NEW and DELTE should be used like malloc and free to
ensure the proper calling of constuctor and destructor for theensure the proper calling of constuctor and destructor for the
classes.classes.
 Both have two versionsBoth have two versions
1.1. NEW and DeleteNEW and Delete
2.2. NEW[] and DELETE []NEW[] and DELETE []
 First two are for pointers to single objects, and last two forFirst two are for pointers to single objects, and last two for
arrays of objects.arrays of objects.

Difference between static andDifference between static and
dynamic memory allocationdynamic memory allocation
Static memory allocation Dynamic memory allocation
Static memory is allocated automatically
by compiler when definition statements
are encountered.
Dynamic memory is allocated only when
there is explicit call to malloc, calloc or
realloc function.
To make static memory allocation , the
amount of the memory space to be
reserved should be known at the run time.
Amount of memory to be reserved can be
given at the run time.
In static memory allocation sometimes
memory wastage occurs because memory
is already known and it can not change.
Memory wastage is avoided due to
memory allocation occur at run time.
Memory allocated at the compile time has
static lifetime.
Memory allocated at run time has
dynamic lifetime.
Its is faster it is slower

Meta classMeta class
 aa meta classmeta class is ais a classclass whose instances are classes.whose instances are classes.
Just as an ordinary class defines the behavior ofJust as an ordinary class defines the behavior of
certain objects, a meta class defines the behavior ofcertain objects, a meta class defines the behavior of
certain classes and their instances.certain classes and their instances.
 a meta class is defines as class of the class.a meta class is defines as class of the class.
 A meta class hold the attributes and function whichA meta class hold the attributes and function which
will appli to the class itself therefore it is class ofwill appli to the class itself therefore it is class of
class.class.

Friend functionFriend function
 C++ allows a way through which a function canC++ allows a way through which a function can
access the private data of a class.access the private data of a class.
 Such a function need not be a class member, it maySuch a function need not be a class member, it may
be member function of another class or may be nonbe member function of another class or may be non
member function.member function.
 This function is called FRIEND FUNCTION. TheThis function is called FRIEND FUNCTION. The
declaration should be preceded by keyworddeclaration should be preceded by keyword
FRIEND.FRIEND.

Class PQrClass PQr
{{
Private:Private:
………………
Public:Public:
…………
…………
Friend void abc();Friend void abc();
};};
 The function is definedThe function is defined
elsewhere in the program likeelsewhere in the program like
normal function.normal function.
 Function definition does not useFunction definition does not use
either keyword FRIEND oreither keyword FRIEND or
scope operator.scope operator.
 Functions that are declared withFunctions that are declared with
FRIEND keyword are known asFRIEND keyword are known as
friend functions.friend functions.

 A function can declared as friend in number of class.A function can declared as friend in number of class.
 A friend function has full access right to access theA friend function has full access right to access the
private members of class.private members of class.
 Member function of one class can be friend ofMember function of one class can be friend of
another class.another class.

CharacteristicsCharacteristics
 It is not in the scope of the class in which it has beenIt is not in the scope of the class in which it has been
declared as friend.declared as friend.
 it is not in the scope of class so it cannot be calledit is not in the scope of class so it cannot be called
using object of that class.using object of that class.
 It can be invoked like normal function ,withoutIt can be invoked like normal function ,without
object.object.

 It can be declared either in public or private part withIt can be declared either in public or private part with
out affecting its meaning.out affecting its meaning.
 Usually, it has the objects as arguments.Usually, it has the objects as arguments.
 Unlike member function, it cannot access the memberUnlike member function, it cannot access the member
names directly and has to use an object name and dotnames directly and has to use an object name and dot
membership operator with each name. likemembership operator with each name. like
 A.hA.h

Friend FunctionFriend Function
{{
public:public:
friend Complex sum (Complex A, Complex B);friend Complex sum (Complex A, Complex B);
};};
{{
}}
{{
elseelse
}}
Complex sum (Complex A, Complex B)Complex sum (Complex A, Complex B)
{{
temp.real=A.real + B.real;temp.real=A.real + B.real;
temp.imag= A.imag + B.imag;temp.imag= A.imag + B.imag;
}}
{{
Z= sum (X,Y);Z= sum (X,Y);
}}

{{
public:public:
};};
{{
}}
{{
elseelse
}}
{{
}}
{{
}}
X Y Z

{{
public:public:
};};
{{
}}
{{
elseelse
}}
{{
}}
{{
}}
5
6
7
8
X Y Z

{{
public:public:
};};
{{
}}
{{
elseelse
}}
{{
}}
{{
}}
5
6
7
8
X Y Z
7
8
B
5
6
A

{{
public:public:
};};
{{
}}
{{
elseelse
}}
{{
}}
{{
}}
5
6
7
8
X Y Z
7
8
B
5
6
A
+
+
=
=
temp

{{
public:public:
};};
{{
}}
{{
elseelse
}}
{{
}}
{{
}}
5
6
7
8
X Y Z
7
8
B
5
6
A
12
14
+
+
=
=
temp

{{
public:public:
};};
{{
}}
{{
elseelse
}}
{{
}}
{{
}}
5
6
7
8
12
14
X Y Z
7
8
B
5
6
A
12
14
+
+
=
=
temp

{{
public:public:
};};
{{
}}
{{
elseelse
}}
{{
}}
{{
}}
12 + 14 i12 + 14 i
5
6
7
8
12
14
X Y Z
7
8
B
5
6
A
12
14
+
+
=
=
temp

 We can also declare all the member functions of oneWe can also declare all the member functions of one
class as the friend functions of another class. In thisclass as the friend functions of another class. In this
case the first class is known as FRIEND class.case the first class is known as FRIEND class.
 This can be specified as follows :-This can be specified as follows :-
Class zClass z
{{
……………………....
…………
Friend class x;Friend class x;
};};

A function friend in two classesA function friend in two classes
Void max(XYZ m,ABC n)Void max(XYZ m,ABC n)
{{
If(m.x>=n.a)If(m.x>=n.a)
Cout<<m.x;Cout<<m.x;
ElseElse
Cout<<n.a;Cout<<n.a;
}}
Int main ()Int main ()
{{
ABC abc;ABC abc;
abc..setvalue(10);abc..setvalue(10);
XYZ xyz;XYZ xyz;
Xyz.setvalue(20);Xyz.setvalue(20);
max(xyz,abc);max(xyz,abc);
Return 0;Return 0;
}}
Class ABC;Class ABC;
Class XYZClass XYZ
{ int x;{ int x;
Public:Public:
Void setvalue(int i)Void setvalue(int i)
{ x=i ; }{ x=i ; }
Friend void max(XYZ,ABC);Friend void max(XYZ,ABC);
};};
Class ABCClass ABC
{{ int a;int a;
Public:Public:
void setvalue(int i)void setvalue(int i)
{{ a=i ;}a=i ;}
Friend void max(XYZ,ABC);Friend void max(XYZ,ABC);
};};

Pass by referencePass by reference
Class class_2;Class class_2;
Class class_1Class class_1
{{ int value1;int value1;
Public:Public:
void indata(int a)void indata(int a)
{{ value1=a;value1=a; }}
Void display()Void display()
{{ cout<<value1<<“n”;cout<<value1<<“n”; }}
Friend void exchange(class_1 &,Friend void exchange(class_1 &,
class_2 &);class_2 &);
};};
Class class_2Class class_2
{{ int value2;int value2;
public:public:
void indata( int a)void indata( int a)
{{ value2=a;value2=a; }}
{{ cout<<value2<<“n”;cout<<value2<<“n”; }}
Friend void exchange(class_1Friend void exchange(class_1
&,class_2 &);&,class_2 &);
};};
Contd…

Void exchange(class_1 & x,class_2Void exchange(class_1 & x,class_2
& y)& y)
{{ int temp=x.value1;int temp=x.value1;
x.value1=y.value2;x.value1=y.value2;
y.value2=temp;y.value2=temp;
}}
{{
class_1 c1;class_1 c1;
Class_2 c2;Class_2 c2;
C1.indata(100);C1.indata(100);
C2.indata(200);C2.indata(200);
Cout<<“values beforeCout<<“values before
exchange”<<“n”;exchange”<<“n”;
C1.dispaly();C1.dispaly();
C2.display();C2.display();
Exchange(c1,c2);Exchange(c1,c2);
Cout<<“values afterCout<<“values after
exchange”<<“n”;exchange”<<“n”;
Return 0;Return 0;
}}

Define a class tour in C++ with theDefine a class tour in C++ with the
description given below:description given below:
Private members:Private members:
tcodetcode of type stringof type string
NoofadultsNoofadults of type integerof type integer
NoofkidsNoofkids of type integerof type integer
KilometersKilometers of type integerof type integer
TotalfareTotalfare of type floatof type float
Public members:Public members:
 A constructor to assign initial values as follows:A constructor to assign initial values as follows:
Tcode with the word “NULL”Tcode with the word “NULL”
Noofadults as 0Noofadults as 0
Noofkids as 0Noofkids as 0
Kilometers as 0Kilometers as 0
Totalfare as 0Totalfare as 0
 A function assignfare( ) which calculates and assigns the value of data member totalfare as follows:A function assignfare( ) which calculates and assigns the value of data member totalfare as follows:
for each adultfor each adult
Fare (Rs.)Fare (Rs.) For KilometersFor Kilometers
500500 >=1000>=1000
300300 < 1000 & >= 500< 1000 & >= 500
200200 < 500< 500
for each kid the above fare will be 50% of the fare mentioned in the above table for example:for each kid the above fare will be 50% of the fare mentioned in the above table for example:
if kilometers is 850, noofadults =2 and noofkids = 3if kilometers is 850, noofadults =2 and noofkids = 3
then totalfare should be calculated asthen totalfare should be calculated as
noofadults * 300 + noofkids * 150noofadults * 300 + noofkids * 150
I.e. 2 * 300 + 3 * 150 = 1050I.e. 2 * 300 + 3 * 150 = 1050
 A function entertour( ) to imput the values of the data members tcode, noofadults, noofkids andA function entertour( ) to imput the values of the data members tcode, noofadults, noofkids and
kilometers and invoke assignfare( ) function.kilometers and invoke assignfare( ) function.
 A function showtour ( ) which displays the contents of all the data members for a tour.`````A function showtour ( ) which displays the contents of all the data members for a tour.`````

class tourclass tour
{{
char tcode[15];char tcode[15];
int noofadults;int noofadults;
int noofkids;int noofkids;
int kilometers;int kilometers;
float totalfare;float totalfare;
public:public:
tour( )tour( )
{{
strcpy(tcode,”null”);strcpy(tcode,”null”);
noofadults=0;noofadults=0;
noofkids=0;noofkids=0;
kilometers=0;kilometers=0;
totalfare=0;totalfare=0;
}}
void assignfare( )void assignfare( )
{{
if (kilometers>=1000)if (kilometers>=1000)
totalfare= 500 * noofadults + 250 *totalfare= 500 * noofadults + 250 *
noofkids;noofkids;
else if (kilometers>=500)else if (kilometers>=500)
noofkids;noofkids;
elseelse
noofkids;noofkids;
}}
void entertour( )void entertour( )
{{
cout<<“enter tcode:”;cout<<“enter tcode:”;
gets(tcode);gets(tcode);
cout<<“enter noofadults:”;cout<<“enter noofadults:”;
cin>>noofadults;cin>>noofadults;
cout<<“enter noofkids:”;cout<<“enter noofkids:”;
cin>>noofkids;cin>>noofkids;
cout<<“enter kilometers=“;cout<<“enter kilometers=“;
cin>>kilometers;cin>>kilometers;
}}
void showtour ( )void showtour ( )
{{
cout<<“tcode=“<<tcode;cout<<“tcode=“<<tcode;
cout<<“nnumber ofcout<<“nnumber of
adults=“<<noofadults;adults=“<<noofadults;
cout<<“nnumber of kids=“<<noofkids;cout<<“nnumber of kids=“<<noofkids;
cout<<“nkilometers=“<<kilometers;cout<<“nkilometers=“<<kilometers;
cout<<“ntotalfare=“<<totalfare;cout<<“ntotalfare=“<<totalfare;
}}
};};

Define a class HOUSING in C++Define a class HOUSING in C++
with the following descriptions:with the following descriptions:
(4)(4) private members:private members:
 REG_NOREG_NO integer (ranges 10-1000)integer (ranges 10-1000)
 NAMENAME array of characters (string)array of characters (string)
 TYPETYPE charactercharacter
 COSTCOST floatfloat
 Public members:Public members:
 function read_data( ) to read an object of HOUSING type.function read_data( ) to read an object of HOUSING type.
 Function display ( ) to display the details of an object.Function display ( ) to display the details of an object.
 Function draw_nos( ) to choose and display the details of 2Function draw_nos( ) to choose and display the details of 2
houses selected randomly from an array of 10 objects of typehouses selected randomly from an array of 10 objects of type
HOUSING. Use random function to generate the registrationHOUSING. Use random function to generate the registration
nos. to match with REG_NO from the array.nos. to match with REG_NO from the array.

class HOUSINGclass HOUSING
{{
int REG_NO;int REG_NO;
char NAME[20], TYPE;char NAME[20], TYPE;
float COST;float COST;
public:public:
void read_data( )void read_data( )
{{
cout<<“Enter Registration Number=“;cout<<“Enter Registration Number=“;
cin>>REG_NO;cin>>REG_NO;
cout<<“Enter Name=“;cout<<“Enter Name=“;
gets(NAME);gets(NAME);
cout<<“Enter Type=“;cout<<“Enter Type=“;
cin>> TYPE;cin>> TYPE;
cout<<“Enter Cost=“;cout<<“Enter Cost=“;
cin>>COST;cin>>COST;
}}
void display ( )void display ( )
{{
cout<<“Registration No.”<<REG_NO;cout<<“Registration No.”<<REG_NO;
cout<<“nName=“;cout<<“nName=“;
puts(NAME);puts(NAME);
cout<<“nType=“<<TYPE;cout<<“nType=“<<TYPE;
cout<<“nCost=“<<COST;cout<<“nCost=“<<COST;
}}
void draw_nos( )void draw_nos( )
{{
int no1, no2;int no1, no2;
randomize( );randomize( );
no1=random(1991)+10;no1=random(1991)+10;
no2=random(1991)+10;no2=random(1991)+10;
for (int i=0; i<10; i++)for (int i=0; i<10; i++)
if (arr[i].REG_NO==no1|| arr[i].REG_NO==no2)if (arr[i].REG_NO==no1|| arr[i].REG_NO==no2)
display();display();
}}
};};
HOUSING arr[10];HOUSING arr[10];

functionfunction
 Void show();Void show(); function declarationfunction declaration
 Main()Main()
 {{
 Show();Show(); function callfunction call
}}
Void show()Void show() function definitionfunction definition
{{
……………………
……………… function bodyfunction body
}}

Function prototypeFunction prototype
 Introduce first in c++.Introduce first in c++.
 Prototype describe the function interface ti the compilerPrototype describe the function interface ti the compiler
by giving details (number and type of arguments andby giving details (number and type of arguments and
return type)..return type)..
 Type function name (arguments list). ;Type function name (arguments list). ;
 Ex:-Ex:-
 float add(int k,int g);float add(int k,int g);
 float add(int k,g); illegalfloat add(int k,g); illegal
 float add (int ,int){name of the argumentsfloat add (int ,int){name of the arguments
are optional}are optional}

 In function definition arguments names are requiredIn function definition arguments names are required
because the arguments must be refereced inside thebecause the arguments must be refereced inside the
function ex:-function ex:-
 Float volume(int a,float b,float c);Float volume(int a,float b,float c);
 {{
 Float v=a * b * c;Float v=a * b * c;
 }}
 The function calling should not include type names in theThe function calling should not include type names in the
argument list.argument list.

Call by referenceCall by reference
 When we pass arguments by reference then the argumentWhen we pass arguments by reference then the argument
in the called function become alias to the actual argumentsin the called function become alias to the actual arguments
in the calling function .in the calling function .
 When function is working its own arguments, its worksWhen function is working its own arguments, its works
on the original arguments.on the original arguments.
 In c++ this task is perform by making reference variableIn c++ this task is perform by making reference variable
to the actual arguments.to the actual arguments.

Call by value.Call by value.
 When a function call passes arguments by value, theWhen a function call passes arguments by value, the
called function creates a new set of variable and copiescalled function creates a new set of variable and copies
the values of arguments into them, this process is knownthe values of arguments into them, this process is known
as call by value.as call by value.
 Function does not have access to the actual variables inFunction does not have access to the actual variables in
the calling program and can work on the copies of values.the calling program and can work on the copies of values.

Inline functionInline function
 Inline is a function that expanded in a line when it is invoked.Inline is a function that expanded in a line when it is invoked.
 The compiler replaces the function call by its correspondingThe compiler replaces the function call by its corresponding
code.code.
 Syntax:Syntax:
 Inline return type function nameInline return type function name
 {{
 Function bodyFunction body
 }}

 Improve the execution speed.Improve the execution speed.
 Reduces the memory requirement of function execution.Reduces the memory requirement of function execution.
 All inline function must be defined before they called.All inline function must be defined before they called.
 The speed benefits of inline function diminish as theThe speed benefits of inline function diminish as the
function grows in size.function grows in size.
 A function definition in a class definition is an inlineA function definition in a class definition is an inline
function definition, even without the use of thefunction definition, even without the use of the inlineinline
specifier.specifier.

 Where inline may not workWhere inline may not work
 For functions returning values , if a loop, switch, gotoFor functions returning values , if a loop, switch, goto
statements.statements.
 Functions not returning values, if return exists.Functions not returning values, if return exists.
 If function contain static variables.If function contain static variables.
 If inline functions are recursiveIf inline functions are recursive
 When function call becomes small compare to functionWhen function call becomes small compare to function
execution.execution.

 #include<iostream.h>#include<iostream.h>
 Inline float add(float x , float y)Inline float add(float x , float y)
 {{
 Return (x+y);Return (x+y);
 }}
 Inline float sub(float p , float q )Inline float sub(float p , float q )
 {{
Return(p-q);Return(p-q);
}}
{{
Float a=12.34;Float a=12.34;
Float b=3.6Float b=3.6
Cout<<add(a,b)<<endl;Cout<<add(a,b)<<endl;
cout<<sub(a,b)<<endl;cout<<sub(a,b)<<endl;
Return 0;Return 0;
}

Default argumentsDefault arguments
 A default argument is a value given in the functionA default argument is a value given in the function
declaration that the compiler automatically inserts if thedeclaration that the compiler automatically inserts if the
caller does not provide a value for that argument in thecaller does not provide a value for that argument in the
function call.function call.
 Syntax:Syntax:
return_type f(…, type x = default_value,…);

Default argumentsDefault arguments
 Default values are specified when the function is declared.Default values are specified when the function is declared.
 We must add default values from right to left ,we can notWe must add default values from right to left ,we can not
provide a default value to a particular arguments in theprovide a default value to a particular arguments in the
middle of argument list.middle of argument list.
 Default arguments are useful in situations where someDefault arguments are useful in situations where some
arguments always have the same value.arguments always have the same value.

Default ArgumentsDefault Arguments
(Examples)(Examples)
 doubledouble powpow((doubledouble x,x, intint n=2)n=2)
 // computes and returns x// computes and returns xnn
The default value of the 2nd
argument is 2.
This means that if the programmer calls pow(x), the
compiler will replace that call with pow(x,2), returning
x2

Default ArgumentsDefault Arguments
(Rules)(Rules)
 Once an argument has a default value, all the argumentsOnce an argument has a default value, all the arguments
after it must have default values.after it must have default values.
 Once an argument is defaulted in a function call, all theOnce an argument is defaulted in a function call, all the
remaining arguments must be defaulted.remaining arguments must be defaulted.
int f(int x, int y=0, int n)
// illegal
int f(int x, int y=0, int n=1)
// legal

Examples:-Examples:-
 Int mul(int I,int j=6,int l=9); legalInt mul(int I,int j=6,int l=9); legal
 Int mul(int I,int j=6,int l); illegalInt mul(int I,int j=6,int l); illegal
 Int mul(int I=0,int j,int l=9); illegalInt mul(int I=0,int j,int l=9); illegal
 Int mul(int I=0,int j=6,int l=9); legalInt mul(int I=0,int j=6,int l=9); legal
 Advantages:-Advantages:-
 We can default arguments to add new parameters to theWe can default arguments to add new parameters to the
existing functions.existing functions.
 Default arguments can be used to combine similarDefault arguments can be used to combine similar
functions into one.functions into one.

Function overloadingFunction overloading
 When using more than one functions with same name andWhen using more than one functions with same name and
with different arguments in a program is known aswith different arguments in a program is known as
function overloading or function polymorphism.function overloading or function polymorphism.
 Function overloading is part of polymorphism.Function overloading is part of polymorphism.

 Function would perform different operations dependingFunction would perform different operations depending
on the argument list in function call.on the argument list in function call.
 Correct function to be invoked is determined by checkingCorrect function to be invoked is determined by checking
the number and type of arguments but not on return typethe number and type of arguments but not on return type
of function.of function.
 Examples;-Examples;-
 Int area(int,int);Int area(int,int);
 Int area(int ,float);Int area(int ,float);

 Examples :-Examples :-
 Int add(int a, int b);Int add(int a, int b);
 Int add(int a, int b, int c);Int add(int a, int b, int c);
 Double add(double x, double y);Double add(double x, double y);
 Double add(int p ,double q);Double add(int p ,double q);
 Double add(double p, int q);Double add(double p, int q);
 Function callsFunction calls
 Add(5,19);Add(5,19);
 Add(16,7.9);Add(16,7.9); Add(12.4,3.5);Add(12.4,3.5);
 Add (4,12,23);Add (4,12,23); Add(3.4,7)Add(3.4,7)
Function prototype 1
Function prototype4

 A function call first match the prototype having the sameA function call first match the prototype having the same
number and type of actual arguments and then calls thenumber and type of actual arguments and then calls the
appropriate function for execution…appropriate function for execution…

 A function match includes following steps:-A function match includes following steps:-
1.1. Compiler first try to find exact match in which the typesCompiler first try to find exact match in which the types
of actual arguments are the same.of actual arguments are the same.
2.2. If exact match not found, compiler uses the integralIf exact match not found, compiler uses the integral
promotions to the actual arguments like char to int, floatpromotions to the actual arguments like char to int, float
to double.to double.

3.3. When either of them fail then compiler uses built inWhen either of them fail then compiler uses built in
conversion to the actual arguments and then uses theconversion to the actual arguments and then uses the
function whose match is unique.function whose match is unique.
4.4. If all of the steps fail then the compiler will try userIf all of the steps fail then the compiler will try user
defined conversions in combination with integraldefined conversions in combination with integral
promotions and built in conversions to find a uniquepromotions and built in conversions to find a unique
match.match.

ConstructorsConstructors
andand
DestructorsDestructors

ConstructorConstructor
 It is a member function which initializes theIt is a member function which initializes the
objects of its class.objects of its class.
 A constructor has:A constructor has:
(i) the same name as the class itself(i) the same name as the class itself
(ii) no return type(ii) no return type ,not even void.,not even void.
 It constructs the values of data member soIt constructs the values of data member so
that it is called constructor.that it is called constructor.

 A constructor isA constructor is called automaticallycalled automatically
whenever a new object of a class iswhenever a new object of a class is
created.created.
 You mustYou must supply the argumentssupply the arguments to theto the
constructor when a new object is created.constructor when a new object is created.
 If you do not specify a constructor, theIf you do not specify a constructor, the
compiler generates a default constructorcompiler generates a default constructor
for you (expects no parameters and hasfor you (expects no parameters and has
an empty body).an empty body).

{{
rectangle rc(3.0, 2.0);rectangle rc(3.0, 2.0);
rc.posn(100, 100);rc.posn(100, 100);
rc.draw();rc.draw();
rc.move(50, 50);rc.move(50, 50);
rc.draw();rc.draw();
}}
 WarningWarning: attempting to initialize a data: attempting to initialize a data
member of a class explicitly in the classmember of a class explicitly in the class
definition is a syntax error.definition is a syntax error.

Declaration and definationDeclaration and defination
Class complexClass complex
{{
Int m,n;Int m,n;
Public:Public:
complex();complex();
};};
complex :: complex ()complex :: complex ()
{{
m=0;n=0;m=0;n=0;
}}

 A constructor that accepts no parameters isA constructor that accepts no parameters is
called default constructor.called default constructor.

characteristicscharacteristics
1.1. They should be declared in public section.They should be declared in public section.
2.2. Invoked automatically when class objects areInvoked automatically when class objects are
created.created.
3.3. They do not have return types, not even voidThey do not have return types, not even void
and they can't return any value.and they can't return any value.
4.4. They cannot be inherited,though a derivedThey cannot be inherited,though a derived
class can call the base class constructors.class can call the base class constructors.

5. They also default arguments like other5. They also default arguments like other
functions.functions.
6. They implicitly call the NEW and DELETE6. They implicitly call the NEW and DELETE
operators when memory allocation is required.operators when memory allocation is required.
7. Constructors can not be virtual.7. Constructors can not be virtual.

Parameterized constructorsParameterized constructors
 The constructors that can take arguments areThe constructors that can take arguments are
called parameterized constructors.called parameterized constructors.
 It is used when we assign different value toIt is used when we assign different value to
the data member for different object.the data member for different object.
 We must pass the initial values as argumentsWe must pass the initial values as arguments
to the constructors when an object isto the constructors when an object is
declared.declared.

 This can be done in two ways:-This can be done in two ways:-
 ByBy calling the constructors implicitlycalling the constructors implicitly
 Class_name object(arguments);Class_name object(arguments);
 Ex:- simple s(3,67);Ex:- simple s(3,67);
 This method also known as shorthand.This method also known as shorthand.
 ByBy calling the constructors explicitlycalling the constructors explicitly
 Class_name object =constructor(arguments);Class_name object =constructor(arguments);
 Ex:- simple s=simple(2,67);Ex:- simple s=simple(2,67);
 This statement create object s and passes the values 2This statement create object s and passes the values 2
and 67 to it.and 67 to it.

Example:-Example:-
Class integerClass integer
{{ int m,n;int m,n;
public:public:
integer(int,int);integer(int,int);
void display()void display()
{{ cout<<“m”<<m;cout<<“m”<<m;
cout<<“n”<<n;cout<<“n”<<n; }}
};};
Integer::integer(int x,int y)Integer::integer(int x,int y)
{{
m=x;m=x;
n=y;n=y;
}}
{{
Integer i1(10,100);Integer i1(10,100);
Integer i2=integer(33,55);Integer i2=integer(33,55);
Cout<<“object 1”;Cout<<“object 1”;
i1.display();i1.display();
Cout<<“object 2”;Cout<<“object 2”;
i2.display();i2.display();
Return 0;Return 0;
}}

Notes:-Notes:-
 A constructor function canA constructor function can
also be defined as INLINEalso be defined as INLINE
function.function.
{{ int m,n;int m,n;
public:public:
integer (int x,int y)integer (int x,int y)
{{ m=x;m=x;
n=y;n=y;
}};}};
 Parameters of aParameters of a
constructor can be of anyconstructor can be of any
type except that of thetype except that of the
class to which it belongs.class to which it belongs.
Class AClass A
{{
………………..
…………..
Public:Public:
A(A);A(A);
};}; is illegalis illegal

 A class can accept aA class can accept a
reference of its own classreference of its own class
as parameter.as parameter.
Class AClass A
{{
………………
…………………………
Public:Public:
A(A&);A(A&);
};};
is validis valid
 In this case theIn this case the
constructor is called asconstructor is called as
copy constructor.copy constructor.

Copy constructorCopy constructor
 When a class reference is passed as parametersWhen a class reference is passed as parameters
in constructor then that constructor is calledin constructor then that constructor is called
copy constructor.copy constructor.
 A copy constructor is used to declare andA copy constructor is used to declare and
initialize an object from another object.initialize an object from another object.
 Synatx:-Synatx:-
 Constructor _name (class_name & object);Constructor _name (class_name & object);
 Integer (integer &i);Integer (integer &i);

 Integer i2(i1);/integer i2=i1;Integer i2(i1);/integer i2=i1;
 Define object i2 and initialize it with i1.Define object i2 and initialize it with i1.
 The process of initialization object through copyThe process of initialization object through copy
constructor is known as copy initialization.constructor is known as copy initialization.
 A copy constructor takes a reference to an objectA copy constructor takes a reference to an object
of the same class as itself as argument.of the same class as itself as argument.

 #include<iostream.h>#include<iostream.h>
Class personClass person
{{ public:public:
int age;int age;
Person(int a)Person(int a)
{ age = a; }{ age = a; }
Person(person & x)Person(person & x)
{{ age=x.age;age=x.age;
}}
};};
int main()int main()
{{
Person timmy(10);Person timmy(10);
Person sally(15);Person sally(15);
Person timmy_clone = timmy;Person timmy_clone = timmy;
cout << timmy.age << " " <<cout << timmy.age << " " <<
sally.age << " " <<sally.age << " " <<
timmy_clone.age << endl;timmy_clone.age << endl;
timmy.age = 23;timmy.age = 23;
cout << timmy.age << " " <<cout << timmy.age << " " <<
sally.age << " " <<sally.age << " " <<
timmy_clone.age << endl;timmy_clone.age << endl;
}}

Dynamic constructorsDynamic constructors
 Constructors can also be used to allocateConstructors can also be used to allocate
memory while creating objects.memory while creating objects.
 This will allocate the right amount for eachThis will allocate the right amount for each
object when the objects are not of the sameobject when the objects are not of the same
size.size.
 Allocation of memory to objects at the time ofAllocation of memory to objects at the time of
their construction is known as dynamictheir construction is known as dynamic
construction is known as “dynamicconstruction is known as “dynamic
construction of objects”.construction of objects”.
 The memory is allocated by NEW operator.The memory is allocated by NEW operator.

#include<string.h>#include<string.h>
Class stringClass string
{{
char *name;char *name;
int length;int length;
Public:Public:
string()string()
{{
length =0;length =0;
name = newchar[length+1];name = newchar[length+1];
}}
string(char *s)string(char *s)
{{
length=strlen(s);length=strlen(s);
name=new char [length+1];name=new char [length+1];
strcpy(name,s );strcpy(name,s );
}}
{{ cout<<name<<“n”;}cout<<name<<“n”;}
void join (string &a,string & b);void join (string &a,string & b);
};};
void string:: join(striing&a,string &b)void string:: join(striing&a,string &b)
{{ length =a.length+b.length;length =a.length+b.length;
delete name;delete name;
name =new char [length+1];name =new char [length+1];
strcpy(name,a.name);strcpy(name,a.name);
strcpy(name,b.name);strcpy(name,b.name);
}}
{{ char *first =“jon”;char *first =“jon”;
string name1(first),name2(tom),name3(jery),s1,s2;string name1(first),name2(tom),name3(jery),s1,s2;
s1.join(name1.name2);s1.join(name1.name2);
s2.join(s1,name3);s2.join(s1,name3);
name1.display();name1.display();
s1.display();s1.display();
s2.display();s2.display();
return 0;return 0;
}}

Constructor overloadingConstructor overloading
{multiple constructor in a class}{multiple constructor in a class}
 When more than one function is defined in a class ,When more than one function is defined in a class ,
is known as constructor overloading.is known as constructor overloading.
 Example:-Example:-
{{ int m,n;int m,n;
public:public:
integer()integer()
{{ m=0;m=0; n=0;n=0; }}
Integer (int a,int b)Integer (int a,int b)
{{ m=a;n=bm=a;n=b }}
Integer(integer&i)Integer(integer&i)
{{ m=i.m;m=i.m;
n=i.n;n=i.n; }};}};

Class complexClass complex
{{ float real,imag;float real,imag;
public:public:
complex(){ }complex(){ }
complex(float x)complex(float x)
{{ real=imag=x;}real=imag=x;}
complex(float c, float d)complex(float c, float d)
{{ real=c;real=c; imag =imag =
d;d; }}
friend complex sumfriend complex sum
(complex,complex);(complex,complex);
friend display(complex);friend display(complex);
};};
Complex sum (complex c1, complex c2)Complex sum (complex c1, complex c2)
{{ complex c3;complex c3;
c3.real =c1.real +c2.real;c3.real =c1.real +c2.real;
c3.imag=c1.imag+c2.imag;c3.imag=c1.imag+c2.imag;
Return(c3);Return(c3);
}}
Void display(complex d)Void display(complex d)
{{ cout<<c.real<<“+j”<<c.imag;cout<<c.real<<“+j”<<c.imag;
}}
{{
complex a(3.4,6.7);complex a(3.4,6.7);
complexb(2.5);complexb(2.5);
complex c;complex c;
c= sum(a,b);c= sum(a,b);
cou<<“a=”;display(a);cou<<“a=”;display(a);
cout<<“b=”;display(b);cout<<“b=”;display(b);
cout<<“c=”;display(c);cout<<“c=”;display(c);
}}

 Constructors are also define with defaultConstructors are also define with default
argumentsarguments
 Complex (float real ,float imag=0);Complex (float real ,float imag=0);
 It will invoke by following way complex c(5),It will invoke by following way complex c(5),
this statement assign 5 to real and the defaultthis statement assign 5 to real and the default
value already assigned to imag.value already assigned to imag.
 We can also invoke it like complex(5,3.4),it willWe can also invoke it like complex(5,3.4),it will
assign values both real and imag meansassign values both real and imag means
overwrite the new value to imag value.overwrite the new value to imag value.

Dynamic initialization of objectsDynamic initialization of objects
 Objects can be initialized dynamically,initialObjects can be initialized dynamically,initial
value of objects are provided during runvalue of objects are provided during run
time.time.
 Advantage of it we can provide variousAdvantage of it we can provide various
initialization formats by constructorinitialization formats by constructor
overloading.overloading.

Class fixed_depositClass fixed_deposit
{{
long int pamount;long int pamount;
int y;int y;
float r;float r;
float rvalue;float rvalue;
Public:Public:
fixed_deposit() { }fixed_deposit() { }
fixed_deposit(long int p,int y1,float r1=0.2);fixed_deposit(long int p,int y1,float r1=0.2);
fixed_deposit(long int p,int y1, int r1);fixed_deposit(long int p,int y1, int r1);
void display();void display();
};};
Fixed_deposit :: fixed_deposit(long int p,int y1,Fixed_deposit :: fixed_deposit(long int p,int y1,
float r1)float r1)
{{ pamount =p;pamount =p;
y=y1;y=y1;
r=r1;r=r1;
rvalue=(pamount*y*r)rvalue=(pamount*y*r) ;;
Rvalue=rvalue/100;Rvalue=rvalue/100;
}}
Fixed_deposit :: fixed_deposit(long int p, intFixed_deposit :: fixed_deposit(long int p, int
y1,int r1)y1,int r1)
{{ pamount=p;pamount=p;
y=y1;y=y1;
r=r1;r=r1;
rvalue=pamount;rvalue=pamount;
for(int i=1;i<=y1;i++)for(int i=1;i<=y1;i++)
rvalue =rvalue*(1+float(r)/100);}rvalue =rvalue*(1+float(r)/100);}
Void fixed_deposit :: display()Void fixed_deposit :: display()
{{
cout<<“n”cout<<“n”
<< “pricipal amount”<<pamount<<“n”<< “pricipal amount”<<pamount<<“n”
<<“return value”<<rvalue<<“n”;<<“return value”<<rvalue<<“n”;
}}
{{
fixed_deposit fd1,fd2,fd3;fixed_deposit fd1,fd2,fd3;
long int p;int y1; float r; int R;long int p;int y1; float r; int R;
Cout<<“enter amount,period,intrest rate inCout<<“enter amount,period,intrest rate in
percent”<<“n”;percent”<<“n”;
Cin>>p>>y>>R;Cin>>p>>y>>R;
Fd1=fixed_deposit(p,y,R);Fd1=fixed_deposit(p,y,R);

Cout<<“enter amount,period,intrest rate inCout<<“enter amount,period,intrest rate in
decimal ”<<“n”;decimal ”<<“n”;
Cin>>p>>y>>r;Cin>>p>>y>>r;
Fd2=fixed_deposit(p,y,r);Fd2=fixed_deposit(p,y,r);
Cout<<“enter amount and peroid”<<“n”;Cout<<“enter amount and peroid”<<“n”;
Cin>>p>>y;Cin>>p>>y;
Fd3=fixed_deposit(p,y);Fd3=fixed_deposit(p,y);
Cout<<“ndeposit 1”;Cout<<“ndeposit 1”;
Fd1.display();Fd1.display();
Cout<<“n deposit 2”;Cout<<“n deposit 2”;
Cout<<“n deposit 3”;Cout<<“n deposit 3”;
Return 0;Return 0;
}}

DestructorsDestructors
 A destructor is used to destroy the objects thatA destructor is used to destroy the objects that
have been created by constructor.have been created by constructor.
 It is also a member function of class whoseIt is also a member function of class whose
name same as class name but preceded by tiledname same as class name but preceded by tiled
sign(~).sign(~).
 It never takes any arguments nor return anyIt never takes any arguments nor return any
value.value.
 It will be invoked implicitly by the compilerIt will be invoked implicitly by the compiler
upon exit from the program to clean up theupon exit from the program to clean up the
storage which is allocatedstorage which is allocated

 The new operator is used in constructor toThe new operator is used in constructor to
allocate memory and delete is used to free inallocate memory and delete is used to free in
destructors.destructors.
 Expl:-Expl:- ~assign()~assign()
 {{
 Delete p;Delete p;
}}

Int count =0;Int count =0;
Class tryClass try
{{ public:public:
try()try()
{{
count++;count++;
Cout<<“no of objects created”<<count;Cout<<“no of objects created”<<count;
}}
~try()~try()
{{
cout<<“no of object destroyed”<<count;cout<<“no of object destroyed”<<count;
Count- -;Count- -;
}};}};
int main()int main()
{{
cout<< “enter main”;cout<< “enter main”;
try t1,t2,t3,t4;try t1,t2,t3,t4;
{{
cout<<“block1”;cout<<“block1”;
try t5;try t5;
}}
{{
cout<<“block 2”;cout<<“block 2”;
try t6;try t6;
}}
cout<<“again in main”;cout<<“again in main”;
Return 0;Return 0;
}}

Class and object in C++

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Class and object in C++ (20)

More from rprajat007 (7)

Recently uploaded (20)

Class and object in C++