ifjp; (Introduction): - tSlk fd ge igys Hkh ppkZ dj pqds gSa fd Class C++ dk lcls

egRoiw.kZ xq.k gSaA C++ ds vanj Class dk egRo dks bl izdkj le>k tk ldrk gSa
fd C++ dk igys fu/kkZfjr fd;k xk; uke 'Class ds lkFk C' (C with Classes) j[kk x;k
FkkA C++ esa Class dk iz;ksx lEHkor% C esas Structure dk mUur fl)kUr gSaA
Class iz;ksDrk ifjHkkf"kr Data Type ds fuekZ.k rFkk mls dk;kZfUor djus dk ,d
u;k rjhdk Hkh gSaA C++ tSlk fd ,d C dk gh mUur laLdj.k gSa vr% C ds oLrqr
% izk;% xq.k blesa lekfgr djus dk iz;kl fd;k x;k gSaA C++ C esa ifjHkkf"kr
lHkh lajpukvksa (Structures) dks vuqeksfnr djus ds vykok iz;ksDrk ifjHkkf"kr
(User-defined) Data rFkk iwoZ&fufeZr (built-in) Data ds varj dks cgqr gh de ls de
djus dk iz;kl fd;k djrk gSaA blds vfrfjDr blea Data dh lqj{kk ds n`f"Vdks.k ls
bls ckgjh gLr{ksi ls cpkus ds fy;s fNikus (hiding) dh Hkh lqfo/kk miyC/k gSaA
C++ esa oa'kkuqØe (Inheritance) dk iz;kstu gSa rkfd ,d Data dk izdkj nwljs Data
izdkj ds y{k.kksa dks Hkh mi;ksxh esa yk ldsaA

Class dk o.kZu djuk (Specifying A Class)

Class Data rFkk blls lEcfU/kr Function dks lkFk ck¡/kus (Bind) dh ,d fof/k gSaA ;g
Data dks ckgjh gLr{ksi ls cpkus ds mn~ns'; ls fNikus dh O;oLFkk Hkh j[krk
gSaA
Class ds nks izdkj ls of.kZr (Specify) fd;k tk ldrk gSa &
(a) Class ?kks"k.kk (class declaration)
(b) Class Function ifjHkk"kk (Class Function Definition)

Class ?kks"k.k blds lnL;ksa (Members) ds izdkj rFkk {ks= (Scope) dks Li"V djrk
gSaA Class Function ifjHkk"kk (Class Function Definitions) Function ds dk;kZUo;u dk
o.kZu djrk gSaA Class ?kks"k.k (Class Declaration) dk lkekU; rjhdk bl izdkj gSa
&
Class Class_name
{
Private :

variable declarations;
function declarations;
Public :
variable declarations;
function declarations;

}
Class ?kks"k.kk (Class Declaration) Struct ?kks"k.k ds leku gksrk gSa rFkk
Key-Board Class ds ckn vkus okyk Class_name dk vewrZ vFkok lkj (Abstract) Data
gksrk gSaA Class dk eq[; Hkkx dks"Bdksa (braces) esa can gksrk gSa rFkk og
lsehdkWyu (:) ds lkFk lekIr gksrk gSa tSlkfd vki mij ds mnkgj.k esa ns[k ldrs
gSaA
lnL; (Members): - Class esa nksi zdkj ds ?kks"k.kk (Declarations) gksrs
gSa & Variables rFkk nwljk Functions rFkk budks ml Class dk lnL; (Members) dgk
tkrk gSaA lnL; izk;% nks oxZ ds gksrs gSa& futh (Private) rFkk lkoZtfud
(Public)A
futh lnL; (Private Member): - oSls lnL; ftudh ?kks"k.kk futh oxZ ds vanj
fd;k gksrk gSa] dsoy class ds vanj ls gh Access fd;s tk ldrs gSaA bl izfØ;k esa
Data dks ckgjh gLr{ksi ls cpk;k tkrk gSa tks fd Object Oriented Programming ds

-1–
eq[; vk/kkjksa eas ,d gSaA Private Key-word dk iz;ksx ,sfPNd gSa D;ksafd Class
ds ;s lnL; By Default futh gksrs gSaA gk¡ ;fn vkius Public yscy fy[kuk NksM+
fn;k rks lHkh lnL; futh (Private) le>s tk;saxsaA
Data Members: - Class ds vanj ?kksf"kr fd;s x;s Variables Data Members
dgykrs gSaA
Member Functions: - Class ds vanj ?kksf"kr fd;s x;s Member Function
dgykrs gSaA Members Function Private data members rFkk Private Functions dk iz;ksx
dj ldrs gSaA fdUrq] lkoZtfud lnL; (Function & Data) dks Class ds ckgj ls Access
fd;k tkrk gSaA

Private :
izos'k Variable declaration (data)
izfrcaf/kr function declaration
Public :
izos'k Variable declaration (data)
vuqer function declaration (data)

mnkgj.kLo:i ,d lkekU; Class ?kks"k.kk (Class Declaration) dks ns[ksa %

Class commodity
{
int number;
float rate;
public :
void getdata(int n, float r);
void putdata(void);
}
mijksDr mnkgj.k esa class dks commodity dk uke fn;k x;k gSa tks ,d u;s
Identifier esa bl Class ds mnkgj.kksa (Instances) dks ?kksf"kr djus dk dk;Z lEiUu
djsxkA bl Class esa nks data lnL; besa By Default futh (Private) gSa tcfd nksuks
function lkoZtfud (Public) gSaA getdata() uked Function dk iz;ksx Number rFkk Rate
nksuks Variable dks euk fu/kkZfjr djsaxs rFkk putdata( ) mu ekuksa dks
iznf'kZr djus ds fy;s iz;ksx esa yk, tkrs gSaA

lnL; QaD'ku dks ifjHkkf"kr djuk (Defining Member Functions)

Member Function fdlh Class ?kks"k.kk ds vUnj vFkok ckgj ifjHkkf"kr fd;s tk ldrs
gSaA ;fn Member Function cgqr NksVk gSa rks bls Class esa gh ifjHkkf"kr fd;k
tk ldrk gSaA bl izdkj dh Function ifjHkk"kk,sa inline dgykrh gSaA

Dykl ds vUnj dh ifjHkk"kk (Inside the Class Definition)

mnkgj.k 1 % bl mnkgj.k esa commodity Dykl dks blds vanj ifjHkkf"kr
djsaxsA
//Example of Member Function Definition
//Inside Class Declaration
Class commodity
{
private :
int a;
float rate;

-2–
 public :
void getdata(int a, float r);
void putdata( );
{
cout <<a;
cout << r;
}
};
bl Class esa nks public Function ifjHkkf"kr gSa] getdata( ) vkSj putdata( )A
mYys[kuh; gSa fd Function ds dksM (Code) Hkh class dh ifjHkk"kk esa fy[k fn;s
x;s gSaA blds foijhr ;fn lnL; QaD'ku vkdkj esa cM+s gksrs gSa rks mUgsa
Class dh ifjHkk"kk ds ckgj ifjHkkf"kr djuk pfkg;sA ;|fi bl Function dk
izksVksVkbi class ifjHkk"kk esa fy[kuk vko';d gSaA
Dykl ds ckgj dh ifjHkk"kk (Outside the class definition)
// Function definition outside the class declaration
void commodity : : getdata(int a, float b)
{
number = a;
rate = b;
}
void commodity : : putdata( )
{
cout << number <<"\n";
cout << rate <<"\n";
}
vc ge ,d ,slk izksxzke rS;kj djrs gSa ftlesa Object rS;kj fd;k tk; tks
rkieku dks fMxzh lsfYl;l ls fMxzh QkjsugkbV esa vkSj fMxzh QkjsugkbV ls
fMxzh lsfYl;l esa ifjofrZr djrk gSaA ge tkurs gSa fd ,d Object rS;kj djus ls
iwoZ bl Object ds Class dks ?kksf"kr djuk vko';d gSaA ekuk tempconvt uke dk
class gSaA
//Declaration of Class TEMPCONVT
class tempconvt
{
private :
float c, f;
public :
float c_to_f(float i); //prototype of the function to convert 0C to 0F
float f_to_c(float j); //prototype of the function to convert 0F to 0C
};
;gk¡ c vkSj f Variable Private gSa vSkj c_to_f( ) vkSj f_to_c( ) Function public
gSaA c_to_f( ) Function fMxzh lsfYl;l ls fMxzh QkjusgkbV esa ifjorZu djrk gSa]
tcfd f_to_c( ) Function fMxzh QkjusgkbV ls fMxzh lsfYl;l esa ifjorZu djrk
gSaA ;g Function Member Function dgykrs gSaA vr% lnL; Function dks class ds
ckgj fuEu izdkj ifjHkkf"kr fd;k tk;sxk &
//Declaration of Function c_to_f( )
float tempconvt : : c_to_f(float i)
{
f = 1.8 * i + 32;
return (f);
}

-3–
 // declaration fo function f_to_c( )
float temconvt : : f_to_c(float j)
{
c = (j – 32)/1.8;
return (c);
}

lnL; QaD'ku ?kks"k.kk dk izk:i (Format of A Member Function Declaration)

<Vkbi> <class dk uke> :: QaD'ku dk uke (iSjkehVj)
{
QaD'ku ckWMh (Function Body)
}
;gk¡ <Vkbi> : QaD'ku }kjk ykSVk, tkus okys QaD'ku dk uke gSaA
<class dk uke> : ml class dk ue gSa ftlls QaD'ku lac) gSaA
QaD'ku dk uke : ?kksf"kr fd;s tkus okys QaD'ku dk uke gSaA
iSjkehVj : Format arguments gSaA
mi;qZDr fooj.k ls Li"v gSa fd class data vkSj QaD'kuksa dks ,d bdkbZ
esa ,dtqV (combine) djrk gSaA ;g xfrfof/k ,udSIlwys'ku (encapsulation) dgykrh
gSaA

Ldksi jstksY;w'ku vkWijsVj (Scope Resolution Operator)

;gk¡ :: vkWijsVj] Scope resolution vkWijsVj dgykrk gSaA ;g lnL; QaD'ku
dks mlls lEcfU/kr class dks layXu (associate) djrk gSaA mnkgj.kkFkZ mi;qZDr
QaD'ku ?kks"k.kk esa vkWijsVj :: dEikbyj dks crkrk gSa fd c_to_f( ) vkSj
f_to_c( ) QaD'ku] class tempconvt ds lnL; gSaA

vkWCtsDV rS;kj djuk (Creating Objects)

Object ,d Class dk ,d n`"VkUr dk mnkgj.k gksrk gSaA Object blds Class ds
uke ls rS;kj fd;k tkrk gSa vkSj bldk Type, Class dk type dh gksrk gSaA Object
ifjHkkf"kr djus ds fy;s fuEufyf[kr izk:i (Syntax) iz;ksx fd;k tkrk gSaA
<Dykl dk uke> <vkWCtsDV dk uke>;
mnkgj.kkFkZ] ctemp dk uke dk vkWCtsDV] temp_covt class ds fy;s fuEu
izdkj ?kksf"kr fd;k tkrk gSa&
temp_convt ctemp;
mi;qZDr ?kks"k.kk ls ;g Li"V gksrk gSa fd temp_convt Dykl dk vkCtsDV
ctemp gSaA blfy;s Dykl ,d ,slk Vkbi gSa tks MkVk vkSj QaD'kuksa dks ijLij
cka/krk gSaA vr% Class Abstract Data Type (ADT) Hkh dgykrk gSaA

ckgjh QaD'ku dks buykbu cukuk (Making Outside Function Inline)

Object Oriented Programming ds mn~ns';ksa esa ,d ;g Hkh gSa fd Dykl ifjHkk"kk
ls dk;kZUo;u ds forj.k dks vyx j[kk tk;A blhfy; lnL; QaD'ku dh ifjHkk"kk Dykl
ls ckgj nh tkrh gSaA
ge lnL; QaD'ku dks Dykl ds ckgj ifjHkkf"kr dj ldrs gSa rFkk blds fy;s
QaD'ku ifjHkk"kk ds gSMj ykbu ij DokfyQk;j (Qualifier) inline dk iz;ksx dj bls
buykbu (Inline) cuk ldrs gSaA
mnkgj.kLo:i bls ns[ksa&
class commodity
{
int number;

-4–
 float rate;
public :
void getdata(int n, float r); //?kks"k.kk (declaration)
};
inline void commodity : : getdata(int n, float r) //ifjHkk"kk (definition)
{
number =n;
rate = r;
}

lnL; QaD'ku dk usfLVax (Nesting of Member Functions)

ge fdlh Dykl ds lnL; QaD'ku dks ml class ds Object }kjk MkWV vkWijsVj
(. operator) dk iz;ksx dj dkWy Hkh dj ldrs gSaA fdUrq bldk ,d viokn gSaA ,d
lnL; QaD'ku vius uke ls mlh class dks nwljs lnL; QaD'ku ds vanj cqyk;k tk
ldrk gSaA bls lnL; QaD'ku dk usfLVax dgrs gSaA bl fØ;k ij vk/kkfjr bl
izksxzke dks ns[ksa &
//Program to find out the smaller number
# include <isotream.h>
class number
{
int a, b;
public :
void input(void);
void disp(void);
int smaller(void);
};
int number : : smaller(void)
{
if (a <= b)
return(a);
else
return(b);
void number : : input(void)
{
count << "Input a and b" << "\n";
cin >> a>> b;
}
void number :: disp(void)
{
cout<<"Smaller Number=" <<smaller() << "\n";
}
int main( )
{
number A;
A.input();
A.disp();
return ();
}
mijksDr izksxzke dks fØ;kfUor djus ij bl izdkj dk ifj.kke iznf'kZr gksxk &
Input a and b

-5–
 10 12
Smaller value 10

futh lnL; QaD'ku (Private Member Function)

Program fodkl ds nkSj dqN function ,sls gksrs gSa ftUga cgqr gh futh
j[kus dh vko';drk gksrh gSaA ,sls Function dks ge Program dks futh Hkkx esa
j[krs gSaA
futh lnL; Function fdlh nwljs Function ds }kjk rc gh iz;ksc fd;k trkk gSa tc
og ml class dk lnL;k gksA ;gk¡ rd fd dksbZ Object Hkh futh Function dks Dot
Operator dh lgk;rk fd dk;kZfUor ugha dj ldrkA mnkgj.kLo:i bls ns[ksa &
class temp
{
int n;
void study( );
public :
void read( );
void write( );
};
t1.study( );
mijksDr dFku t1.study dk;Z ugha djsxk D;ksafd study futh Function gSa
rFkk bls dkWy ugha fd;k tk ldrk gSaA fdUrq Function tSls study( ) read( ) ds }kjk
iz;ksx esa yk;k tk ldrk gSaA tSls &
void temp : : read(void)
{
study( ); //blesa dsoy study dks dkWy fd;k tk jgk gSa rfkk
blds lkFk dksbZ Object iz;ksx ugha f;dk tk jgk gSaA
}

Class esa vuqfoU;kl (Arrays within A Class)

fdlh class esa vuqfoU;kl (Arrays) blds Data lnL;ksa ds :i esa iz;qDr fd;s tk
ldrs gSa vkSj ;s class dh lwpuk Object esa ls izkIr djrs gSaA Objects ds fy;s
vf/kd ek=k ds MkVk dk mi;ksx djus ds fy;s class esa vuqfoU;kl dk iz;ksx fd;k
tkrk gSaA blds fy;s ge fuEufyf[kr mnkgj.k ij fopkj djrs gSaA
mnkgj.k % ,d izksxzke fy[kuk ftlesa fdlh item dh la[;k (number) vkSj
ykxr (cost) dks buiqV fd;k tk;s vksj ckn esa bls vkmViqV esa izLrqr fd;k tk;sA
# include <iostream.h>
# include <conio.h>
class item
{
int number[10];
char it_code[10];
float cost[10];
public :
void getdata(void);
void putdata (void);
int i, n;
};
void item : : getdata( )
{
cout << "\n Enter total No. of Items";

-6–
 cin >> n;
for (i = 0; i <n; i ++)
{
cout << "\n Enter Item code";
cin >> it_coe[i];
cout << "\n Enter No. of items";
cin >> number[i];
cout << "\n Enter cost";
cin >> cost[i];
}
}
void item : : putdata( )
{
for(i = 0; i<n; i++)
{
cout << "\n Item Code =" <<it_code[i];
cout << "\n Number of Items =" << number[i];
cout << "\n Total cost =" << cost[i] * number[i];
}
}
void main( )
{
clrscr( );
item x;
x.getdata( );
x.putdata( );
} //End of Main Function

Object ds fy;s eSeksjh vkoaVu (Memory Allocation for objects)

Object ds fy;s eseksjh esa LFkku ml le; vkoafVr fd;ktkrk gSa tc mUgsa
?kksf"kr djrs gSaA ;g dFku iwjh rjg lgh ugha gSaA oLrqr% lnL; Function cuk;s
tkrs gSa vkSj eSeskjh esa rc gh lax`ghr fd;s tkrs gSa tc og Class ds ,d vax
ds :i esa ifjHkkf"kr gksrs gSaA pw¡fd lHkh Object tks ,d fo'ks"k class ls
lEcfU/kr gksrs gSa vkSj ,d gh izdkj ds lnL; function dk iz;ksx djrs gSa rFkk bl
dkj.k lnL; Function ds fy;s Object ds fy;s LFkku vkoafVr fd;s tkrs gSaA ;gk¡ ij
Object ds fy, Memory dk vkoaVu blfy;s fd;k tkrk gSa D;ksafd Member Variables
fofHkUu Object ds fy;s fofHkUu eku j[krs gSaA

lHkh Object ds fy;s lkekU;

QaD'ku
lnL; QaD'ku 1 dks
ifjHkkf"kr
lnL; djus ds
QaD'ku 2 nkSjku
vkWCtsDV 1 vkWCtsDV 2 eseksjh
vkWCtsDV 3 Object dks
dk vkoaVu
lnL; QaD'ku 1 lnL; QaD'ku 1 lnL; QaD'ku 1 ifjHkkf"kr
djus ds
lnL; lnL; lnL; nkSjku
QaD'ku 2 QaD'ku 2 QaD'ku 2 esekssjh
dk vkoaVu

-7–
 vkWCtsDV ds fy;s eseksjh dk vkoaVu

LFkk;h MkVk lnL; (Static Data Member)

fdlh Class ds MkVk lnL; dks LFkk;h (Static) dgk tk ldrk gSaA LFkk;h
MkVk lnL; o lnL; Variable dks fuEufyf[kr xq.k gSa &
 blds Class ds igys Object dk eku 0 ('kwU;) ekuk tkrk gSaA blds
vfrfjDr dksbZ eku dh vuqefr ugha gSaA
 iwjs Class ds fy;s ml lnL; dh ,d izfr (Copy) cukbZ tkrh gSa rFkk bls
ml Class ds lHkh Object }kjk lk>kk fd;k tkrk gSaA blds fy;s Object
dh la[;k pkgs ftruh Hkh gks
 ;g dsoy Class ds vanj n`'; (visible) gksrk gSaA
LFkk;h Data lnL; o lnL; Variable dk iz;ksx iwjs class ds lkekU; ekuksa dks
cuk, j[kus ds fy;s fd;k tkrk gSaA mnkgj.kLo:i LFkk;h MkVk lnL; ,d x.kd ds :i
esa gksrk gSa tks lHkh Object ds mifLFkfr dks Record djrk gSaA
#include<iostream.h>
class item
{
static int counter;
int number;
public :
void getdata(int p)
{
number = p;
counter++;
}
void getcount( )
{
cout << "count :";
cout << counter <<"\n";
}
};
in item :: counter;
main( )
{
item x, y;
x.getcount( );
y.getcount( );
x.getdata(10);
y.getdata(20);
cout << "After reading data" <<"\n";
x.getcount( );
y.getcount( );
return ();
}
ifj.kke % count : 0
count : 0
After reading data
count : 2

-8–
 count : 2
mijksDr Program esa LFkk;h (Static) Variable Counter izkjEHk esa 'kwU;
gksrk gSa tc Object curk gSaA Counter esa ,d o`f) gksrh gSa tc Data ,d Object
esa nks ckj i<+k tk jgk gSa] counter nks ckj o`f) gksrk gSa vkSj D;ksafd
counter dh izfr nksuksa Object ds }kjk lk>k fd;k tkrk gSa] nksuksa vkmViqV
dFku 2 eku dks iznf'kZr djrs gSaA
;gk¡ /;ku nsus ;ksX; ckr ;g gSa fd izR;sd LFkk;h lnL; Data dk izdkj rFkk
{ks= (Scope) class ifjHkk"kk ds ckgj ifjHkkf"kr fd;k tkuk pkfg;sA bldh vko';drk
blfy;s gSa D;ksafd LFkk;h Data lnL; Object ds Hkkx ds :i esa lax`fgr u gksdj
vyx lax`fgr gksrs gSaA LFkk;h MkVk lnL; dks class Variable (Class variables)
Hkh dgrs gSa D;ksa os lh/ks&lh/ks class ls gh tqM+s gksrs gSaA

LFkk;h lnL; QaD'ku (Static Member Functions)

LFkk;h lnL; osfj;scy dh rjg] ge LFkk;h lnL; Function Hkh j[k ldrs gSaA dksbZ
Member Function tks LFkk;h ?kksf"kr fd;k tkrs gSa fuEufyf[kr xq.kksa dks
lekfgr djrs gSa &
 LFkk;h Function ml class ds nwljs LFkk;h Data ;k Function dks Access
dj ldrs gSaA
 LFkk;h Member Function Class ds uke ls iz;ksx fd;s tk ldrs gSa tSls
&
Name of Class : : Name of Function
fuEufyf[kr Program esa bu y{k.kksa dks dk;kZfUor fd;k x;k gSaA
Showcount( ) LFkk;h (Static) Function ml le; rd cus Object dh la[;k dks iznf'kZr
djrk gSa rFkk Counter LFkk;h Variable cuk;s x;s Object dh la[;k dh x.kuk djrk
gSaA ns[ksa Program –
#include<iostream.h>
class run
{
int cd;
static int counter;
public :
void seted( )
{
cd = ++counter;
}
void showcd( )
{
cout << "object number :" <<cd <<"\n";
}
static void showcount( )
{
cout << "count :" <<counter<<"\n";
}
};
int run : : counter;
main( )
{
run t1, 12;
t1.setcd( );
t2.setcd( );

-9–
 run : : showcount( );
run t3;
t3.setcd( );
run : : showcount( );
t1.showcd( );
t2.showcd( );
t3.showcd( );
return ();
}
mijksDr Program esa ;g dFku
Code = ++ counter;
fØ;kfUor gksrk gSa tc setcd( ) Function lfØ; gksrk gSa vkSj counter dk
rRdky eku Code ea tek gksrk gSaA pw¡fd izR;sd Object ds code dh viuh izfr
(Copy) gksrh gSa] code dk eku vf}rh; (Unique) gksrk gSaA
mijksDr Program dk ifj.kke bl izdkj gksxk &
Count : 2
Count : 3
Object number : 1
Object number : 2
Object number : 3

vkWCtsDV ds vuqfoU;kl (Array of Objects)

C++ esa class, Objects ds vuqfoU;kl dks O;Dr dj ldrh gSa ftlls Object ds
Variable esa vf/kd ek=k esa eku laxzfgr fd;s tk ldrs gSa vkSj buk mi;ksx
Public Member Function esa fd;k tk ldrk gSaA Objects dks buds lwpdkad (Index
Number) }kjk fLFkr o izkIr fd;k tkrk gSa ftldk eku Data ds Type ds vuqlkj gksrk
gSa mnkgj.kkFkZ &
class XX
{
char a[30];
int e;'
public :
void accept( );
void give( );
};

Class dh bl ?kks"k.kk esa XX ,d Class gSa ftlesa nks Private Member 'a' vkSj 'e'
rFkk Public Member accept function vkSj give Function gSaA XX Class ds }kjk Objects
ds vuqfoU;kl O;Dr fd;s tk ldrs gSa ftlls fofHkUu Objects esa vf/kd ek=k esa
eku laxzfgr fd;s tk ldrs gSaA
xx Y[20];
;gk¡ XX class vuqfoU;kl y dks O;Dr djsxk] ftlls eseksjh esa 20 Data eku
Private Member ds :i esa laxzfgr fd;s tk ldrs gSaA Function ds call djus esa
Objects dks eku fn;s tkrs gSa] tSls &
y[1] .accept( );
;g Object dh izFke eseksjh fLFkfr esa izFke lnL; dk eku accept function
ds }kjk izkIr djrk gSaA blh izdkj eseksjh dh vU; fLFkfr;ksa ds fy;s Object ds
vU; 15 eku Hkh izkIr fd;s tk ldrs gSaA

- 10 –
 mnkgj.k 5 % ,d Program fy[kuk ftlesa N la[;k esa fo|kfFkZ;ksa ds
fjdkMZ Objects ds vuqfoU;kl esa v Input fd;s tk;sa vkSj fo|kfFkZ;ksa dh lwph
fuEu izk:i esa Nis &

List of Students
Name Roll No. Grade
... ... ...
... ... ...
... ... ...
... ... ...

Student ds Record dk <kapk fuEu izdkj gksxk &

Name Roll No. Grade

fo|kfFkZ;ksa dks Grade fuEufyf[kr fu;eksa ls fn;k tk;sxk &

Marks Grade
< 200 D
>= 200 < 240 C
>= 240 < 320 B
>= 320 A

gy % blds fy;s ge student uke dk Class mi;ksx djsaxs] ftlesa fo|kFkhZ dk

record laxzfgr gksxk vkSj Data Input djus ds fy;s] Grade dh x.kuk djus ds
fy;s ,oa fo|kFkhZ ds Data iznf'kZr djus ds fy;s mfpr Functions dk mi;ksx djrs
gSaA
Student
Name
roll_no
marks
grade
read_data( )
compute_grade( )
display_data( )

// The Program Reads the records of N Students in

// An array of Object and compute their Grade
# include Miostream.h>
# include (conio.h>
# include Mstdio.h>
# include <iomanip.h>
class student
{
char name[15];
int rollno;
int marks;
char grade;
public :
void read_data( );

- 11 –
 void compute_grade( );
void display_data( );
}
void student : : read_data( )
{
gets(name)
fflush(stdin);
cin >> rollno >> marks;
}
void student : : compute_grade;
{
if(marks < 200>
grade = 'D';
else if(marks <240)
grade = 'C';
else if(marks < 320)
grade = 'B';
else
grade = 'A';
}
void student : : display_data( )
{
compute_grade( );
count << end1 << setw(9) << name << setw(7) << rollno. <<setw(5) << grade;
}
void main( )
{
int n;
student stud list[50];
count << "\n Enter The Number of students";
cin >> n;
for(int i = 0; i<n; i ++)
stud_list[i] .read_data( );
clrscr( );
cout << "\n NAME ROLL NO GRADE";
for(i = 0; i < n; i++)
stud_list[i] .display_data( );
} //End of main function

QaD'ku vkX;wZesUV ds :i esa vkWCtsDV (Objects As Function Arguments)

C++ Hkk"kk esa vkWCtsDV iwoZ fufeZr Data Type ds :i esa ekuk tkrk gSa]
vkSj fdlh Function esa Argument ds :i esa izf"kr (Pass) fd;k tk ldrk gSaA Object
dks Function esa izsf"kr djus ds fy;s fuEufyf[kr fof/k;ksa esa ls fdlh ,d dk
mi;ksx fd;k tkrk gSa &
1. Pass by value (eku }kjk izs"k.k)
2. Pass by reference (irs }kjk izs"k.k)

eku }kjk isz"k.k (Pass By value) – bl fof/k esa Function dks Object dh ,d
izfr (Copy) izf"kr fd;k tkrk gSa vr% QaD'ku ds vanj Object esa fd;s x;s
la'kks/ku dk izHkko ml ewy Object ij ugha iM+rk gSa ftldh Copy Pass dh x;hA

- 12 –
 fjÝsUl }kjk izs"k.k (Pass by reference) – blesa Object dk irk (Address)
Function dks izsf"kr fd;k tkrk gSaA QyLo:i] Function tks Hkh dk;Z ml Object ij
djrk gSa mldk izHkko mlds ewy Object ij lh/ks&lkh/ks iM+rk gSa rFkk lkFk
gh og Hkh la'kksf/kr gks tkrk gSaA fjÝsUl }kjk izs"k.k T;knk l{ki gksrk gSa
D;ksafd blesa iwjs Object dks izf"kr djus dh ctk; dsoy mldk irk gh izsf"kr
gksrk gSaA

mnkgj.k 6 % ,d Program fy[kuk ftlesa ,d esfVªDl (Matrix) dks Input fd;k

tk;s vkSj blds NORM dh x.kuk dh tk;sA
gy % fdlh eSfVªDl dk NORM mlds vO;oksa ds oxksZa ds ;ksx oxZewy
gksrk gSaA bl Program esa Class mat-op dk izk:i esa fuEu izdkj gksxk &
mat_op
i, j, m, n
mat[ ] [ ]
reat_mat( )
compute_norm( )
display_mat( )
//Reads A Matrix And Compute Its Norm
# include <iostream.h>
# include <math.h>
#include <conio.h>
// CLASS DECLARATION
class mat_op
{
int i, j, m, n;
int mat[10] [10];
public :
void read_mat( );
int compute_norm( );
void display mat( );
};
void mat_op : : read_mat( )
{
cout << "\n Enter The Matrix :";
for(i = 0; i < m; i ++)
for(j = 0; j<n; j ++)
cin >> mat[i] [j];
}
int mat_op : : compute_norm( )
{
int sum = 0;
for(i = o; i <m; i ++)
for(j = 0; j < n; j ++)
sum + = mat[i][j]; * mat[i][j];
return(sqrt (sum));
}
void mat_op : : display_mat( )
{
clarscr( );
cout << "\n The Matrix Is :";

- 13 –
 for(i = 0; i < m; i ++)
{
cout << "\n";
for(j =0; j < n; j ++)
cout << mat[i][j] <<" ";
}
}
int get_norm(mat_op X); // Prototype Declaration
void main( )
{
int norm_of_mat;
mat_op mat_obj;
// Read Matrix
mat_obj . read_mat( );
// Send Mat_obj By Value to get_norm function
norm_of_mat = get_norm(mat_obj);
mat_obj . display_mat( );
cout << "\n The Norm of the Matrix Is \n" << norm_of_mat;
getch( );
}
// Function that Receives And object
int get_norm(mat_op x)
{
int res;
res = x . compute_norm( );
return(res);
}

UNIT – I
INTRODUCTION: -
(i) bls AT&T Bell laboratories esa cuk;k x;k FkkA
(ii) bls 1980 ds n'kd esa Bjarnc stroustrup }kjk cuk;k x;k FkkA
(iii) ;g ,d iqjkuh Object oriented language 'Simula 67' ij vk/kkfjr FkhA
(iv) C++ dh lQyrk dk jkt mldh Object oriented technology gSa ftls real world
}kjk vklkuh ls viuk;k tk ldrk gSaA

OOP Concepts: - Object oriented programming. S/w development dh vk/kqfud rduhd

gSa ftls lHkh Project development ds fy;s iz;ksx esa fy;k tkrk gSaA

Procedural V/s OOP Programming: -

(i) Procedural Programming: - Procedural language dk gj Program funsZ'kksa dk
lewg gSaA ftldk gj Statement computer dks dqN djus dk funsZ'k nsrk
gSaA vr% Focus flQZ Processing ij jgrk gSaA blds fy;s algorithm dh
vko';drk gksrh gSa vkSj mu algorithms esa ls best algorithm dks pquk tkrk
gSaA blds }kjk fdlh function esa arguments dks pass fd;k tkrk gSa rFkk
muds }kjk values dks return fd;k tkrk gSaA
(ii) OOP Programming: - Object Oriented approach esa problems dks Object ds :i
esa ns[kk tkrk gSaA Object ,d entity gsSa ftldh dqN fo'ks"krk,a o
behaviour gksrk gSaA
tSls 'Orange' ,d Object gSaA ftldh dqN fo'ks"krk,a gSa &

- 14 –
(1) ;g xksy gksrh gSaA (2) bldk colour orange gksrk gSa vkfnA
rFkk bldk behaviour: - (i) ;g jlhyh gksrh gSa (ii) ;g taste esa [kV~Vh ehBh gksrh
gSaA Object Oriented Programming ds vUrxZr Object mu entity dks iznf'kZr djrs
gSa ftlds }kjk data o functions dks store fd;k tkrk gSaA
bu lHkh objects dks ,d special entity esa group fd;k tkrk gSa ftls class dgrs
gSaA vr% 'Class' Objects dk group gSa tks Common Properties rFkk Relationships dks
Share djrh gSaA example: - 'CAR' ,d Object ugha cfYd ,d class gSaA 'Opel Astra' ,d
Object gSa tks 'Car' Class ds }kjk define fd;k x;k gSaA 'CAR' ,d vU; Class
'Automobiles' dh subclass gSa tks iqu% 'Vechicles' dh ,d sub class gSaA
vr% Object Oriented Programming, implementation dk ,d Method gSa ftlds }kjk
Programs dks Organize fd;k tkrk gSaA tSls] Collection of objects dks define djuk
gSa tks Class ds instance dks iznf'kZr djrk gSaA
Features of OOP's: - or C++: -
OOP's ,d approach gSa ftlds }kjk dqN Concepts dks define fd;k tkrk gSa ftlls vyx
vyx Programming Problems dks define fd;k tkrk gSaA tks fuEu gSa% &
(1) Data Abstraction (2) Data Encapsulation
(3) Modularity (4) Inheritance
(5) Polymorphism (6) Objects
(7) Classes.

(1) Data Abstraction: - Abstraction ds }kjk real world concept ds egRoiw.kZ

features dks iznf'kZr fd;k tkrk gSa ftlesa background details dks Include fd;k
tkrk gSaA
Example: - ;fn vki car drive dj jgs gSa rks ge flQZ car dks pykus ds vko';d
features gh irk gksrs gSa tSls% & Gear handling, steering, clutch dk mi;ksx brakes
vkfnA car pykrs le; flQz gear change fd;k tkrk gSa ;k brakes dks handle fd;k tkrk
gSa ijUrq internally D;k gks jgk gSa ;g User ls Hidden gksrk gSaA ;g abstraction
gSaA tgka flQZ egRoiw.kZ car driving concepts dks /;ku esa j[kk tkrk gSa]
ftlesa background details dks include ugha fd;k tkrk gSaA

(2) Encapsulation: - Encapsulation OOP's dk egRoiw.kZ Concept gSa] ftlesa data

rFkk data ij Operate gksus okys functions dks ,d single unit esa j[kk tkrk
gSaA vr% data rFkk blls related functions dks ,d Single unit esa j[kk tkrk
gSa ftls encapsulation dgrs gSaA
vr% data dks flQZ muds functions ds }kjk access fd;k tkrk gSaA bu
Function dks C++ esa Member functions ds uke ls tkuk tkrk gSaA data dks directly
access fd;k tkrk gSaA ;fn ge Object ds }kjk data item dks read djuk pkgrs gSa rks
blds fy;s Object ds }kjk Member functions dks Call fd;k tkrk gSaA vr%
Encapsulation data Abstraction Implement djus dk ,d rjhdk gSaA
fdlh Hkh Company esa vyx&vyx departments gksrs gSa] o gj department
vius&vius dk;Z dks access djrk gSaA
(3) Modularity: - fdlh Program dks Individual components esa divide djuk
Modularity dgykrk gSaA Program dks Partition djus ls% &
1) blls Program dh Complexity (tfVyrk) de gks tkrh gSaA
2) blds }kjk Program dh Well defined o documented boundaries dks Hkh
define fd;k tkrk gSaA
vr% Modularity ds vUrxZr System Properties dks cohesive o Loosely coupled modules
esa divide fd;k tkrk gsaA vr% Module vius vki esa ,d vyx Unit gSaA ftls Compile
Hkh vyx ls fd;k tkrk gSaA

- 15 –
 Example: - ekuk ,d Program music system dks iznf'kZr djrk gSaA Music
System esa speakers, cassette-player, record player, cd-player, tuner vkfn dks 'kkfey
fd;k tkrk gSaA vr% Program dks vyx&vyx Modules esa iznf'kZr fd;k tkrk gSa
ftlesa gj Module Speaker, record-player vkfn dks iznf'kZr fd;k tkrk gSaA gj Module
vius vki esa Complete unit gSa vkSj bUgsa rc bdV~Bk fd;k tkrk gSa tc ,d
Single goal dks iwjk djuk gksA
(4) Inheritance: - Inheritance ds vUrxZr ,d Class dh Properties dks nwljh class
}kjk access fd;k tkrk gSaA ge ,d class 'Human' ls dqN Properties dks 'inherit'
djrs gSa tSls & Speak, breath, eat, drink vkfnA ysfdu ;s Properties lHkh
Humans ds fy;s Unique ugha gksrhA Human ds }kjk bu Properties dks Class
"Mammal' ls Inherit fd;k tkrk gSaA Inheritance dks ifjHkkf"kr djus ds ,d
Example fuEu gSa% &

Vehicles

Auto Mobiles Pulled

Vehicles

CAR BUS CART Rick

Shaw

OOP's esa Inheritance dk Role: -

1) blds vUrxZr Real World models dh closeness dks iznf'kZr fd;k tkrk
gSaA
2) Reusability dks iznf'kZr fd;k tkrk gSaA Inheritance ds }kjk fdlh ,d
cuh gqbZ Class esa additional features dks include fd;k tkrk gSaA
3) Inheritance izd`fr ls transitive gksrh gSaA tSls ;fn Class A, B Class dh
properties dks inherit djrh gSa] rks A dh lHkh Sub Classes
Automatically B dh Properties dks inherit djrh gSaA
(5) Polymorphism: - Polymorphism ds }kjk Data ;k Message dks ,d ls T;knk Form
esa Process fd;k tkrk gSaA Polymorphism ds vUrxZr Class dk Object mlesa
Pass fd;s x;s vyx&vyx Messages ij dk;Z djrk gSaA tSls 'Human' 'Mammal' dh
Subclass gSa oSls gh 'Dog', 'Cat' vkfn Hkh 'Mammal' dh subclass gSaA
ijUrq ;fn ;g Message pass fd;k tk, fd 'see through day light' tks fd lHkh
Mammals ds fy;s gSaA rks ;g lHkh ds fy;s Pass gksxk ijUrq ;fn lHkh
Mammals dks 'See through night' message pass fd;k tk;s rks Humans o dogs
vkfn ds }kjk ;g laHko ugha gSaA ysfdu Cat ij ;g Message ykxw gksrk
gSaA ;gh Polymorphism gSaA
(1) Operator Overloading
(2) Function Overloading
(6) Objects: - Object Oriented System dh Run Time Entities dks Objects dgk tkrk
gSaA ftlds }kjk ,d Person, place, bank account vkfn dks Handle fd;k tkrk
gSaA tc Program execute gksrk gS rc Object ,d nwljs dks Message Hkstdj
interact djrs gSa rc Custumer dk Object account ds Object ls bank balance dh

- 16 –
 request djrk gSaA gj Object data rFkk data ij gksus okys Operation dks
Perform djrk gSaA example: -

Object : Emp
Data :
name
Date of joining
salary
functions:
calc_salary
display

BENEFITS OF OOP
OOP's dks iz;ksx esa ysus ls program designer o user nksuks dks cgqr Qk;ns
gSaA eq[; ykHk% &
1) Inheritance ds }kjk redundant (duplicate) code dks gVk;k tkrk gSaA
2) Programs dks modules ds :i esa cuk;k tk ldrk gSa ftlls development esa le;
de yxrk gSa rFkk Productivity Hkh high gksrh gSaA
3) Data hiding ds }kjk Program Code dks secure j[kk tk ldrk gSaA
4) Objects ds vk/kkj ij iwjs Project dks vklkuh ls NksVs&NksVs Parts esa
divide fd;k tk ldrk gSaA
5) Object Oriented System ds }kjk NksVs Programs dks vklkuh ls cM+s
Programs esa cnyk tk ldrk gSaA
6) software dh complexity (tfVyrk) dks vklkuh ls Handle fd;k tkrk gSaA

Data Types In C++

C++ dh data types dks nks Hkkxksa esa ckaVk x;k gSa% &
(i) Fundamental Types
(ii) Derived Types

FUNDAMENTAL DATA TYPES

int char float Double Void

Fundamental ;k Basic data types fdlh vU; data type ij fuHkZj ugha gksrh gSaA
1) int Data Type: -
(i) Integers dks whole number store djus ds fy;s iz;ksx esa fy;k tkrk gSa
ftudk dksbZ Fractional ;k decimal part ugha gksrk gSaA tSls% & 539, -
1970 vkfn integers gSa ijUrq 5.39, 5/2 vkfn dks integers ugha dgk tkrk
gSaA
(ii) C++ esa Integers dks 'int' data type }kjk iznf'kZr djrs gSaA
(iii) Int memory esa 2 Byte Space dks mi;ksx esa ysrk gSaA
(iv) C++ esa rhu izdkj ds integers dks define fd;k x;k gSa% &
1) Short 2) int 3) long
(1) Short integer de ls de 2 bytes ysrk gSaA
(2) int short ds cjkcj ;k mlls T;knk gksxk ijUrq 2 bytes Memory gh ysxkA
(3) Long integer de ls de 4 Bytes ysrk gSaA

- 17 –
2) Char Data Type: -
(i) Characters dks character set ds }kjk define fd;k tkrk gSaA
(ii) Characters dks define djus ds fy;s 'Char' Keyword Use esa fy;k tkrk gSaA
(iii) eq[;r% Character memory esa integer equivalent code ds :i esa Store jgrs
gSaA
(iv) char type dks izk;% integer type Hkh dgk tkrk gSa] D;ksafd blds }kjk
letters, symbols vkfn lHkh dks store fd;k tk ldrk gSaA
(v) Characters memory esa '1 Byte' space ysrs gSaA
(vi) Characters dks fuEu Hkkxksa esa ckaVk x;k gSa% 7

1) char 1 Byte -128 to 127

2) unsigned char 1 Byte 0 to 255
3) signed char 1 Byte Some as char

3) Float Data Type: -

(i) os Number ftUgsa Decimal }kjk iznf'kZr fd;k tkrk gSa floating point
numbers dgykrs gSaA tSls% & 3.14590 vkfnA
(ii) Floating point numbers dks define djus ds fy;s 'float' keyword dks mi;ksx
esa fy;k tkrk gSaA
(iii) Float memory esa 4Bytes space Use esa ysrs gSaA
Precision Digit
38 38
float 4Byte 3.4x10 to 3.4x10 7
4) Double Data Type: -
(i) double data type dks floating point numbers dks handle djus ds fy;s mi;ksx
esa fy;k tkrk gSaA
(ii) ;g float ls double vr% 8bytes dk Memory Space ysrk gSaA
(iii) bls Float ls cM+h Value Store djus ds fy;s mi;ksx esa fy;k tkrk gSaA

Precision Digit
double 8Byte 1.7x10-308 to 1.7x10308 15

Precision Digit
-4932 4932
Long double 10Bytes 3.4x10 to 3.4x10 19
5) Void Data Type: -
(i) void ds }kjk Empty Set of values dks Specify fd;k tkrk gSaA
(ii) bls function dh return type ds :i esa mi;ksx esa fy;k tkrk gSaa
(iii) void type ds Object dks define ugha fd;k tkr ldrkA

Derived Data Types

Fundamental data type ds }kjk dqN vU; Data types dks derive fd;k x;k gSa tks fuEu
gSa% &

Derived Data Types

Array function Pointer reference Constants

1) Arrays: -

- 18 –
 (i) Same data type dh cgqr lh Values dks ,d lkFk j[kdj mUgsa ,d specific
uke ns fn;k tkrk gSaA bl izdkj ds concept dks arrays dgrs gSaA
(ii) Memory esa ;s values yxkrkj ,d ds ckn ,d Store jgrh gSaA
(iii) Array define djus ds fy;s [ ] Brackets esa array size dks define fd;k tkrk
gSaA
(iv) Array 1-Diemonsional, 2-Diemonsional ;k ;k Multi Diemensional Hkh gks
ldrs gSaA

2) Functions: - Function Program ds Modularity Concept dks ifjHkkf"kr djrs gSaA c++
esa functions dks Class ds ckgj o vUnj nksuks txg define fd;k tk ldrk gSaA
3) Pointers: -
(i) Pointer ,d Variable gSa ftls Memory address store djus ds fy;s mi;ksx esa
fy;k tkrk gSaA
(ii) Pointers dks define djus ds fy;s * sign dks mi;ksx esa fy;k tkrk gSaA
lkFk gh mldh data type dks define djrs gSaA

Syntax: - data type * pointer variable;

example: - char * a;
or
a = 10; int *b;
b = &a; //correct assignment of pointers
b = 10 // Illegal assignment of pointers

4) References: -
(i) Reference, object dk gh nwljk uke gSaA Reference ds }kjk igys define
fd;s x;s variables ds aliases dks create fd;k tkrk gSaA
(ii) Reference variable define djus ds fy;s & (ampersand) sign dks mi;ksx esa
ysrs gSaA
(iii) Reference variable dks define djus ds fy;s fuEu syntax dks mi;ksx esa
fy;ks tkrk gSa% & type & ref-var = var_name;
(iv) ;fn sum dks total dk Reference variable declare fd;k tkrk gSa rks sum rFkk
total nksuks ,d gh Variable Value dks iznf'kZr djrs gSaA
int total;
int & sum = total; //reference variable
total = 100;
5) Constants: -
(i) Program execution ds le; ftu variable dh value change ugha gkrh mUgsa
constants dgk tkrk gSaA
(ii) Constants dks define djus ds fy;s Const keyword dks mi;ksx esa fy;k
tkrk gsaA
(iii) Constants dks declaration ds le; gh Initialise fd;k tkuk pkfg;sA
(iv) Constants dks fuEu izdkj define fd;k tkrk gSa% &
Syntax: - const type name = value;
cont int pi = 3; // example

User defined Derived Data types

Class structure Union enumeration

- 19 –
1) Class: - Class ds }kjk same Type ds Object ds group dks iznf'kZr fd;k tkrk gSaA
ftl izdkj fdlh Hkh Variable dks define djrs le; mldh data type vko';d gksrh gSa
mlh izdkj Class ds fy;s objects vko';d gSaA
(i) Class dks cukus ds fy;s class Keyword dks mi;ksx esa fy;k tkrk gSaA
Syntax: - Class class name
I
variable declaration
function declaration
public:
variable declaration
function declaration
};
(ii) Class ds vUnj define fd;s x;s variables o functions private gksrs gSa tc rd
fd public access specifier dks mi;ksx esa u fy;k tk,A
(iii) class dks close djus ds fy;s braces ds ckn (;) semi colon dks mi;ksx esa
fy;k tkrk gSaA

2) Structure: - Structure vyx&vyx data type ds variables dk leqg gSa ftls ,d uke ns
fn;k tkrk gSaA tSls student Roll no, name, class, marks, grade vkfn dk collection gSaA
os vriables ftUgsa structure cukus ds fy;s mi;ksx esa fy;k tkrk gSaa elements of
structure dgykrs gSaA blds fy;s struct keyword dks mi;ksx esa fy;k tkrk gSaA

struct student
{
int rollno;
char name [30];
int class;
float marks;
char grade;
};
3) Union: - Union og Memory location gSa ftls ,d ls vf/kd vyx&vyx variables }kjk
Share fd;k tkrk gSaA Union dks Hkh structure dh rjg gh define fd;k tkrk gSaA
blds fy;s union keyword dks mi;ksx esa fy;k trk gSaAi bls Hkh Object }kjk Access
fd;k tkrk gSaA
Union share
{ int i; BYTE 0 BYTE 1
char ch;
}; union share cnvt; ch

4) Enumeration: - integer constants dks const ds vykok ,d vksj rjhds ls define fd;k
tkrk gSa ftUgsa enumeration dgrs gSaA blds fy;s enum keyword dks mi;ksx esa
fy;k tkrk gSaa
enum { start, stop, god};
blds }kjk rhu integer constants dks define fd;k tkrk gSa ftUgsa enumerators dgrs
gSaA By default enumerators dh value 0 ls start gksrh gSaa bls bl izdkj Hkh define
fd;k tkrk gSa% &
const int start = 0;

- 20 –
 const int stop = 1;
const int god = 2;

OPERATORS
1) I/O Operators: - User }kjk terminal ls input fy;k tkrk gSaA ftls standard input dgk
tkrk gSa tks igys ls defined iostream ds cin ls fy;k tkrk gSaA standard output }kjk
terminal ij output fn;k tkrk gSa ftls cout }kjk define fd;k tkrk gSaA
Output Operators: - insertion operator ("<<")
input Operators: - extraction operator(">>")

example: - # include <iostream.h>

# include <conio.h)
int main ( )
{
int val1, val2, sum;
cout <<" Enter First Value";
cin>> val1;
cout <<"\n Enter Second value;
cin>>val2;
sum = val1 + val2;
cout << "\n" << The sum of the value is" <<sum;
return 0;
}
2) Arithmetic Operators: - + addition, -subtraction, * multiplication
/division, % modulus
lHkh binary operators gSaA
3) Increment & Decrement Operators: - (++) (--) fdlh variable esa ,d increase djus ;k
1 decrease djus ds fy;s Increment/De. operators dks mi;ksx esa fy;k tkrk gSaA
4) Relational Operators: -
1) < (less than) 2) > (greater than) 3) <= (less than equal to)
4) > = (greater than equal to) 5) == (equal to) 6) ! = (not equal to)

5) Logical Operators: -
(i) Logical AND (&&)
(ii) Logical OR (II)
(iii) Logical Not

6) Conditional Operator: - (?:)

expression1? expression2: expression3
result = maks > 50 ? 'P' : 'F';
7) Other Operators: -
(1) Sizeof - ;g unary compile time operator gSa tks variables dh length dks bytes
ds :i esa iznf'kZr djrk gSaA
(2) Comma: - cgqr lh string expression dks mi;ksx esa ysus ds fy;s Comma
Operator dks mi;ksx esa ysrs gSaA

Classes & Objects

,d class ds }kjk data mlls related functions dks ,d lkFk j[kk tkrk gSaA eq[; Class ds
nks parts gksrs gSa%&
1) Class declaration

- 21 –
 2) Class Function definitions

Class declaration ds }kjk mldh type o Scope dks ifjHkkf"kr fd;k tkrk gSaA
class class_name
{
private;
variable declaration;
function declaration;
public;
variable declaration;
function declaration;
};
tc Variables o Function dks class esa declare fd;k tkrk gSa rks mUgsa class
members dgk tkrk gSaA bl class members dks eq[;r% nks section es define fd;k
tkrk gSaA
1) Private
2) Public
blds fy;s Public rFkk Private Keywords dks mi;ksx esa fy;k tkrk gSaA bu
Keywords ds ihNs (colon) dks mi;ksx esa ysrs gSaA
os Variables ftUgsa class ds vUnj define fd;k tkrk gSaA data members
dgykrs gSa rFkk os functions ftUgsa Class esa define fd;k tkrk gSaA Member
functions dgykrs gSaA dsoy member functions }kjk gh private data members, private
functions dks access fd;k tk ldrk gSaA class ds public members dks class ds ckgj
access fd;k tk ldrk gSaA
Example of Class: -
class my
{ int x;
int y;
public
void getdata ( ); //function declaration
void put data ( );
};
mijksDr class ds }kjk nks data members o nks members functions dks define fd;k x;k
gSaA By default nksuks data member private gSa rFkk Member functions dks public
define fd;k x;k gSaA mijksDr functions dks declare fd;k x;k gSa uk fd define.
tc ,d ckj class dks declare dj fn;k tkrk gSa rks user }kjk class cgqr ls
variables dks define fd;k tk ldrk gSaA
Syntax: - class_name object_name;
my ob1; //object of my class;
* class ds object dks fuEu izdkj ls Hkh define fd;k tk ldrk gSa% &
class my
{
--------------
--------------
} 01, 02, 03; // objects with class declaration
Class ds Private data dks class ds Member function }kjk gh access fd;k tk ldrk gSaA
main ( ) ds vUrxZr class ds Member functions dks Object ds lkFk call fd;k tkrk gSa
%&

for example: - 01.getdata ( ); //function call in main

- 22 –
main ( ) esa fuEu statements dks ugha fy[kk tk ldrk gSa% &
(i) getdata ( ); //illegal
(ii) 01.x = 10; //illegal

DEFINING MEMBER FUNCTIONS: -

Member functions dks Program esa nks txg define fd;k tk ldrk gSa% &
1) Outside the class definition
2) Inside the class definition

(i) Outside the class definition: - Member functions dks class esa declare djds class ds
ckgj Hkh define fd;k tk ldrk gSaA
Syntax: - return_type classname : : function name (arguments)
{
//function body:
}
example: -
# include <iostream.h>
# include <conio.h>

class student
{ int roll, marks;
public:
void getdata( ); //function declaration
void putdata( );
};
void student : : getdata ( ) //function definition
{ cout <<"\n Enter the student roll no.";
cin >> roll;
cout << "\n Enter the student marks";
cin>> marks;
}
void student : : putdata( )
{ cout <<"\n The student roll number is "<<roll;
cout <<"\n The student marks in" << marks;
}
void main( )
{ student s1;
s1. getdata( );
s1. putdata( );
}

mijksDr nksuks member function ds }kjk fdlh value dks return ugha fd;k x;k gSA
vr% budh return type void gksxhA
Member functions dh dqN fo'ks"krk,sa fuEu gS% &
1) cgqr lh vyx&vyx classes same function name dks mi;ksx esa ys ldrh gSa
D;ksafd gj function ds lkFk mldk class label yxk gksrk gSaA
2) Class ds Private Data dks Member functions }kjk Access fd;k tk ldrk gSaA
3) ,d Member function nwljs member function dks vklkuh ls directly call dj ldrs
gSaA blds fy;s dot operator dh vko';drk ugha gksrh gSaA

- 23 –
Inside The Class: - Member functions dks class ds vUnj Hkh define fd;k tk ldrk gSa
%&
Example: - class student
{ int roll, marks;
public: void getdata( )
{cout<, "Enter the roll no";
cin>> roll;
cout <<"/nEnter the marks";
cin>>marks;
}

INLINE FUNCTION
Inline functions ds }kjk Program execution dh speed dks c<+k;k tkrk gSaA Normal
function o Inline function dh Coding same gksrh gSa ijUrq inline function dh definition
inline keyword ls 'kq: gksrh gSaA lkFk gh nksuks functions dk compilation process
Hkh vyx&vyx gksrk gSaA
Executable Program dks Computer memory esa Load djus ds ckn instruction
dks one by one execute fd;k tkrk gSaA tc function call instruction occur gksrk gSa]
rks Program tYnh ls function call statement ds ckn okyh instruction address dks Store
dj ysrk gSa rFkk ckn esa ml function dks memory esa Load dj function code dks
execute djrk gSa rFkk function dh return value dks store dk iqu% save dh xbZ
instruction ij igq¡p tkrk gSaA
Square function esa gksus okyk Overhead: -
Example: -
Memory loaded Code 1) function call ds ckn okyh instruction dh Save
1010 int a = 4, b =7 djukA vr% 1018 address dks Save.
1012 int c = a+b,d; 2) C dh Value dks stock esa MkyukA
1015 d = square (c); 3) Memory Location 2022 ij Jump djukA
1018 cout <<d; 4) mudh Instructions dks execute djukA
: : 5) Value 121 dks d esa store djukA
: : 6) iqu% 1018 ij tkukA
: :
2022 int square (int i)
{ return i*i; }

Inline Function ls bl overhead ls cpk tk ldrk gSa D;ksafd inline ds lkFk fy[kk x;k
Code execute djrs le; compiler function call statement dks function code esa ifjofrZr dj
nsrk gSaa vr% execution ds fy;s ckj&ckj Jump dh vko';drk ugha gksrhA
Inline function normal function ls T;knk fast run gksrs gSa ijUrq bldk lcls
cM+k uqdlku ;g gSa fd ftruh ckj inline function dks call fd;k tk,xk mruh ckj
mldh copy cusxhA
Inline function definition dks lHkh functions ds mij fy[kuk pkfg;s tks mls call dj jgs
gksA
Inline functions fuEu ifjfLFkfr;ksa esa dk;Z ugha djrs% &
1) os function tks loop, switch ;k goto statement dks mi;ksx esa ys jgs gSaA
2) os function ftuesa static variable dks mi;ksx esa fy;k x;k gksA
3) ;fn function recursive gksA
Example of Inline function: -
# include <iostream.h>
inline int square (int x)

- 24 –
 { return (x*x); }
void main( )
{
int a = 5;
cout <<square (a) <<"\n";
}

SCOPE RESOLUTION OPERATOR

C++ ,d block structural language gSaA blocks rFkk scope dks program dks cukus ds
fy;s mi;ksx esa fy;k tkrk gSaA ge tkurs gSa fd vyx&vyx block esa Same
variable dk vyx&vyx Meaning gksrk gSaA Variable dk Scope mlds Declaration ls
ysdj mlds block ds end rd jgrk gSaA tc fdlh Variable dks block ds vUnj declare
fd;k tkrk gSa rks og local variable dgykrk gSaA
Example: -
{
int x =10; //local for the block
}
{
int x =1;
...............
...............
}
mijksDr mnkgj.k esa x dks nks txg declare fd;k x;k gSa ftlesa vyx&vyx values
gSa rFkk bldh memory location Hkh vyx&vyx gSaA Second block esa declare fd;k
x;kA x 1st block ls vyx gSaA C++ nested block dks Hkh support djrh gSa tSls% &
{
int x = 10;
..............
..............
{ Block1
int x = 1;
............
............ Block2
}
}

Block2 dks Block1 esa define fd;k x;k gSaa ;gk¡ inner block esa defined x dh Value
ds }kjk Outer block dh X dh Value dks Hide dj fn;k x;k gSaA C ds vUrxZr global
variable dks inner block }kjk access ugha fd;k tk ldrk Fkk ijUrq C++ ds }kjk bl
Problem dks solve dj fn;k x;k gSaA blds fy;s :: Scope Resolution Operator dks
mi;ksx esa fy;k tkrk gSaA blds }kjk Global variable dks access fd;k tk ldrk gSaA
Syntax: - :: variable name
example: - int a = 10;
void main( )
{ clrscr( );
int a = 15;
cout << "main( )" << "\n";
cout << "a =" <<a<< "\n"; //local a printed
cout <<"::a =" << :: a<<"\n"; //global a printed
//Inner Block

- 25 –
 {
int a = 25; //local to inner block
cout <<"/n Inner Block";
cout <<"a =" <<a<<"\n";
cout <<"::a=" <<"\n"; \\global a
}
}
Note: - Class ds member function dks class ds ckgj access djus ds fy;s Hkh scope
Resolution Operator dks mi;ksx esa fy;k tkrk gSaA
USE OF STATIC
Class ds members (data o functions) dks static declare fd;k tk ldrk gSaA vr% static
data members Hkh define fd;s tk ldrs gSa o static member function dks Hkh define
fd;k tk ldrk gSaA
1) Static Data Member or Static Variable: - Static data member class ds global
variable dh rjg gh gksrs gSa ;g variable lHkh Objects (Same class ds) ds }kjk
access fd;s tk ldrs gSaA
Static member normal class variable ls dqN fHkUu gksrs gSa% &
1) class ds lHkh Objects ds }kjk static variable dh ,d gh copy dks share fd;k tkrk
gSaA
2) ;s flQZ class rd gh mi;ksx esa fy;s tk ldrs gSa ijUrq budk lifetime iwjs
Program rd jgrk gSaA
fdlh Hkh data member dks nks Rules dh vko';drk gksrh gSa% &
(i) bUgsa class definition esa declare djukA
(ii) budh definition dks class ds ckgj djukA
(i) fdlh Hkh static data member dks class esa declare djus ds fy;s static keyword dks
mi;ksx esa ysrs gSaA
Static keyword dks mi;ksx esa ysrs gSaA
Syntax: - static data type variable_name;
class x
{
static int count; //declaration in the class
};
(ii) mijksDr class esa count static variable dks declare fd;k x;k gSa rFkk ijUrq bldh
definition dks class ds ckgj define fd;k tk,xkA
syntax: - return_type class name : : variable_name;
example: - class x
{
static int count;
};
int x : : count; //definition of static member

Object 2

Object 1 Object 3

count

Sharing of static data member

- 26 –
example: -
class stat
{ int roll,marks;
static int count;
public:
void getdata (int i, int j)
{
roll = i;
marks = j;
count ++;
}
void putdata( )
{
cout << end<< "rollno=" <<roll;
cout << end <<"marks=" <<marks;
cout <<end <<"Count=" <<count;
}
};
int stat :: count; //definition of count outside the class
void main( )
{ stat 01;
01.getdata (23, 78);
01. putdata( );
01. getdata (1, 92);
01. putdata( );
}
2) Static Member Function: - os Member functions tks flQZ class ds static data members
dks access djrs gSa] mUgsa static member function dgk tkrk gSaA blds fy;s
function dks static declare fd;k tkrk gsaa ftldk declaration o definition fuEu gSa% &
class x
{ static int count;
static void show( )
{ cout << count <<end1;}
};
int x:: count;
Static member function normal function ls dqN vyx gksrk gSa blds fy;s ftu Rules dks
define fd;k tkrk gSa os fuEu gSa% &
1) Static Member functions ds }kjk same class ds static data members dks access
djrs gSaA
2) static Member function dks class ds Objects }kjk ugh cfYd class ds name ls
invoke fd;k tkrk gSaA
Syntax: - class_name :: function_name
static function dks call djus ds fy;s% &
x :: show( );
# Program: - FOR STATIC MEMBER FUNCTION
class x
{
int code, price;
static int count; //static data member
public:

- 27 –
 void getdata (int i, intj)
{
code = i;
price = j;
++count;
}
void show ( )
{
cout <,end1<<"Code="<< code;
cout <<end1<<"price=" <<price;
}
static void display ( ) //static member function
{
cout <<"count =" count <<"\n";
}
};
int x :: count = 0;
void main( )
{
x o1, o2;
clrscr( );
o1.getdata (101, 25);
o2.getdata (105, 30);
x :: display ( );
x o3;
o3. getdata (200, 50);
x :: display ( );
o1.show ( );
o2. show ( );
o3. show ( );
}
Class ds Member function }kjk Normal o Static nksuks Members dks access fd;k tk
ldrk gSa tcfd static member function class ds static variable dks access djrk gSaA

FRIEND FUNCTION
encapsulation o data hiding dk concept ;g crkrk gSa fd Non member function ds }kjk
class ds Private o Protected data members dks access ugha fd;k tk ldrkA ij
dHkh&dHkh Private data members dks non member function }kjk access fd;k tkrk
gSa blds fy;s friend function dks mi;ksx esa ysrs gSaA Friend function ,d non
member function gSa ftls class ds private data members o Protected data member dks
access djus dh Permission gksrh gSaA
fdlh Hkh Non Member function dks class dk friend cukus ds fy;s class definition ds
vkxs friend keyword dks mi;ksx esa fy;k tkrk gSaA ftlesa class dk declaration o
definition 'kkfey gSaA
Example: - Class sample
{ private ;
public;
friend void check ( ); //declaration included
;
};

- 28 –
mijksDr function definition ds le; friend keyword dks mi;ksx esa ugha fy;k tk,xkA
friend function ls lacaf/kr dqN egRoiw.kZ Rules: -
1) fdlh function dks ,d ls T;knk class dk friend cuk;k tk ldrk gSaA
2) bl function dk class esa dksbZ scope ugha gksrk cfYd ;g viuh Original
declaration o definition ij fuHkZj gksrk gSaA
3) blds fy;s class ds object dh vko';drk ugha gksrh cfyd bls normal function
}kjk invoke fd;k tkrk gSaA
4) ;g class dk member function ugha gSaA vr% ;g class ds members dks directly
access ugha dj ldrkA vr% blds fy;s class ds Object name ds lkFk Dot(.)
Operator dks mi;ksx esa fy;k tkrk gSaA
5) bls class esa dgh Hkh declare fd;k tk ldrk gSaA
6) Friend function arguments ds :i esa class object dks ysrk gSaA

Program: - Friend Function

Class ABC
{ int x, y;
public;
void getdata( )
{ cout <<"Enter the value of x & y";
cin>>x;
cin>>y;
}
//friend declaration
friend float average (ABC a);
};

//friend definition
float average (ABC a)
{ return float (a.x + a.y)/2.0;}

void main( )
{ ABC ob1;
clrscr( );
ob1. getdata( );
float avg.;
avg = average (ob1); //object passed to the average( )
cout<< "average="<<avg<<"\n" //and return value stored in avg.
}
,d class ds Member function dks nwljh class dk friend function Hkh cuk;k tk ldrk
gSaA
Example: -
Class a
{:
void fc_a( ); //member function of A
:
};
class B
{:
friend void A :: fc_A( ); //friend declaration
:

- 29 –
 };
blh izdkj ,d class dks nwljh class ds friend class Hkh declare fd;k tk ldrk gSaA
Class A
{ int x,y;
public:
void getdata( )
{
}
float fc( )
{
}
};
Class B
{:
friend class A; //all member function of class A
;
};

FRIEND AS BRIDGE
tc fdlh function dks nks vyx&vyx class ds Objects ij Operation Perform djuk gks rks
mls nksuks classes dk firend cuk fn;k tkrk gSaA
Program: - friend function as Bridges
class xyz;
class ABC
{ int x,y;
public:
void getdata( )
{ x =3;
y = 7;
}
friend int com friend (ABC, XYZ);
};
class XYZ
{ int x, y;
public:
void getdata ( )
{ x=5;
y = 10;
}
friend int com friend (ABC, XYZ);
};
int com_friend (ABC a, XYZ b) //friend function definition
{ return (a.x * b.x + a.y * b.y);}

void main( )
{
ABC ob1;
XYZ ob2;
clrscr( );
ob1. getdata ( );

- 30 –
 ob2. getdata( );
cout << com_friend (ob1, ob2); //using the friend function
}
tc nks class dk Common friend cuk;k tkrk gSa rks nwljh class dks igys declare
djuk vko';d gSaA blhfy;s class XYZ dks ABC ls igys declare fd;k tkrk gSaA

RETURNING OBJECTS
fdlh Hkh function }kjk Objects dks as a arguments fy;k gh ugha tkrk cfYd os
Objects dks return Hkh djrs gSaA
Program: - Complex Number
class complex
{ int x,y;
public;
void getdata( )
{
count << "\n Enter the real part";
cin>> x;
cout <<"\n Enter the imginary part";
cin>>y;
}
void display Complex c1
{
cout << c1.x <<"+i" <<c1.y <<end1;
}
friend complex add (complex, complex);
};
int main( )
{
complex A, B,C;
A. getdata( );
B. getdata( );
C = add (A,B);
cout <<"a=";
A. display (A);
cout << "B=";
B. display(B);
cout << "C=";
C. display (c);
reutrn (0);
}

- 31 –
 UNIT – II
CONSTRUCTORS AND DESTRUCTORS
Constructors: - C++ ds eq[; Features data abstraction, Encapsulation, Data hiding,
Inheritance rFkk Polymorphism vkfn lHkh dks ,d lkFk class esa Implement fd;k tkrk
gSa ij class Definition ds }kjk flQZ Data type dks Create fd;k tkrk gSaA
Class Type ds Objects dks vyx ls Create o Initialize fd;k tkrk gSaA
Constructors o destructors dqN special member function gSa ftlds }kjk Class ds Object
ds lkFk class dks Initialize o Dispose (Delete) fd;k tkrk gSaA
Constructor Class dk Member Function gSa tks Class ds Object ds lkFk Automatic Call
gksrk gSaA Constructor dk uke o class dk uke Same gksrk gSa rFkk Constructor
dk eq[; dk;Z Class dh values dks Objects ds }kjk Initialize djuk gSaA
NEED FOR CONSTRUCTORS: - C++ esa array ;k Structure dks declaration ds le; gh
initialize fd;k tkrk gSa blds fy;s fuEu code dks mi;ksx esa ysrs gSa% &
struct student
{
int rollno;
int marks;
};
int main( )
{
student s1 = {0, 0};
int a[5] = {1,2,3,4,5};
}
ysfdu bl initialization dks Class ds lkFk mi;ksx esa ugha fy;k tk ldrk gSaA
D;kasfd Class Members ds fy;s Access Labels dh vko';drk gksrh gSaA bUgsa
Outside the class access ugha fd;k tk ldrkA vr% fuEu code invalid gSa% &
Class student
{
private : int rollno;
int marks;
public:
};
int main( )
{
student s1 = {0,0}; //illegal;
}
Private data members dks Non Member function }kjk access ugha fd;k tk ldrk gSaA
blds fy, ,d Solution Provide fd;k x;k gSa% &
class student
{
private : int rollno;
int marks;
public : void init( )
{
rollno = 0;
marks = 0;
}
.......
};
int main( )

- 32 –
{ student s1; //create on object
s1.init( ); //initialize it
}
mijksDr mnkgj.k esa init( ) function ds }kjk values dks initialize fd;k x;k gSa]
ysfdu Programmer dks bls explicitly invoke djuk iM+rk gSaA vU; 'kCnksa esa
initialization dh responsibility programmer ij gksrh gSaA ;fn Programmer }kjk init( )
dks invoke ugha fd;k tk, rks values esa garbage initialization gks tk,xkA
vr% bl Problem dks nwj djus ds fy;s initialization dh responsibility dks Programmer
ds ctk; Compiler dks ns fn;k tkrk gSa D;ksafd Compiler gh tkurk gSa fd dc
Objects dks Create fd;k tk,xkA gj le; tc Object dks Create fd;k tkrk gSaA Compiler
Automatically initialization function dks invoke dj values dks initialize dj nsrk gSaA ;g
Compiler rHkh dj ldrk gSa tc initialization function dk uke o class dk uke same
gksA

Declaration & Definition

Constructor, Class dk Member Function gSa ftldk uke rFkk Class dk uke same gksrk
gSaA Constructor dks class ds vU; Member Function dh rjg gh define fd;k tkrk
gSaA bls Class ds ckgj ;k Class ds vUnj dgha Hkh define fd;k tk ldrk gSaA
Example1: -
Class X
{ int i;
public: int j;
X( ) //constructor inside the class
{ i = 0;
j = 0;
}
};
Example2: -
Class x
{ int i;
public: int j;
x( );
};
x :: x ( ) //constructor Outside the class
{ i = 0;
j = 0;
}
mijksDr nksuks class definition esa Constructor dks Public Section esa Define fd;k
tkrk gSa ij Constructor dks Private o Protected Section esa Hkh define fd;k tk ldrk
gSaA ijUrq ;s Cosntructor Non-Member Function ds fy;s Available ugha gksrsA
bUgsa flQZ Member Function ;k Friend Function }kjk mi;ksx esa fy;k tk ldrk gSaA

Example: -
Class x
{ int i;
x( )
{
i = 0;
j = 0;
} //Constructor in private section

- 33 –
 public :
int j;
void getval( )
{
cin>>i>>j;
}
void print( )
{
cout << "i=" <<i<< "j=" <<j;
}
void check( );
friend void abc( );
};
void x :: check( ) //Constructor is used here.
{ x o1;
:
}
void abc( )
{ x o2; // Constructor is used here
:
}
int main( )
{ x o3; //Constructor is not used here
} //because main( ) is non member function

**eq[;r% Constructors dks Public Section esa gh Define fd;k tkrk gSaA

DEFAULT CONSTRUCTORS
os Constructors tks fdlh Parameter dks Accept ugha djrs mUgsa Default Constructor
dgk tkrk gSaA mijksDr Program esa x( ) Constructor default Constructor gSaA
Default Constructor dks Call djrs le; Object mlh rjg Create fd;s tkrs gSa tSls fdlh
vU; Data type ds Variable dks Create djuk gksA tSls% &
x o1;
bl Object o1 ds }kjk Class ds Default Constructor dks Call fd;k x;k gSaA ;fn Class
esa dksbZ Constructor define ugha fd;k x;k gSa rks Compiler }kjk Class dks
default constructor supply fd;k tkrk gSa tks Argument ugha ysrk gSaA
Example: -
Class A
{
int i;
public: void getdata( );
void output( );
:
};
A o1; //use default constructor for creating 01
Default Constructor ds }kjk data members dks dummy values ls initialize fd;k tk ldrk
gSaA tc Constructor dks argument ds lkFk declare fd;k tkrk gSa rks default
constructor hide gks tkrk gSaA blds ckn default constructor dks Invoke ugha fd;k tk
ldrkA

- 34 –
 CONSTRUCTOR WITH DEFAULT ARGUMENTS
fdlh vU; function dh rjg Constructor dks Hkh Default Arguments pass fd;k tk ldrs
gSaA
Example: -
class A
{ int i, j;
public:
A(int a =0, int b =10); //constructor declaration
: //with default arguments
};
A :: A (int a, int b) //constructor definition
{ i = a;
j = b;
}
void main( )
{ A o1 (2,3);
A o2; //it takes default arguments i = 0; j=10;
vr% Default Arguments okys Constructor fcYdqy Default Constructor dh rjg gh dk;Z
djrs gSaA

PARAMETERIZED CONSTRUCTORS
ge tkurs gSa fd Constructor Hkh Arguments ysrs gSa bl Constructors dks
Parameterized Constructors dgk tkrk gSaA blds }kjk vyx&vyx Objects ls different
data elements dks initialize fd;k tkrk gSaA mijksDr mnkgj.k }kjk Parameterized
Constructor dh definition dks ifjHkkf"kr fd;k x;k gSa% &
class ABC
{
int i;

public:
float j;
ABC (int a, float b) //Parameterized Constructor
{ i = a;
j = b;
}
:
};
Class ds Parameterized Constructor ds lkFk Initial values dks arguments ds :i esa Pass
djuk vko';d gSaA ugha rks Compiler Error show djrk gSa% & ABC o1 //invalid
Parameterized Constructor ds lkFk Initial Values dks Object Creation ds lkFk Pass fd;k
tkuk pkfg;sA Parameters dks nks izdkj ls Pass fd;k tk ldrk gSa% &
1) Constructor dks Implicitly Call djukA
2) Constructor dks Explicitly Call djukA
1) Constructor ds Implicit Call esa mlds uke dks Statement esa Mention ugha fd;k
tkrk flQZ Initial value dks Pass dj fn;k tkrk gSaA
tSls% & ABC ob1 (2,3); //implicit call
2) Explicit Constructor Call ds le; User }kjk Explicitly Name fn;k tkrk gSa o Values
dks initialize fd;k tkrk gSaA tSls% &
ABC ob1 = ABC (3, 4.5); //explicit call

- 35 –
Constructor ds explicit call ds le; Object temporarily create gksrk gSaA ;g Object rc rd
mi;ksx fy;k tkrk gSaA tc rd Program bls mi;ksx esa ys jgk gSa ckn esa ;g
Object Remove dj fn;k tkrk gSaA Temporary instance dk dksbZ uke ugha gksrkA
Example: -
class sample
{ int i, j;
public;
sample (int a, int b)
{ i = a;
j =b;
}
void output( )
{ cout <<i<<j<<"\n";}
:
};
void main( )
{ sample s1 (2,5);
s1. output( );
sample (4,9) .output( ); //Data values that are
// temporary created
}
COPY CONSTRUCTOR
Compiler }kjk Copy Constructor dks rc mi;ksx esa fy;k tkrk gSa tc ,d Class ds
Object Reference dks mlh Class ds nwljs Object esa copy djuk gks ;k ,d Object dh
Values dks nwljs Object esa Pass djuk gksA
Example: -
sample s1; //default constructor used
sample s2 = s1; //copy constructor used
mijksDr mnkgj.k esa nwljs Statement esa Compiler s1 dh Copy s2 esa dj
nsxkA ;fn Program esa Copy Constructor dks define ugha fd;k x;k gSa] rks
Compiler Automatically mls Create dj nsxk vkSj ;s Public gksxkA
User }kjk Lo;a dk Copy Constructor Hkh define fd;k tk ldrk gSaA Copy Constructor
}kjk Argument ds :i esa Same Class ds Object dk reference fy;k tkrk gSaa
Example: -
class sample
{ int i, j;
public:
sample (int a, int b) //constructor
{
i =a; j = b;
}
sample (sample &s) //copy constructor
{
j = s. j;
i = s. i;
}
void output( )
{
cout <<"i =" << i <<"j=" << "\n";
:

- 36 –
 }
};
mijksDr Class Definition esa nks constructors dks mi;ksx esa fy;k x;k gSa% &
1) Parameterized Constructor
2) Copy Cosntructor
bu Constructors dks fuEu izdkj ls mi;ksx esa fy;k tk,xk% &
sample s1 (4, 5); //Parameterized used
sample s2 (s1); //s1 copied to s2 copy constructor called
sample s3 = s1; //s1 copied to s3 copy constructor called
//again
Copy Constructor ds }kjk Values dk Initialization djuk Copy initialization dgykrk
gSaA

Q: - Copy Constructor dks dc Call fd;k tk,% &

(i) Copy Constructor dks rc Invoke fd;k tkrk gSa tc Object defined gks rFkk
mls fdlh vU; Object ls initialize djuk gksA
(ii) tc Object Pass by Value gks% & Copy constructor dks rc Invoke fd;k tkrk
gSa tc Object Pass by Value to a function gksA D;ksafd Pass by value
method esa arguments dh Copy dks Create fd;k tkrk gSa vr% Copy
Constructor invoke gksrk gSaA
(iii) tc Function Object Return djrk gks% & tc fdlh Function }kjk Object Return
fd;k tkrk gS rc Copy constructor Invoke gksrk gSaA

DYNAMIC INITIALIZATION OF OBJECTS

Dynamic Initialization ls rkRi;Z ;g gSa fd Initial values dks runtime ds nkSjku Pass
fd;k tk,A ;gk¡ rd fd Class Objects dks Hkh Run Time ij Initialize fd;k tk ldrk gSaA
Example: -
class sample
{ int roll, marks;
public:
sample (int a, int b) //Parameterized Constructor
{ roll = a; marks = b;}
sample (sample &s)
{ roll = s. roll;
marks = s. marks;
cout << "copy constructor\n";
}
void output( )
{ cout << "roll no=" <<roll<<end1;
cout << "marks =" <<marks <<end1;
}
};
void main( )
{ int x,y;
cout <<"\n Enter the roll no. of student";
cin>> x;
cout<<"\n Enter the marks of student";
cin>>y;
sample s1(x,y); //Dynamic initialization of constructor
sample s2 (s1); //copy constructor called

- 37 –
 s1. output( );
s2. output( );
}

Special Characteristics of Constructors: -

1) Constructor Function Automatically Invoke gksrs gSa tc objects dks Create fd;k
tkrk gSaA
2) ;fn Class esa Constructor dks define fd;k x;k gSa rks object cukdj lcls igys
class dks initialize fd;k tkuk pkfg;sA
3) Constructor Normal Function ds Rules dks Follow djrs gSa ;fn Constructor dks
Private ;k Protected Section esa define fd;k x;k gSa rks mUgsa flQZ Member
Function o Friend Function }kjk Invoke fd;k tk ldrk gSaA ijUrq Public
Constructors lHkh ds fy;s Available gksrs gSaA
4) Construction dh dksbZ Hkh return type ugha gksrhA
5) Constructors dks inherit ugha fd;k tkrk ijUrq derived class }kjk base class ds
constructor dks call fd;k tk ldrk gSaA
6) Constructor static define ugha fd;s tk ldrsA
7) Default o Copy Constructor dks vko';drk iM+us ij Compiler }kjk Generate fd;k
tkrk gSaA (tc mUgsa class esa define u fd;k x;k gSaA)
8) C++ ds vU; function dh rjg Constructor esa Hkh Default arguments dks pass
fd;k tk ldrk gSaA
9) Constructor ds address dks ysuk Possible ugha gSaA
10) Constructor dks explicitly create Hkh fd;k tk ldrk gSaA

DESTRUCTORS
ftl izdkj Objects dks Create fd;k tkrk gSa mlh izdkj Object dks Destroy Hkh fd;k
tkrk gSaA Destructor ds }kjk] Constructor }kjk construct fd;s x;s Objects dks destroy
fd;k tkrk gSaA
Destructor Hkh member function gSa ftldk uke o Class dk uke same gksrk gSa ftls
(~) tilde ds sign ds ckn fy[kk tkrk gSaA Destructor dksbZ Arguments ugha ysrk o
bldh dksbZ Return type ugha gksrhA ;s compiler }kjk Automatically Call gksrs gSa
tc Object dks destroy fd;k tkrk gSaA
~ dk Sign Not dks iznf'kZr djrk gSaA vr% Destructor Not a Constructor gSaA

Example: -
class ABC
{ int count = 0;
public:
ABC( )
{ count ++;
cout<<"\n No. of objects created" <<count;
}
~ ABC( ) //Destructor definition
{ cout <<\n No. of Objects destroyed" << count;
count --;
}
};
void main( )
{
ABC A1, A2, A3;

- 38 –
 {
cout << "INNER BLOCK" <<end1;
ABC A4;
}
}

ARRAY
ge tkurs gSa fd Array Variables dk collection gSa tks Same Type ds gksrs gSaA
rFkk ftUgsa ,d Single name fn;k tkrk gSaA Arrays dbZ izdkj ds gksrs gSa% &
(i) Single Dimensional Array
(ii) Multi Dimensional Array

Array dks define djus ds fy;s fuEu syntax dks mi;ksx esa fy;k tkrk gSa% &
datatype array name [size];
Example: - int a[4];
ARRAY OF OBJECTS
ftl izdkj Structure array dks define fd;k tkrk gSa mlh izdkj array Variable dks Class
type dk Hkh define fd;k tk ldrk gSaA bu Variables dks array of objects dgk tkrk
gSaA Example: -
class A1
{ char name [30];
float marks;
public:
void input ( );
void output ( );
};
bl izdkj A1 ,d User defined data type gSa ftls blds Object Create dj mi;ksx esa fy;k
tk ldrk gSaA
A1 ob1[3]; //array of ob1
Array of object dks memory esa mlh izdkj Store fd;k tkrk gSa ftl izdkj
Multidimensional array dksA Object }kjk data item Space dks Create fd;k tkrk gSaA
Member Function dks vyx ls Store fd;k tkrk gSaA ftls lHkh Objects }kjk mi;ksx
esa fy;k tkrk gSaA
Example: -
class emp
{ char name [30];
float age;
public:
void input( );
void output( );
};
void emp :: input ( )
{ cout << "Enter the name";
cin>>name;
cout << "Enter the age";
cin>>age;
}
void emp :: output ( )
{ cout <<"Name:" <<name <<end1;

- 39 –
 cout <<"age:" <<age <<end1;
}
void main( )
{
emp emp1 [4];
for (int i = 0; i <4; i++)
{
cout <<"\n Details of emp1" <<end1;
emp1[i], input ( );
}
cout <<end1;
for (i = 0; i<4; i++)
{ cout<< "\n employee" <<end1;
emp1 [i], output ( );
}
}
POINTER TO OBJECT
Pointer ds Class ds Object dks Point fd;k tk ldrk gSaA Example: -
ABC x;
;gk¡ ABC ,d Class gSa rFkk X ,d Object gSa ftls ABC type dks define fd;k x;k
gSaA blh izdkj ABC Class ds Pointer ABC Class ds Pointer dks define fd;k tkrk
gSaA
ABC * ptr;
Object Pointers Run time ij Object Create djus ds fy;s Useful gksrs gSaA Object Pointer
ds }kjk Object ds Public members dks Access fd;k tkrk gSaA Example: -
class ABC
{ int x, y;
public:
void input (int a, int b)
{ x =a ; y = b;}
void output( )
{ cout <<end1 <<"x=" <<x;
cout << end1 <<"y=" <<y;
}
};
vc Class dk Variable rFkk Pointer fuEu izdkj declare fd;k tk,xk% &
ABC a;
ABC *ptr = & a;
mijksDr Pointer ptr esa a ds address dks initialize fd;k x;k gSaA
ABC ds Member Function dks nks izdkj ls define fd;k tkrk gSaA
1) Using dot operator and object
2) Using arrow operator and object pointer
a. input (2,3);
a. output ( );
mijksDr Statement esa Object & dot Operator dks mi;ksx esa fy;k x;k gSaA mlh
izdkj Pointers ds fy;s arrow operator mi;ksx esa fy;s tkrs gSa% &
ptr  input (2,3);
ptr  output ( );

- 40 –
D;ksafd Pointer ptr a dk alias gSa vr% blds fy;s fuEu Method dks Hkh mi;ksx esa
fy;k tk ldrk gSa% &
(*ptr). output ( );
Paran theses yxkuk vko';d gSa D;ksafd (.) Operator dh Precedence * ls high gksrh
gSaA
Example: -
void main( )
{
ABC ob1;
ABC *ptr = &ob1;
ptr  input (3,4);
ptr  output ( );
}
THIS POINTER
tc Class dks define fd;k tkrk gSa rc Memory esa Member functions dks Memory
space allocate gks tkrh gSaA vr% Member Function dh ,d gh Copy dks Class ds
lHkh Objects }kjk Share fd;k tkrk gSaA dsoy gj Object ds Data Members ds fy;s
vyx ls Space Allocate dh tkrh gSaA
Member Function 1 Member Function 2

Member Function 3

Object 1 Object 2 Object 3

data member 1 data member 1 data member 1

data member 2 data member 2 data member 2

Memory Allocation For Class Object & Functions

ij bl Allocation ds lkFk ,d Problem gSa% & ;fn Member Function dh flQZ ,d gh
Copy exists djrh gSa rks ;g dSls irk pysxk fd dkSuls Object }kjk data member dh
value dks manipulate fd;k tk,?
Example: - ;fn Member Function3 ds }kjk data member2 dh value dks change fd;k tk
jgk gSa rFkk User Object1 }kjk data Member2 dh value dks change djuk pkgrk gSa
rks Member function3 dks ;g dSls irk pysxk fd dkSuls Object }kjk data member2 dh
value dks change fd;k x;k gSa?
blds fy, this pointer ,d solution gSaA tc Object }kjk Member function dks Call fd;k
tkrk gSa rks ;g Automatically implicitly argument dks pass dj fn;k tkrk gSa tks ,d
Object Pointer gSa ftlls Function dks invoke fd;k tkrk gSaA bl Pointer dks this pointer
dgk tkrk gSaA vr% ;fn Object1 }kjk Member function3 dks invoke fd;k tkrk gSa
rks Member function3 ds ikl ,d Implicit argument pass dj fn;k tkrk gSa fd mls Object
1 }kjk Point fd;k x;k gSaA blds fy, fuEu example gSa% &
# include <string.h>
class s1
{

- 41 –
 char name [30];
float sales;
public;
s1 (char *s, float a)
{
strcpy (name, " ");
strcpy (name, s);
sales = a;
}
void print( )
{ cout.write (this->name, 30); //use of this
cout << "has invoked print( ) function\";
}
};
void main( )
{
s1 raj ("Raj", 5000), seema ("Seema", 7000);
raj.print();
seema.print();
}
POINTER TO CLASS MEMBERS
Class ds Member ds Address dks ysdj mls Pointer esa Assign fd;k tkuk Hkh laHko
gSaA Member ds Address dks & Operator ds lkFk iwjs Class name ds }kjk Access
fd;k tkrk gSaA Class Member Pointer dks ::* ds }kjk Declare fd;k tkrk gSaA ftls
Class name ds lkFk mi;ksx esa fy;k tkrk gSaA Example: -
class A
{
int m;
public:
void display( );
};
Member m ds pointer dks fuEu izdkj Define fd;k tkrk gSa% &
int A :: *p = &A::m;
p Pointer fcYdqy Class Member dh rjg define fd;k x;k gSa ftls Class Object }kjk
Invoke fd;k tk,xkA
A::* dk vFkZ "Pointer to member of A Class" gSa rFkk &A::m dk vFkZ "address of m
member of A Class". Scope resolution operator dks Pointer rFkk Member nksuks ij apply
fd;k tkrk gSaA
tc Member dks Pointers ds lkFk Access fd;k tkrk gSa rks blds fy;s dereferencing
Operator dks mi;ksx esa ysrs gSaA Member Functions dks Invoke djus ds fy;s
Dereferencing Operator dks fuEu izdkj mi;ksx esa fy;k tkrk gSa% &
(Object_name. *pointer_to_member function) ();
(Pointer_to_object  * pointer to member function) ( );
( ) dh Precedence .* o * high gksrh gSaA vr% parentheses vko';d gSaA
class A
{
int x,y;
public:
void input (int a, int b)

- 42 –
 { x=a; y=b;}
friend int sum (A m);
};
int sum (A a)
{ int A :: * px = &A :: x;
int A :: *py = &A :: y;
A *pm = &a;
int s = a.*px +pm*py;
return s;
}
void main( )
{
A ob1;
void (A :: *pf) (int, int) = & A :: input;
(ob1. *pf) (10, 20);
cout << "Sum =" <<sum (ob1) <<end1;
A *op = &ob1;
(op*pf) (30, 40);
cout << "Sum=" <<sum(ob1) <<end1;
}

References
Function ,d User Defined operation gSa ftls ("()") Operator ds lkFk Invoke fd;k tkrk
gSaA ;fn Function Arguments Recieve djrk gS rks bu Arguments dks Call Operator
esa fy[kk tkrk gSaA Arguments dks Comma ds }kjk separate fd;k tkrk gSaA
Function dks nks izdkj ls Invoke fd;k tkrk gSa%
a) Call by value
b) Call by reference

vr% Call by reference method dks fuEu izdkj ls mi;ksx esa fy;k tkrk gSaA
Reference fdlh Hkh variable dk alias gSaA tSls% &
float v = 2.5;
float & m = v; //m reference of v.
vr% m ds fy;s vyx ls memory dks allocate ugha fd;k tkrkA blh izdkj Pointer Hkh
Variable ds addresses dks Contain djrs gSa ftlls Values dks access fd;k tk ldrk gSaA
Example: - float v = 20.25;
float * fp;
fp = & v;
mijksDr example esa float * fp define fd;k x;k gSa ftlls float value dks Point fd;k
tkrk gSaA Variable Value dks fp ds }kjk access fd;k tk ldrk gSaA

REFERENCE PARAMETERS
tc Parameters dks function esa reference ds :i esa Pass fd;k tkrk gSa rks Formal
Parameters esa actual parameters ds references dks Pass dj fn;k tkrk gSaA vr%
Function ds }kjk Original Values dh Copy Create ugha dh tkrh gSaA cfYd Original
Values ds reference dks Pass fd;k tkrk gSaA
tgk¡ Original Values dks function ds }kjk Change djuk gks rc Call by reference dks
iz;ksx esa fy;k tkrk gSaA
Example: -
void main( )

- 43 –
{
clrscr( );
void swap (int &, int &); //prototype
int a,b;
a =7; b =4;
cout << "original values\n";
cout <<"a=" <<a<<"b="<<b<<"\n";
swap (a,b); //function call
cout <<"swapped values\n";
cout <<"a=" <<a<<" b="<<b<<"\n";
}
void swap (int &x, int &y)
{
int t;
t = x;
x = y;
y = t;
return;
}
mijksDr Example esa Function Call same gksxk ijUrq function declaration o function
definition nksuksa esa reference symbol dks mi;ksx esa fy;k tkrk gSaA
**Reference dks flQZ varaibles ds fy;s Pass fd;k tkrk gSa ijUrq Constants ds fy;s
References dks mi;ksx esa ugha fy;k tkrk gSaA

FUNCTION RETURNING REFERENCE

Function ds }kjk Reference dks Hkh return fd;k tkrk gSaA tSls
float & min (float &a, float &b)
{
if (a<b)
return a;
else
return b;
}
mijksDr function min( ) }kjk float & dks return fd;k tkrk gSaA vr% function float
type variable dk reference return dj jgk gSa ij ;g function ml variable ds reference dks
return djsxk tks nksuksa esa ls NksVk gSaA
;fn User nks values esa ls minimum dks -1 values assign djuk pkgrk gSa rks
function dks assignment statement ds left side esa Use fy;k tk ldrk gSaA tSls% &
min (x,y) = -1;
example: -
class f_ret_ref
{
int x,y;
public:
fun( )
{ x = 4;
y = 7;
}
int & small (int & a, int &b)
{ if (a<b)

- 44 –
 return a;
else
return b;
}
void out ( );
};
void f_ret_ref :: out ( )
{ cout << "The minimum value is" <<small (x,y); }
void main( )
{
fun f;
f. out ( );
}
PASSING REFERENCES TO OBJECTS
tc ,d Object dks fdlh Function esa 'Pass by value' Pass fd;k tkrk gSa rks fcuk
Constructor dks invoke fd;s ml Object dh Copy Create gks tkrh gSaA
;fn User dks Original Object ds lkFk dk;Z djuk gSa rks blds fy;s mlds Reference
;k Alias dks Pass fd;k tk ldrk gSaA
Example: -
class simple
{ int x;
public:
simple (int i)
{ x = i; }
~ simple( )
{ cout <<"Destroy object" <<x<<end1;}
void put (int i)
{ x = i;}
int get( )
{ return x;}
};
void fun (simple & s1)
{ s1. put (7);
cout <<"this x is local to fun" <<end1;
cout <<"x =" <<s1. get( ) <<end1;
}
void main( )
{
clrscr( );
simple s1(1);
cout <<"The x is in main( )" <<end1;
cout <<"x=" <<s.get( ) <<end1;
fun (s1);
cout <<"x = " <<s.get( ) <<end1;
}
DYNAMIC ALLOCATION OPERATORS
Dynamic Allocation dk vFkZ run time ij Program dks Memory Allocate djuk gSaA
Global rFkk Local Variable dks Compile time ij Memory allocate dh tkrh gSaA C++
}kjk nks unary operators dks define fd;k x;k gSa tks new rFkk delete gSa ftlds run
time ij memory dks allocate o deallocate fd;k tkrk gSaA ;s Operators new rFkk delete

- 45 –
free store memory ij Operation dks Perform djrs gSa ftUgsa free store operators dgk
tkrk gSaA
Class name ds lkFk lHkh izdkj ds Objects dks Create djus ds fy, New Operator dks
mi;ksx esa fy;k tkrk gSaA New Operator dh general form fuEu gSa%&
Pointer_variable = new data_type;
;gk¡ data type C++ dh data type gSa rFkk Pointer variable ml data type dk pointer gSaA
New operator }kjk data_type ds equal memory dks allocate fd;k tk,xk rFkk ,d Pointer
return gksxk tks newly allocated area dks point djsxkA
iptr = new int;
blds }kjk free store memory ls specific data type int ds fy, Memory allocate dh tk;sxhA
,d ckj tc Pointer Newly allocated memory Point djrk gSa rks mlesa data values dks at
address operator }kjk store fd;k tkrk gSaA
fptr = new float;
*fptr = 17.32;
syntax: - pointer variable = new Data type (value);
ex: - char * cptr = new char ('c');
New operator ds }kjk User define Data type dks Hkh Memory allocate dh tkrh gSa
tSls structures, array, classes vkfnA One dimensional array dks New }kjk fuEu izdkj
Memory allocate nh tkrh gSaA
syntax: - pointer variable = new data type [size];
ex.: - int * value = new int [10];
blds }kjk 10 int array dks free store memory allocate dh tk,xhA 2-D array ds fy, fuEu
izdkj ls memory allocate dh tk,xhA
int * val;
val = new int [4][7]; //legal
val = new int [x][7]; //legal
val = new int [ ][7]; //illegal
val = new int [4][ ]; //illegal
val = new int [x][ ]; //illegal
By default new operator Nul return djrk gSa tc insufficient free store memory available
gksA initialization rHkh perform fd;k tk,xk tc new operator }kjk non zero value return
dh tk,A
tc fdlh Object dks new ds }kjk create fd;k tkrk gSa vkSj mldh vko';drk ugha
gSa rks mls destroy djus ds fy, 'delete' operator dks mi;ksx esa fy;k tkrk gSaA ;g
memory deallocation operator dgykrk gSaA
syn: - delete pointer variable;
ex.: - delete iptr;
Pointer variable ml data object dks point djrk gS ftls new }kjk create fd;k x;k gSaA
New operator ds }kjk allocated array dks fuEu izdkj delete fd;k tkrk gSaA
syn: - delete [size] pointer variable;

Example: -
class student
{ int *roll;
float * marks;
static int size;
public:
void getdata( );
void putdata( );
};

- 46 –
int student :: size;
void student :: getdata( )
{
cout <<"Enter the elements of array?\m";
cin >> size;
//Dynamically allocate memory space for these arrays
roll = new int [size]
marks = new float [size];
//check that memory is available of not
if (roll! ='\0' 11 marks = '\0')
{
cout << "Out of memory! aborting!";
return ( );
}
//Read value in the array elemnts;
for (int i = 0; i <size; i++)
{
cout <<"Enter roll no & marks for student" <<i+1<<"\n";
cin>> roll[i]>> marks[i];
}
}
void student :: putdata( )
{
cout << "\t Roll no \t \t marks \n";
for (int i = 0; i<size, i++)
cout <<"\t" <<roll[i] <<"\t\t" <<marks [i] <<"\n";
//Deallocate the memory by array before exiting
delete [ ] roll;
delete [ ] marks;
}
void main( )
{
clrscr( );
student s1;
s1. getdata( );
s1. putdata( );
getch( );
}

- 47 –
 UNIT III
FUNCTION OVERLOADING
Function Overloading polymorphism dk Concept gSaA ftlesa ^,d iaFk vusd dkt^ ds
concept dks mi;ksx esa fy;k tkrk gSaA C++ esa Polymorphism dks nks izdkj ls
Implement fd;k tk ldrk gSaA
1) Function Overloading
2) Operator Overloading
Function overloading esa ,d gh function dks vyx&vyx vFkZ esa iznf'kZr fd;k tkrk
gSaA
tc Operator ds nks ;k nks ls vf/kd Meaning dks define fd;k tkrk gSaA C++ esa
nksuks functions vyx&vyx define gksaxs tks fuEu gSa % &
float divide (int a, int b);
float divide (float x, float y);
mijksDr divide function esa igyk divide function nks integer argument ysrk gSa tks
float ysus okys divide function ls vyx gSaA
,d function dk uke ftldh cgqr lh definitions gSa ftUgsa vyx&vyx arguments ls
differenciate fd;k tkrk gSaA mls function overloading dgrs gSaA

Function Overloading dh vko';drk% & Object dh viuh fo'ks"krk o LoHkko

gksrk gSa tSls bird ,d object rFkk ns[kuk mldk LoHkko gSa mlh izdkj ;g dgk tk
ldrk gSa fd function overloading ds }kjk u dsoy Polymorpism dks implement fd;k
tkrk gSa cfYd Program ds vUrxZr number of comparisons dks Hkh reduce fd;k tkrk
gSa] ftlls Program fastly run gksrk gSaA

Declaration of Definitions: - Function Overloading dh key function dh argument list gSa

ftls function signature Hkh dgk tkrk gSaA
Function dh argument list dks function signature dgk tkrk gSa ;fn fdUgha nks
functions esa same type o same number ds argument same order esa gSa rks mUgsa
same signature ds function dgk tkrk gS tSls% &
void square (int a, float b) //function 1
void square (int x, float y) // same signature as that
// have same signature
function dks mlds argument o return type ls differentiate fd;k tkrk gSaA Overloaded
function dks declare djus esa cgqr Problem gksrh gSa bUgsa vU; function dh rjg
declare fd;k tkrk gSa ijUrq flQZ ,d ckr dk /;ku j[kk tkrk gSa fd function ds
argument dks vyx j[kk tk, rkfd function dks differentiate fd;k tk ldsA
tc ,d gh function dks ,d ls T;knk ckj Program esa declare fd;k tkrk gSa rks
Compiler }kjk second declaration dks fuEu interpretation fd;k tkrk gSa% &
(i) ;fn ml function ds signature igys ls defined functions ds signatures same gSa
rks ml function dks igys function dk redeclartion dgk tkrk gSaA
(ii) ;fn nks function ds signatures exactly match gksrs gSa ij return type
vyx&vyx gks rks function dk second declaration erroneous re-declaration
dgyk,xk ftlls compile time errors generate gksrh gSaA example: -
float square (float f);
double square (float x); //Error
function ftuesa same signature rFkk same name gks ijUrq different return type gks rks
mls C++ esa allow ugha fd;k tkrkA
(iii) ;fn nks function ds signature ;k rks argument ;k type ds vk/kkj ij vyx&vyx
gks rks mu nksuks functions dks overloaded function dgk tkrk gSaA

- 48 –
Calling Overloaded functions: -
Overloaded function dks vU; function dh rjg gh call fd;k tkrk gSaA Number rFkk
Type of arguments ds vk/kkj ij decide fd;k tkrk gSa fd fdl function dks invoke djuk
gSaA
dksbZ Hkh function call lcls igys number rFkk type of argument dks check djrk gSa
ckn esa function dks execute djrk gSa ysfdu dHkh&dHkh float rFkk double values
;k int or long values esa confusion gksrk gSaA tSls ;fn fuEu declaration ds function
dks invoke djuk gSa rks% &
void psqr (double d);
ftlesa value 1.24 nh xbZ gSaA bl value dks float o double dqN Hkh consider fd;k tk
ldrk gSaA
vr% bl izdkj ds confusion dks nwj djus ds fy, constant suffixes dks mi;ksx esa
fy;k tkrk gSaA (f, l, l, UL vkfn)
float – F , long double – L
Unsigned int – U , Unsigned long int – UL
vr% Constant suffix dks mi;ksx esa ysdj ambiguity dks nwj fd;k tkrk gSaA
BEST MATCH <w¡<us ds fy;s dke esa vkus okys steps: - Function
overloading dks argument matching ds }kjk Perform fd;k tkrk gSaA blesa actual
arguments o formal argument dks compare fd;k tkrk gSaA ;gk¡ 3 Possible cases gSa%
&
a) A match: - tc function call dk match fe tk,A
b) No match: - tc function call dk dksbZ match u feysA
c) Ambigious match: - tc function call ls related function dks ,d ls T;knk ckj define
fd;k x;k gksA
Compiler fdlh Hkh function ds fy;s best possible match <w¡<rk gSa blds fy;s
compiler fuEu steps dks follow djrk gSa% &
(1) Exact Match Search djuk% & tSls% &
void fun1 (int);
Overloaded function
void fun1 (double);
fun1 (0); //exact match, match fun1 (int)
(2) A match through promotion: - ;fn exact match ugha feyrk gSa rks actual arguments
ds promotion }kjk Match fd;k tkrk gSa tSls% &
void fun1 (int);
void fun1 (float);
fun1 ('c'); //match through promotion;
match fun1 (int);
3) Match through application of standard C++ rules: - tc exact match o Match through
promotion ugha gksrk rc standard conversion ds }kjk actual argument dks match fd;k
tkrk gSaA
void fun1 (char);
void fun1 (double);
fun1 (471); // match through standard conversion
// matches fun1 (double);

"Example of function Overloading"

void amount (float p, int t, float r)
{ cout << "\n Principal Amount :" <<p;
cout << "\t time :" <<t << "years";
cout << "\t rate :" <<r;

- 49 –
 cout <<"\n Interest Amount :" <<(p*t*r) <<"\n";
}
void amount (float p, int t)
{
cout << "\n Principal Amount :" <<p;
cout << "\t time :"<<t;
cout << "\t rate : 0 ; 0.08
cout << "\n Interest Amount :" << (p*t*0.08) <<"\n";
}
void amount (float p, float r)
{
cout << "\n Principal Amount :" <<p;
cout <<"\t Time : 2 years";
cout <<"\t Rate :" <<r;
cout <<"\n Interest Amount :" << (p*2*r) <<"\n";
}
void amount (int t, float r)
{
cout <<"\ Principal Amount : 2000";
cout <<"\t Time :" <<t<<"years";
cout <<"\t Rate:" <<r;
cout <<"\n" Interest Amount :" << (2000*t*r) <<"\n";
}
void amount (float p)
{
cout <<"\n Principal Amount : "<<p;
cout <<"\t time : 2years";
cout <<"\t Rate: 0.08";
cout <<"\n Interest Amount :" << (p*2*0.08) <<"\n";
}
void main ( )
{
clrscr( );
cout <<"Case 1";
amount (2000.0F);
cout <<"Case 2";
amount (2500.0F, 3);
cout <<"Case 3";
amount (2300.0F, 2, 0.13F);
cout <,"Case 4";
amount (2, 0.13F);
cout <<"Case 5";
amount (6, 0.09F);
}

OPERATOR OVERLOADING
Polymorphism ds}kjk vyx&vyx Internal Structure ds object dks ,d gh External
ShapePolymorphism dks Inheritance implement
interface }kjk Implement fd;k tk ldrk gSaA
djus ds fy, mi;ksx esa fy;k tkrk gSaA tSls
Draw( )

- 50 –
Object Circle Object box Object triangle
Draw (Circle) Draw (box) draw (triangle)
Polymorphism dks Operator o function Overloading ds }kjk Implement fd;k tk ldrk
gSa tgk¡ Same Operator rFkk function vyx&vyx argument ds vk/kkj ij vyx&vyx
dk;Z djrk gSaA bl Polymorphism dks compile time ij gh check dj fy;k tkrk gSa vr%
bls early binding, static binding ;k compile time polymorphism dgykrk gSaA
Operators esa ls dqN Operators ,sls gSa ftUgsa Overload ugha fd;k tk ldrk gSa%
&
 Class member access operator (.,.*)
 Scope resolution operator (::)
 Size operator (sizeof)
 Conditional operator (?:)

DEFINING OPERATOR OVERLOADING: - fdlh Hkh Operator dk ,d vfrfjDr task

define djus ds fy;s mldk ml Class ds lkFk relation define djuk gSa ftlds fy;s
Operator apply fd;k tk,xkA blds fy;s ,d Special function dks define fd;k tkrk gSa
ftls Operator function dgrs gSaA Operator function dh general form dks fuEu izdkj ls
ifjHkkf"kr fd;k tk ldrk gSa% &
return_type class_name :: operator (argument_list)
{
function body //task defined
}
;gk¡ return og value gSa ftls overloaded operator specific operation perform dj return
djsxkA op og Operator gSa ftls overload fd;k x;k gSaA
Operator Function ;k rks member function ;k friend function gksuk pkfg;s ij ;g ges'kk
non static gSaA
fdlh Hkh Operator dks overload djus ds fy, fuEu steps dks follow fd;k tkrk gS% &
1) lcls igys class dks define fd;k tkrk gSa tks Operator overloading ds fy;s data
type dk dk;Z djrh gSaA
2) class definition esa operator function dks declare djuk
3) vc operator function dh specific definition dks class esa ;k class ds ckgj define
djukA (Member function or friend function).
tc Operator function dks member function dh rjg implement fd;k tkrk gS o ;fn
operator binary operator gSa rks flQZ second operand dks gh explicit argument dh rjg
pass fd;k tk,xkA D;ksafd first operand implicitly (compiler }kjk automatically) pass gks
tkrk gSaA
unary operators dks tc member function dh rjg overload fd;k tkrk gSa rks fdlh
Hkh operand dks explicit argument dh rjg pass ugha fd;k tk,xkA
ij tc fdlh Hkh operator function dks friend function dh rjg implement fd;k tkrk
gSa rks dksbZ Hkh argument implicitly (automatically) pass ugha gksrk vr% lHkh

- 51 –
operands dks explicitly pass fd;k tkrk gSaA D;ksafd friend function ds fy;s this
pointer ugha gksrkA
Operation Overloading ds nkSjku fuEu Rules dks ugha cnyk tk ldrk% &
1) Syntax – no. of operands o mudk format
2) Operators dh precedence
3) Operators dh associativity

Rules for Overloading Operators: -

1) Existing (miyC/k) operators dks gh overload fd;k tk ldrk gSa] u;s Operator
dks create ugha fd;k tk ldrkA
2) Operator Overloading esa at least (de ls de) ,d Operand user define type dk
gksuk gh pkfg;sA
3) Operator ds ewy meaning dks change ugha fd;k tk ldrkA vr% + Operator dks
nks Values ds Subtraction ds fy;s mi;ksx esa ugha fy;k tk ldrkA
4) Overloaded operator original operator ds syntax dks gh follow djrh gSaA
5) dqN Operator ,sls gSa ftUgsa Overload ugha fd;k tk ldrkA
6) dqn Operator dks overload djus ds fy;s friend function dks mi;ksx esa ugha
fy;k tk ldrkA flQZ member function dks gh operator overloading ds fy;s
mi;ksx esa fy;k tk ldrk gSaA
7) Unary operators dks tc Member function dh rjg Overload fd;k tkrk gSa rks
explicit argument dh vko';drk ugha gksrhA
8) Binary Operators dks tc member function dh rjg overload fd;k tkrk gSa rks ,d
argument dks explicitly pass fd;k tkrk gSa rFkk tc friend function esa operator
dks overload fd;k tkrk gSa rks nksuksa argument dks explicitly pass fd;k
tkuk vko';d gSaa
Operators that cannot be Overloaded
Sizeof Size of operator
. Membership Operator
.* Pointer_to_member operator
:: Scope Resolution Operator
?: Coalitional operator

Where friend function cannot be Used

= Assignment operator
() Function call operator
[] Subscripting operator
 Class member access operator

OVERLOADING UNARY OPERATORS: -

Unary minus operator: -
class unary1
{ int x, y, z;
public:
void input (int m, int n, int o)
{ x = m;
y = n;
z = o;
}

- 52 –
 void display ( );
void operator-( ); //overload unary minus
};
void unary1 :: display( )
{ cout <<"x =" <<x;
cout <<"y =" <<y;
cout <<"z ="<<z;
}
void unary1 :: operator-( )
{ x = -x;
y = -y;
z = -z;
}
void main ( )
{ unary1 ob1;
ob1.input (10, -40, 60);
cout <<"ob1:";
ob1. display( );
-ob1;
cout <<"ob1:";
ob1.display( );
}

UNARY + OPERATOR
As member function;

# include <iostream.h>
#include <conio.h>
class s1
{
int x,y;
public:
void in (int a, int b)
{
x = a;
y = b;
}
void out( )
{
cout <<"x: -" <<x;
cout <<" y: -"<<y;
}
void operator + ( )
{
x2 + x;
y2 + y;
}
};
void main ( )
{

- 53 –
 s1 ob;
ob. in (2, -3);
ob. out ( )
+ ob;
ob. out ( );
}
Result: - x = 2, x = 2
y = -3, y = 3

Unary Preincrement operator (++)

Through member function
# include <iostream.h>
# include <conio.h>
class s1
{
int x,y;
public:
void in (int a, int b)
{
x = a;
y = b;
}
void out ( )
{
cout <<"x " <<x;
cout <<" y " <<y;
}
void operator ++ ( )
{
x = ++x; //x = x++;
y = ++y; //y = y++;
}
};
void main( )
{ s1 o1;
o1. in (2, -3);
o1. out ( );
++ o1;
o1. out ( );
}
Result x=2 x=3
y = -3 y = -2

Unary Decrement Operator

Through Member Function
# include <iostream.h>
# include <conio.h>
class s1
{
int x,y;
public:

- 54 –
 void in (int a, int b)
{
x = a;
y = b;
}
void out ( )
{
cout <<"x " <<x;
cout <<" y " <<y;
}
void operator –( )
{
x = x –1;
y = y-1;
}
};
void main( )
{
s1 01;
o1. in (2, -3);
o1. out ( );
-- o1;
o1 . out ( );
}

Unary + & minus operator overloaded through friend function

# include <iostream.h>
# include <conio.h>
class s1
{
int x,y;
public:
void in (int a, int b)
{
x = a;
y = b;
}
void out ( )
{
cout <<"x " <<x;
cout <<" y " <<y;
}
friend void operator – (s1 & o);
friend void operator + (s1 & o);
};
void operator + (s1 & o)
{
o.x = + o.x;
o.y = +o.y;
}

- 55 –
void operator – (s1 & o)
{
o.x = -o.x;
o.y = - o.y;
}
void main( )
{
s1 o1;
ob. in (2, -3);
o1. out ( );
+o1;
o1. out ( );
- o1;
o1. out ( );
}

Unary Increment & Decrement Operator Overloading through friend function

# include <iostream.h>
# include <conio.h>
class s1
{
int x,y;
public:
void in (int a, int b)
{
x = a;
y = b;
}
void out ( )
{
cout <<"x " <<x;
cout <<" y " <<y;
}
friend void operator ++ ( );
friend void operator – ( );
};
void operator ++ (s1 & o)
{
o.x = ++ o.x;
o.y = ++ o.y;
}
void operator – (s1 & o)
{
o.x = -- o.x;
o.y = -- o.y;
}
void main( )
{
s1 o1;
o1. in (2, 3);

- 56 –
 o1. out ( );
++o1;
o1.out ( );
-- o1;
o1.out ( );
}

BINARY OPERATOR OVERLOADING

Binary + Operator through member function (complex No. Addition)
# include <iostream.h>
# include <conio.h>
class complex
{
int real, imag;
public:
void in (int a, int b)
{
real =a;
imag = b;
}
void out ( )
{
cout <<real<<"+i"<<imag <<endl;
}
complex operator + (complex ob)
{
complex ob1;
ob1. real = real + ob.real;
ob1. imag = imag + ob.imag;
return (ob1);
}
};
void main( )
{
complex ob, ob1, ob2;
ob.in (7, 9);
ob.out ( );
ob1.in (3, 4);
ob1.out ( );
ob2 = ob+ob1;
ob2.out ( );
}

Binary - Operator through member function (complex No. Subtraction)

# include <iostream.h>
# include <conio.h>
class complex

- 57 –
{
int real, imag;
public:
void in (int a, int b)
{
real =a;
imag = b;
}
void out ( )
{
cout <<real<<"+i"<<imag <<endl;
}
complex operator – (complex ob)
{
complex ob1;
ob1.real = real – ob.real;
ob1.imag = imag – ob.imag;
return (ob1);
}
};
void main( )
{
complex ob, ob1, ob2;
ob.in (7, 9);
ob.out ( );
ob1.in (3, 4);
ob1.out ( );
ob2 = ob - ob1;
ob2.out ( );
}

Binary * Operator through member function (complex No. Multiplication)

# include <iostream.h>
# include <conio.h>
class complex
{
int real, imag;
public:
void in (int a, int b)
{
real =a;
imag = b;
}
void out ( )
{
cout <<real<<"+i"<<imag <<endl;
}
complex operator * (complex ob)

- 58 –
 {
complex ob1;
ob1.real = real * ob.real – imag* ob.imag;
ob1.imag = real*ob.imag+imag*ob-real;
return ob1;
}
};
void main( )
{
complex ob, ob1, ob2;
ob.in (7, 9);
ob.out ( );
ob1.in (3, 4);
ob1.out ( );
ob2 = ob*ob1;
ob2.out ( );
}

Binary + =, -= Operator through member function

# include <iostream.h>
# include <conio.h>
class plus_minus
{
int x, y;
public:
void in (int a, int b)
{
x =a;
y = b;
}
void out. ( )
{
cout <<x<< "+" << y <<end1;
}
void operator + = (plus_minus o1)
{
x + = o1.x; // x = x + o1.x;
y + = o1.y; // y = y + o1.y;
}
void operator -= (complex 01)
{
x - = o1.x; // x = x - o1.x;
y - = o1.y; // y = y - o1.y;
}
};
void main( )
{
plus_minus ob, ob1;
ob.in (7, 9);
ob.out ( );

- 59 –
 ob1.in (3, 4);
ob1.out ( );
ob + = ob1;
ob.out ( );
ob- = ob1;
ob.out( );
}
Result: - ob = 7,9
ob1 = 3,4
10, 13 + = Result
7, 9 - = Result

Binary + =, -= Operator through friend function

# include <iostream.h>
# include <conio.h>
class plus_minus
{
int x, y;
public:
void in (int a, int b)
{
x =a;
y = b;
}
void out. ( )
{
cout <<x<< "+" << y <<end1;
}
friend plus_minus operator + = (plus_minus & o1, plus_minus & o1);
friend plus_minus operator - = (plus_minus & o1, plus_minus & o2);
};
plus_minus operator + = (plus_minus & o1, plus_minus & o2)
{
o1.x += o2.x;
o1.y += o2.y;
return o1;
}
plus_minus operator - = (plus_minus & o1, plus_minus & o2)
{
o1.x - = o2.x;
o1.y - = o2.y;
return o1;
}
void main( )
{
plus_minus ob, ob1;
ob.in (10, 29);
ob.out ( );
ob1.in (20, 30);
ob1.out ( );

- 60 –
 ob + = ob1;
ob.out ( );
ob- = ob1;
ob.out( );
}
Result: - ob 10, 29
ob1 20, 30
ob = 30, 59 +=Result
ob = 10, 29 - = Result
SPECIAL OPERATOR OVERLOADING

Subscript Operator ([ ])

# include <iostream.h>
# include <conio.h>
class sub
{
int a1 [4];
public :
sub (int a, int b, int c, int d)
{
a1 [0] = a;
a1 [1] = b;
a1 [2] = c;
a1 [3] = d;
}
int operator [ ] (int i)
{
return a1 [i];
}
};
void main( )
{
int i;
sub x (2, 3, 4, 5);
cout << x [2];
}
Result: - It shows 4

mijksDr Program esa ;g leL;k gSa fd ;fn Array Index esa 4 ls T;knk Value Hkh nh
tk;s rks og mls Accept dj Result Garbage Output ds :i esa nsxkA
vr% ;g dgk tk ldrk gSaA mijksDr Program Array Index dks check ugha djrk gSa
blfy, fuEu Program }kjk bl Problem dks nwj fd;k tk ldrk gSaA
# include <iostream.h>
# include <conio.h>
class sub
{
int a1 [4];
public :
sub (int a, int b, int c, int d)

- 61 –
 {
a1 [0] = a;
a1 [1] = b;
a1 [2] = c;
a1 [3] = d;
}
int & operator [ ] (int i)
{
if (i < 0 || i>3)
{
cout <<"subscript is out of range";
exit (1);
}
return a1 [i];
}
};
void main ( )
{
int i;
sub x (2, 3, 4, 5);
cout << x [2];
}
Result: - x: - 4

Arrow Operator () Overloading

# include <iostream.h>
# include <conio.h>
class arr
{
public :
int x;
arr*operator ( )
{
return this;
}
};
void main( )
{
arr m;
m.x = 20;
cout << m x;
m x = 30;
cout << m x;
}
Result: - 20
30

Function Call Operator (( )) Overloading

- 62 –
# include <iostream.h>
# include <conio.h>
class fcall
{
int x, y;
public:
fcall ( )
{
x = 0;
y = 0;
}
fcall (int m, int n)
{
x = m;
y = n;
}
fcall operator ( ) ( int i, int j)
{
x = 2*i;
y = 2*j;
return * this;
}
void display ( )
{
cout <<"The value of x : -" <<x;
cout <<"The value of y :-"<<y;
}
};
void main( )
{
fcall ob1 (2,3), ob2 (7,7);
ob1. display ( );
ob2. display ( );
ob1 (2, 3);
ob2 (3,4);
ob1.display ( );
ob2. display ( );
}
Result: - 2, 3 7, 7
4, 6 ob1
6, 8 ob2

Overloading of Insertion << & Extraction >> Operator

const int size = 3;
class ( )
{ int a[size];
public:
c1 ( );
c1 (int x);
friend c1 operator * (int a, c1 b);

- 63 –
 friend istream & operator >> (istream & in, c1&c);
friend ostream & operator << (ostream & out, c1 & c);
};
c1 :: c1( )
{ for (int i = 0; i < size; i++)
a[i] = 0 : 3
}
c1 :: c1 (int x)
{ for (int i = 0; i = size; i++)
{ a(i) = x; }
}
c1 operator * (int a, c, b)
{ c1 c;
for (int i = 0; i < size; i++)
{ c.a [i] = b.a[i]*a;}
return c;
}
istream & operator >> (istream & in, c1 & c)
{ for (int i = 0; i < size; i++)
{ in>> c. a[i];}
} return in;
ostream & operator << (ostream & out, (i & c)
out << "<";
{ for (int i = 0; i < size; i++)
out << c.a[i] << ",";
out << ">";
return out;
}
};
void main( )
{ c1 m;
cout <<" Enter the element in m "<<"\n";
cin>>m;
cout << "m=" <<m<< "\n";
c1 p;
p = 2*m;
cout << "p=" <<p<< "\n";
}

Overload new & delete Operator

#include <stdlib.h>
class emp
{ char name [20];
int age, sal;
public:
void * operator new (size);
void operator delete (void * q);
emp ( );
~ emp ( );
};

- 64 –
emp :: emp ( )
{ cout << end1 << "In constructor" ;
}
emp :: ~emp ( )
{
cout <<endl << "in Destructor";
}
char pool [sizeof (emp)];
void * emp :: operator new (s)
{ out << end1 << "Reached at new";
return pool;
}
void emp :: operator delete (void * q)
{ cout << end1 <<"reached emp :: delete";
}
void main( )
{
emp * e1;
e1 = new emp;
delete e1;
}

- 65 –
 Unit – IV

INHERITANCE

;g ges’kk vPNk gksrk gSa fd fdlh oLrq dks ckj&2 cukus ds LFkku ij igys ls
cuh gqbZ oLrq dk iz;ksx gks ldsA ,slk djus ls le; dh cpr rks gSa lkFk gh og
tfVy gksus ls Hkh cp tkrh gSaA rFkk budk iz;ksx djuk vklku gks tkrk gSaA
blds lkFk gh mlesa Modification djus rFkk le>us esa Hkh vklkuh gksrh gSaA
bl izdkj ckj&ckj ,d gh dke djus ls cp tkrk gSaA

C++ esa Re use ability ds fl)kUr dks n`<rk ls Support djrh gSaA C++ dh Classes ge
fofHkUu fof/k;ksa ls Reuse dj ldrs gSaA ,d ckj tks Class cuk yh tkrh gSaA mls
vU; Class dh lgk;rk ls oolopt dj fy;k tkrk gSaA vFkkZr~ ,d u;h Class dks iwjkuh
Class ls Drive djuk rFkk iwjkuh Class dh leLr Property dks iwu% iz;ksx djuk gh
Inheritance vFkok Derivation dgykrk gSaA Inheritance esa iwjkuh Class dks Base
Class rFkk u;h Class dks Derived Class dgk tkrk gSaA Derived Class }kjk Base Class
dh dqN vFkok leLr Properties dks Inherit fd;k tk ldrk gSaA Derived Class dks
declare rFkk Define djus dk dk;Z bldh Base Class ls Relationship Specify djds fd;k
tkrk gSaA Derived Class dk mldh Base Class ls Relationship specify djus ds fy, :
(Colon) dk iz;ksx fd;k tkrk gSaA Derived Class dks fuEu izdkj Declare rFkk Define
fd;k tk ldrk gSaA

Class derived class_name : Visibility mode base class_name

{
};
Example Class B: Private A // A Base Class & B Derived Class

Visibility mode Optional gksrk gSaA mls ge private rFkk Public ns ldrs gSaA
Default visibility mode Private gksrk gSaA visibility mode ;g fu/kkZfjr djrk gSa fd
Base Class dks Publicity derived fd;k x;k ;k Privately

Class emp: Public worker // Publicly derived

Class emp: Private worker // Privately derived
Class emp: worker // By default privately

tc Derived Class dks Base Class ls Privately inheritance fd;k tkrk gSaA rc Base Class
ds Public member Hkh derived class esa Private cu tkrs gSaA vkSj bl izdkj Base
Class ds Public Function dks derived class ds member function }kjk gh access fd;k tk
ldrk gSaA bUgsa Object ds ek/;e ls (.) Operator dk iz;ksx djds Directly access
ugha fd;k tk ldrkA tc Derived Class dks Base Class ls Publicly inherit fd;k tkrk
gSaA rc Base Class ds Public members Hkh Derived Class esa Public gh cus jgrs

- 66 –
gSaA vkSj bUgs Object ds ek/;e ls (.) Operator dk iz;ksx djds Directly access fd;k
tk ldrk gSaA ijUrq nksuks gh n’kkvksa esa Base Class ds Private members inherit
ugha gksrs gSaA blfy, Base Class ds Private members Derived Class esa dHkh
ugha vk ldrsA

lyees of Inheritance

(i) Single Inheritance

(ii) Multilevel Inheritance
(iii) Multiple Inheritance
(iv) Hierarchical Inheritance
(v) Hybrid Inheritance

(1) Single Inheritance :- tc dsoy ,d gh Base Class ij vk/kkfjr u;h Derived Class cuk;h
tkrh gSa rks ;g Single Inheritance dgykrk gSaA

Base Class A Derived Class B

bl fp= esa Class A ls Class dks Inheritance iznku fd;k tk jgk gSaA Class B esa
Class A dh lHkh Properties rks gksxh gh lkFk esa bldh viuh Properties define dh tk
ldrh gSaA

// Publicity inheritance with Single

Example :- Class B
{
int a; //not inheritable
public:
int b; //ready for inheritance
void get_ab ( );
int get_a( );
void show_a ( );
};
class D: Public B //Publicaly inheritance
{
int c;
public:
void display ( );
};
void B:: get_ab ( )
{
a=5; b=10;
}
int B:: get_a ( )
{
return a;
}

- 67 –
 void B:: show_a ( )
{
cout << “a=” <<a<< “\n”;
}
void D:: mul ( )
{
c=b * ge_a ( );
}
void D:: display ( )
{
cout <<“a=” <<get_a ( ) << “\n”;
cout <<“a=” <<b<< “\n”; Private Section
cout <<“c=” <<c<< “\n\n”; C Variable from Private
section with class D
}
int main ( ) Public Section
{
D d; b
d. get_ab ( );
d. mul ( ); get_ab ( )
d. show_a ( ); Inherited from B
d. display ( );
get_a ( )
d.b = 20; Function from B
d. mul ( );
d. display ( ); show_a ( )
return 0;
}
Mul ( )
Function
from
Display ( )
Class D

// Privately Inheritance with single inheritance

class B
Q. {
f. int a;
c public:
c int b;
[ void get_ab ( );
c int get_a ( );
};
class Q: Private B
{
int c;
public:
void mul ( );
void display ( );

- 68 –
 };
void B:: get_ab ( )
{ void D:: display ( ).
cout “\n Enter values for a and b”; {
cin>>a>>b; show_a ( );
} cout<<“b=”<<b<<“\n”<< “c=” <<c<< “\n\n”;
int B:: get_a ( ) }
{ int main ( )
int B:: get_a ( ) {
{ D d;
return a; // d. get_ab ( ); //notwork
} d. mul ( );
void B:: show_a ( ) //d. show_a ( ); //notwork
{ d.display ( );
cout <<“a=” <<a<< “\n”; //d.b = 20; //notwork
} d. mul ( );
void D:: mul ( ) d. display ( );
{ return 0;
get_ab ( ); }
c=b * get_a( );
}

“Making a Private member inheritance”

vHkh rd geus ns[kk fd dSls ,d Base Class dh Functionality dks Inheritance
dk iz;ksx djds c<+k;k tk ldrk gSaA ijUrq vHkh rd gekjs ikl ,slk dksbZ rjhdk
ugha gS ftlus Member dks Inherite fd;k tk ldsA ge Class esa lHkh Privte members
dks Public cukdj Hkh ;g dk;Z dj ldrs gSaA rkfd ;s Derived Class esa nksckjk
Directly access fd;k tk ldsA ijUrq ,slk djus ls Object Oriented Programming ds eq[;
fl)kUr Data Hiding dh mis{kk gks tkrh gSaA
C++ esa bl leL;k ds lek/kku ds fy, ,d u;s Visibility mode ftls Protected dgk
x;k gSa }kjk fd;k x;k gSaA ;fn fdlh Member dks Protected fd;k x;k gSaA rks mls
mlh Class ds Member Function }kjk rFkk ml Class ds vkxs okyh derived Class ds
Member ( ) }kjk access fd;k tk ldrk gSaA mls bu nksuks Classes ds vykok fdlh
Outside Function }kjk access ugha fd;k tk ldrk gSaA
Syntax :- Class alpha
{
Private : //Optional visible to member functions within its class
Protected : //visible to member functions of its own and derived class
Public : //visible to all function in the programe
};

tc fdlh Protected Member dks Publicly Inherit fd;k tkrk gSa rks og Derived
Class esa Hkh Protected cuk jgrk gSaA bl izdkj bls ge Derived Class esa Member
Function dh lgk;rk ls access dj ldrs gSa rFkk lkFk gh eq[; ckr ;g gSa fd ;g
Protected Member vkxs iwu% Inherit fd;s tk ldrs gSaA
tc Protect Members dks Private Mode esa Inherit fd;k tkrk gSaA rc ;g Derived
Class esa Private Members cu tkrs gSaA vFkkZr ;s Members vc Derived Class ls
Member Function dh lgk;rk ls access fd;k tk ldrs gSaA ijUrq vkxs inherit ugha fd;s
tk ldrs gSaA

- 69 –
 fdlh Base Class dks Protected Mode esa Hkh inherit fd;k tk ldrk gSaA
Protected Derivation esa Base Class ds nksuksa Members, Public rFkk Protected,
Derived Class esa vkdj Protected cu tkrs gSaA
Derived Class Visibility
Base Class Public Private Protected
Visibility Derivation Derivation Derivation
Private Not inheritable Not inheritable Not inheritable
Protected Protected Private Protected
Public Public Private Protected
Multilevel inheritance :- tc fdlh Derived Class }kjk fdlh igys ls cuh Derived
Class dks Inheritance fd;k tkrk gSa rks bls Multilevel Inheritance dgk tkrk gSaA

Base Class 1 X Base Class 2 Y Derived Class Z

Class Y: visibility_mode x;
{
Body of Y;
};
Class z: visibility_mode y;
{
Body of Z;
};
// Example of Multilevel inheritance
#include<iostream.h>
#include<conio.h>
class st4
{
protected:
int roll_number;
public:
void get_number (int);
void put_number ( );
};
void stu:: get_number (inta)
{
roll_number = a;
}
void stu :: put_number ( )
{
cout<<“\n\troll number:” <<rollnumber<<“\n”;
}
class test:public stu
{
protected:
float m1;
float m2;
Public :
Void get_marks (float,float);
Void put_marks ( );

- 70 –
 };
void test :: get_marks (floatx, floaty)
{
m1=x; m2=y;
}
void test :: Put_marks ( )
{
cout<<“\n Marks in sub1:“<<m1<<“\n”;
cout<<“\Marks in sub2:” <<m2<<“\n”;
cout << “-------“;
}
class Result : Public test
{
float total;
Public:
Void display ( );
};
void Result :: display ( )
{
total = m1+m2;
put_number ( );
put_marks ( );
cout<<“\n\t total :” <<total<<“\n”;
cout<< “--------------“;
}
void main ( )
{
clrscr ( );
result s;
s.get_number (111)
s.get_marks (75, 65)
s.display ( );
getch ( );
}

Multiple inheritance :- tc fdlh ,d Class dks ,d ls vf/kd Inheritance dks Multiple

Inheritance dgk tkrk gSaA
Basex class 1 Basey class 2 Basez class 3

DerivedA class

//Example of multiple inheritance

# include <iostream.h)
# include <conio.h)
class man
{
Protected:
int m;

- 71 –
 Public c:
Void get-m (int);
};
class nan
{
Protected
int n;
Public :
Void get_n (int);
};
class pop:public man, public nan
{
Public:
Void display ( );
};
void man:: get_m (int x)
{
m=x;
}
void nan::get_n (int y)
{
n=y;
}
void pop:: display ( )
{
cout<<“\n\tm=”<<m<<“\n”;
cout<<“\n\tn=”<<n<<“\n”;
cout << “---------“;
cout<<“\n\t m&n=”<<m*n<<“\n”;
cout<< “---------“
}
void main ( )
{
clrscr ( );
pop p;
p. get_m (111);
p.get_n (75)
p.display ( );
getch ( );
}

Hybrid Inheritance :- dbZ ckj ,slh ifjflFkfr vkrh gSa tc gesa ,d ls vf/kd
izdkj ds Inheritance dks iz;ksx djuk iM+rk gSaA tc fdlh Class dks ,d ls vf/kd
izdkj ds Inheritance iznku fd, tkrs gSa rks bl izdkj Inheritance dks Hybrid
Inheritance dgk tkrk gSaA

Basex class1

Derived class to x & Basez class1

Base class 2 for A

- 72 –
 Derived Class A

//Example of hybrid inheritnce

# include Miostream.h>
# include <conio.h>
class stu
{
Procted:
Int roll_number (int);
Public:
Void get_number (int);
Void Put_number ( );
};
void stu :: get_number (int a)
{
roll_number =a;
}
void stu:: put_number ( )
{
Class test: Public stu
{
Protected:
float m1;
float m2;
public:
void get_marks (float, float);
void Put_marks ( );
};
void test :: get_marks (floatx, floaty)
{
m1=x;
m2=y;
}
void tet:: Put_marks ( )
{
cout<<“\n Marks in sub1:” <<m1<< “/n”;
cout<<“Marks in sub2:” <<m2<<“/n”;
cout << “-----------“;
}
class sport
{
Protected:
Char grade;
Public:
Void get_grade (char s)
{

- 73 –
 grade =s;
}
void put_grade ( )
{
cout <<“/n Grade in Sports:” <<grade << “\n\n”;
}
};
class result: Public test, Public sport
{
float total;
Public:
Void display ( );
};
void result :: display ( )
{
total = m1+m2
put_number ( );
Put_marks ( );
Cout << “\n\tTotal:” <<total<< “\n”;
Cout << “----------\n”;
Put_grade ( );
}
void main ( )
{
clrscr ( );
result s;
s.get_number (111)
s.get_grademarks (75, 65)
s.get_grade (‘A’);
s.display ( );
getch ( );
}

Constructors & Destructors in Inheritance

ge tkurs gSa fd constructors object initialization esa egRoiw.kZ role vnk djrs
gSaA ;fn base class constructor esa dksbZ Hkh argument pass ugha fd;k x;k gSa
rks derived class esa constructor function dh vko';drk ugha gksrh gSaA ;fn fdlh
base class esa ,d ;k ,d ls vf/kd arguments ds lkFk constructor dks define fd;k x;k
gSa rks ;g vko';d gSa fd derive class esa Hkh parameterized constructor gks rFkk
base class constructors esa value dks pass djok;k tk ldsA blds fy;s inheritance dks
mi;ksx esa ysdj derived class ds object cukdj base class constructor esa argument
Course pass fd;k tkrk gSaA vr% tc base class o derived class nksuks esa Constructor
dks define fd;k tkrk gSa rks igys base class constructor execute gksrk gSaA ckn
esa derived class constructor dks execute fd;k tkrk gSaA
Multiple inheritance ds case esa] base class dks muds derived class esa
declaration ds vk/kkj ij construct fd;k tkrk gSaA Multilevel Inheritance esa constructor
dks inheritance ds order esa execute fd;k tk,xkA

- 74 –
 vr% derived class, base class dh Initial values pass djus dh responsibility ysrk
gSaA vr% derived class ds object ds }kjk lHkh classes dks initial value pass dj nh
tkrh gSaA
Derived Constructor function dh header line dks (:) colon ds }kjk nks Parts esa
separate fd;k tkrk gSaA first part esa argument declaration fd;k tkrk gSa ftls derived
constructor esa pass djuk gks rFkk second part base constructor dks function call list
dks iznf'kZr djrk gSaA
Example: - D (int a), int a2, float b1, float b2, int d1):
A (a1, a2), B(b1, b2)
 
Call to constructor A Call to constructor B
{
d = d1; //execute own constructor variable
}
mijksDr mnkgj.k esa A(a1, a2) A base constructor dks invoke djrk gSaA rFkk B(b1,
b2) B base constructor dks Invoke djrk gSaA rFkk D class ds Lo;a ds rhu values
gSaA bu lHkh dks D ds Object ds }kjk fuEu izdkj invoke fd;k tk,xk% &
D obj (5, 12, 3.0, 4.5, 16);
Execute of Base Class Constructor
Class B : public A Order of Execution
{ A ( ); base constructor
B ( ); derived cosntructor
};

---------x-------------x-----------x-------------x------------

Class A : public B, public C

{ B ( ); base (first)
C ( ); base (second)
}; A ( ); derived

---------x-------------x-----------x-------------x------------

Class A : public B, virtual public C

{ C( ); virtual base
B ( ); ordinary base
}; A ( ); derived

Example: -
Class A
{ int x;
public :
A (int i)
{ x = i;
cout <<"x is initialized\n";
}
void show( )
} cout <<"x=" << x << "\n";}
};

- 75 –
Class B
{
float y:
public :
B (float s)
{ y = s;
cout <<"B is initialized "\n";
}
void show1( )
{ cout <<"y=" <<y<<"\n";}
};
class C : public B, public A
{
int a, b;
public :
c(int i, float j, int k, int l); A(i), B(j)
{
k = a;
l = b;
cout << "C is initialized \n";
}
void show2( )
{ cout <<" a =" << a << "\n";
cout <<"b =" <<b<< "\n";
}
};
main( )
{
c ab (5, 3.5, 7, 10);
ob. show ( );
ob. show1 ( );
ob. show2 ( );
}
vr% Inheritance esa Constructor define djus ds fy;s fuEu syntax gSa %&
Constructor_name (argument list): initialization section
{
assignment section
}
ge tkurs gSa fd igys base class constructor execute gksrs gSa ckn esa derived class
constructor dks execute gksrs gSa ckn esa derived class constructor dks execute fd;k
tkrk gSa tcfd destructure blds foijhr dk;Z djrs gSaA igys derived class constructor
dks destruct fd;k tk,xk ckn esa base class object destruct gksxkA

Polymorphisom :-;g oops dk lcls egRoiw.kZ xq.k gSaA tSlk fd blds uke ls
gh izrhr gksrk gSaA bldk rkRi;Z gSa ,d gh oLrq ds vusd :i vHkh rd
Polymorphism dks ge Function dks Select djus ds fy, Compiler }kjk muds
Arguments ds Datatype rFkk la[;k dks Match fd;k tkrk gSaA ;g Information Compiler
dks Compile time ij izkIr gksrh gSaA ftls Compiler Appropriate Function dks Compile
time ij gh Call dj ysrk gSaA
Polymorphism eq[;r% nks izdkj dk gksrk gSaA

- 76 –
 1. Compile time
2. Run time Polymorphism
(1) Compile time Polymorphism – C++ esa ge ,d uke ds vf/kd Function vius
Programme esa cuk ldrs gSaA rFkk tc bUgsa iz;ksx djus ds fy, Call fd;k tkrk
gSaA rc Compiler ml Function ds fy, Arguments dh la[;k rFkk muds Datatype dks
feykrk gSaA pwafd ;g dk;Z Compile time Polymorphism, Early binding vFkok Static
Binding dgk tkrk gSaA bl izdkj early binding dk vFkZ ,d Object dk vFkZ ,d Object
}kjk Function dks Compile time esa gh igpku dj Call fd;k tkrk gSaA
(2) Run time Polymorphism – vusd ckj ,slh fLFkfr vkrh gSa fd nks Classes
ftuesa ge Inheritance dk iz;ksx dj jgs gSa ftudk Prototype Hkh leku gksrk
gSaA ;g Function Overloading ugha dgk tk ldrk gSaA D;ksafd leku uke o
Prototype okys Function vyx&vyx Classes esa gSaA ,slh fLFkfr es tc Function dks
Call fd;k tkrk gSaA rc Compiler dks ;g Kkr ugha gks ikrk gSa fd buesa fdl
Function dks Call fd;k tkrk gSaA ,slh fLFkfr esa derived Function dks Programme
esa Runtime ij Select djds Call fd;k tkrk gSaA bls Runtime Polymorphism dgrs
gSaA
Example : Class x
{
public:
void disp ( ); //In base class
{
}
};
class y: classx
{
= Public:
void disp ( ); //In Derived class
{
=
}
};

mijksDr Function dks Overloaded ugha dgk tk ldrk gSaA D;ksafd nksuks
vyx&2 Classes esa gSaA ,slh fLFkfr esa Compiler ;g tku ugha ik;sxk fd dkSulk
Function Call gksA bl fLFkfr esa Runtime Polymorphism dk iz;ksx fd;k tkrk gSaA
C++ esa Runtime Polymorphism ds fl)kUr dks iz;ksx esa ykus ds fy, Virtual
Function dk iz;ksx djuk gksrk gSaA Run time Polymorphism dks Late binding rFkk
Dynamic binding Hkh dgk tkrk gSaA Dynamic binding dks iz;ksx esa ykus ds fy,
Pointer Type ds Object ds ckjs esa Hkh tkuuk o le>uk vko’;d gSaA

Early binding or Static binding Polymorphism Late binding or Dynamic

binding

Compile time Run time

Polymorphism Ploymorphism

Function Operator Virtual

Overloading Overloading Function

- 77 –
 Pointer to Object – vc rd geus Pointer dk iz;ksx Variable ds lkFk gh fd;k
gSaA Pointer dk iz;ksx fdlh Class ds Pointer Type ds Object cukus ds fy, Hkh fd;k
tk ldrk gSaA Pointer Type ds Object Runtime ij u;s Object cukus ds dke esa vkrs
gSaA Pointer Type ds Object ls ge mlh Class ds Public Members Hkh access dj ldrs
gSaA Pointer Type ds Object fuEu izdkj cuk;s tk ldrs gSaA

xyz A
xyz *ptr = &A
Example:-
Class item
{
int code;
float Price;
Public:
Void getdata (int a, float b)
{
code=a;
Price =b;
}
void show (void)
{
cout<<“Code:”<<code<<“\n”;
cout<<“Price:”<<Price<<“\n”;
}
};
void main ( )
{
item x;
item *ptr = &x;
ptr getdata (10, 25.75);
ptr show ( );
getch ( );
}

Virtual Function – tc ge Base Class rFkk derived Class esa leku uke o
Prototype ds Function cukrs gSa rks ;g vko’;d gSa fd Base Class ds Member
Function dks Virtual keyword ds lkFk cuk;s tk;sA tc fdlh Function dks Virtual cuk
ysrs gSa rc Compiler Function dks igpku dj Runtime ij Pointer ds vk/kkj ij u djds
Object ij dk;Z dj ldrs gSaA dHkh&2 ,slh fLFkfr gksrh gSa fd gesa Runtime
Polymorphism dks iz;ksx esa ykus ds fy, Base Class esa Virtual Function cukus
iM+rs gSaA ijUrq buls dksbZ dk;Z lEiUu ugha djkuk gks rks Base Class esa bl
izdkj define djrs gSaA
Virtual Void display ( ) = O;
MijksDr Function dksbZ dk;Z ugha djsxkA vr% bl izdkj define Vritual
Function dks Pure Virtual Function dgk tkrk gSaA
Virtual Functio cukus ds fu;e
1. ;s fdlh Class dk Member gksuk vko’;d gSaA
2. bldks dsoy Pointer type ds Object ls gh acces fd;k tk ldrk gSaA
3. ;s fdlh nwljh Class ds fy, Friend Function gks ldrs gSaA

- 78 –
4. bldks Base Class esa define fd;k tkuk vko’;d gSaA
5. Virtual Constructor ugha cuk;s tk ldrs gSaA ijUrq Virtual Destructor cuk;s
tk ldrs gSaA
6. Base Class dk Pointer, derived class ds Object dks rks access dj ldrk gSa
ijUrq derived class dk Pointer, Base Class ds Object dks access ugha dj ldrk
gSaA
7. Base Class esa define Virtual Function rFkk Derived esa Class esa define
function dk uke rFkk Prototype leku gksus pkfg,A

Example:-
Class Base
{
Public:
Void display ( )
{
cout<<“\n Display Base”;
}
virtual void show ( )
{
cout<<“\n show Base”;
}
};
class derived: Public Base
{
Public:
Void display ( )
{
cout<<“\n Display derived”;
}
void show ( )
{
cout<<“\n show derived”;
}
};
void main ( )
{
Base B;
Derived D;
Base *bptr;
Cout<<“\n bptr Points to base\n”;
Bptr = &B;
bptr display ( );
bptr show ( );
cout<<“\n\n bptr Points to derived \n”;
bptr = &D;
bptr display ( );
bptr show ( );
getch ( );
}

- 79 –
 Pointer to derived Class :- ge dsoy Base Class dk gh Pointer Object ugha cuk
ldrs cfYd derived class dk Hkh pointer Object cuk ldrs gSaA mnkgj.kr% ;fn B ,d
Base Class gSaA rFkk D ,d deroved Class gSa rks B Class dk Pointer D Class dks Hkh
Point dj ldrk gSaA Base Class ds Pointer Object ds }kjk ge dsoy mUgha Members
dks access dj ldrs gSa tks B Class ls Inherit gq, gSaA mu members dks access
ugha fd;k tk ldrk gSa tks D Class ls lEcaf/kr gksrs gSaA ;fn Base rFkk derived
class nksuks esa dksbZ Member Same gSa rks Base Class ds Pointer Object ds }kjk
ges’kk Base Class ds M ember dks gh access fd;k tk;sxkA vFkkZr Base Class dk
Pointer derived Class ds lHkh Members dks directly access ugha dj ldrk gSaA blds
fy, gesa derived class dh Pointer Object declare djuk gksxkA
Example:
Class BC
{
Public:
int b;
void
void show ( )
{
cout<<“b=”<<b<<“\n”;
}
};
Public:
int d;
Void show ( )
{
cout <<“4”<<“\n”<<“d=”<<d<“\n”;
}
};
void main ( )
{
BC *bptr;
BC base;
Bptr = & base;
bptr – b= 100; //access the bc via base Pointer
cout <<“bptr Points to base object\n”;
bptr – show ( );
// derived class
DC derived;
Bptr = & derived;
bptr b=200; //access DC via base Pointer
/* bptr d=300; */ //won’t work
cout<<“bptr now Points to derived object
/* accessing d using a pointer of the derived class DC */
DC *dptr;
dptr = & derived;
dptr = & derived
dptr 300;
cout<<“dptr is derived type Pointer \n”;
dptr show ( );
getch ( );

- 80 –
}

- 81 –
 Unit – V
C++ Streams
Stream Sequence of bytes dk Source gSaA Stream dks fdlh Hkh I/O device rFkk I/O
dks uniformed way esa perform djus ds fy;s Use esa fy;k tkrk gSaa C++ dh
iostream Library abstraction dk ,d Object Oriented implementation gSaA C++ esa I/O
Streams dks Use esa ysus ds fy;s iostream.h header file dk Program esa Use esa fy;k
tkrk gSaA Two Stream operators ftUgsa eq[;r% Use esa fy;k tkrk gSa %&
<<:: insertion for output
>>:: extraction for input
fuEu streams dks automatically create o open fd;k tkrk gSaA
cin  console input
cout  console output
cprn  standard printer
cerr  Standard error output
clog  standard log
caux  standard auxiliary.
;g Source Stream tks Program dks Data Provide djrk gSa mls Input Stream dgk tkr
gSa rFkk destination Stream tks program ds Output dks recive djrh gSa Output Stream
dgykrh gSaA

Input Stream
INPUT
DEVICE extraction from
input stream

PROGRAM
Insertion into
Output Stream output stream
OUTPUT
DEVICE

Input Stream esa data keyboard ls vkrk gSaA

C++ STREAM Classes: -

C++ dk Input/Output System Classes hierarchy ds contain djrk gSa ftUgsa fofHkUu
Streams tSls Console o disk files dks define djus ds fy, Use esa fy;k tkrk gSaA
ios

Pointer
istream streambuf ostream
Output

iostream

istream-withassign ostream-withassign
iostream-withassign

- 82 –
elars ios }kjk gh basic formatted o Unformatted I/O operations dks Support fd;k tkrk
gSaA Class istream formatted o Unformatted input facility dks Provide fd;k tkrk gSa
rFkk Ostream }kjk Formatted output facility dks Provide fd;k tkrk gSaA

STREAM CLASSES FOR CONSOLE OPERATIONS

ios (i) Basic faculty ftls lHkh input/output classes }kjk use esa fy;k tkrk
gSaA
(ii) Pointer to a buffer object dks contain djrh gSaA
(iii) mu constants o function dks declare fd;k tkrk gSa tks formatted
Input rFkk Output operations ds fy;s vko';d gSaA

istream (i) ios dh property dks inherit djrk gSaA

(ii) input function dks declare fd;k tkrk gSa tSls get( ), getline( ) rFkk
read.
(iii) Overloaded extraction operator dks contain djrh gSaA

ostream (i) ios dh property dks Inherit djrh gSaA

(ii) Output function put( ) rFkk write( ) dks declare fd;k tkrk gSaA
(iii) Overloaded insertion operator dks (<<) contain fd;k tkrk gSaA

iostream (i) ;g ios dh istream rFkk ostream nksuks properties dks multiple
Inheritance ds }kjk inherit fd;k tkrk gSaA

streambuf (i) Buffers ds }kjk Physical interface dks provide fd;k tkrk gSaA
(ii) Filebut class dk base gSaA

FORMATTED CONSOLE I/O OPERATIONS

C++ cgqr ls features dks support djrk gSa ftls formatting Output ds fy;s Use esa fy;k
tkrk gSaA bu Features esa fuEu dks include fd;k tkrk gSa% &
(i) ios class functions rFkk flags
(ii) Manipulators
(iii) User defined Output functions.
ios class cgqr ls member function dks contain djrh gSa ftlls cgqr izdkj ls Output dh
formatting dh tk ldrh gSaA muesa ls dqN fuEu gSa% &

Width( ) Field Size dks Specify djus o Output Value dks display djus ds fy;s
vko';d gSaA
Precision( ) Float value esa decimal point ds ckn fdrus No. of digit dks specify fd;k
tk,A
fill( ) Field ds unused portion fdl character ls specify fd;k tk,A
setf( ) Output display dks control djus ds fy;s format flag dks specify djukA
unsetf( ) specific flag dks clear djus ds fy;sA

Manipulators Special function gSa ftls I/O Statements dks alter djus o Stream parameters
dks format djus ds fy;s Use esa fy;k tkrk gSaA bu Manipulators dh access djus ds
fy;s iomanip.h dks Program esa Include fd;k tkrk gSaA

- 83 –
 Manipulators: - ios function
setw( ) width( )
setprecision( ) precision( )
setfill( ) fill( )
setioflags( ) set( )
resetiosflags( ) unsetf( )
bu manipulators ds vykok User }kjk Lo;a ds manipulators Hkh create fd;s tk ldrs
gSaA
Width( ): - Width( ) function dks vko';d field width dks define djus ds fy;s use esa
fy;k tkrk gSaA D;ksafd ;g ,d member function gSa vr% bls object }kjk invoke fd;k
tkrk gSa% &
cout.width(w);
;gk¡ w field width gSaA Output dks right hand side esa print fd;k tkrk gSaA width( )
function flQZ ,d item ds fy;s field width dks specify fd;k tkrk gSaA
cout.width(7);
cout<<3233;
Output: -
. . . 3 2 3 3

if cout.width(7);
cout<<3233<<12;

. . . 3 2 3 3 1 2
vr% gj Item ds fy;s field width dks separately specify fd;k tkuk pkfg,A
;fn field width fd;s x;s number ls NksVh gS rks size of the value dks print fd;k tkrk
gSa tSls% &
cout.width(2);
cout<<7770;
Output: -
7 7 7 0
#include <iostream.h>
void main( )
{
cout.width(3);
cout.<<1<<endl;
cout.width(7);
cout<<223<<16<<endl;
cout.width(3);
cout.6060<<endl;
}

precision( ): - floating numbers dks decimal point ds ckn 6 digits rd print fd;k tkrk
gSaA user }kjk Hkh floating point numbers dks Specify fd;k tk ldrk gSaA blds fy,
member function precision( ) dks use esa fy;k tkrk gSaA
cout.precision(d)
;gka d number of digit dks iznf'kZr djrk gSaA ftldk decimal ds ckn show djuk
gSaA
Example: - cout.precision(3);
cout.sqrt(2);
mijksDr Example esa decimal ds ckn 3 numbers dks Show fd;k tk;sxk

- 84 –
;fn 1 ckj precision dks set dj fn;k x;k gS rks og lHkh ij implement gksrk gSaA tSls
Example: - cout.precision(3);
cout.sqrt(2);
cout<<3.14237<<endl;
cout<<2.22370<<endl;
width dh rjg precision dh setting dks ckj&ckj change djuk ugha iM+rk gSaA
precision dks vyx&vyx values ij vyx&vyx set fd;k tk ldrk gSaA tSls%&
cout.precision(3);
cout<<3.14732<<endl;
cout.precision(5);
cout<<7.456021<<endl;
precision setting ds lkFk field specification dks Hkh combine fd;k tkrk gSaA tSls% &
cout.precision(2);
cout.width(5);
cout<<1.23456<<endl;
igys 2 Statements dks fuEu izdkj instruct fd;k tkrk gSaA print 2 digit after the
decimal point in a field of 5 character width vr% output 
  
Example: - #include <iostream.h>
void main( )
{
cout.width(3);
cout.precision(2);
cout<<1.7692<<endl;
cout.width(7);
cout.precision(3);
cout<<2.7677<<endl;
}
Precision ds fy, fuEu ckrksa dks considered fd;k tkrk gSaA
(1) output round off gksdj iznf'kZr gksrk gSaA tSls% &
cout.precision(2);
cout<<1.767<<endl;
output1.77
(2) ;fn decimal point ds ckn 0 vk jgk gS rks mls automatically gVk fn;k tkrk
gSaA tSls% &
cout.precision(2);
cout<<1.200<endl;
output 
(3) Precision dks ,d ckj set dj nsus ds ckn ckj&ckj set djus dh vko';drk ugha
gksrh gSaA
(4) default precision 6 digit dk gksrk gSaA

fill( )
tc fdlh Hkh value dks print djus ds fy, tc field width dks number ls T;knk define dj
fn;k tkrk gSa rks unused position dks white space }kjk fill dj fn;k tkrk gSaA fill
function dks unused position ij fdlh Hkh character dks Mkyus ds fy, use esa fy;k
tkrk gSaA fill dks fuEu izdkj use esa ysrs gSaA
cout.fill('*');
cout.width(10);
cout<<620<<endl;

- 85 –
mijksDr statements dk output fuEu izdkj ls gksxk
* * * * * * * 6 2 0
#include <iostream.h>
void main( )
{
cout.fill('<');
cout.precision(3);
for(int i = 1; i< = 6; i++)
{
cout.width(5);
cout<<i;
cout<<1.0 / float (i) <<endl;
if (i == 3)
cout.fill('>');
}
}

setf( )

Function width dks tc use esa fy;k tkrk gSa rks number automatically right justify gks
tkrk gSa ij ;fn number dks left justification nsuk gks rks blds setf( ) function dks use
esa fy;k tkrk gSaA setf( ) ios class dk Member function gSa tks formatting provide
djokrk gSa setf( ) function dks fuEu izdkj use esa fy;k tk ldrk gSaA

cout.setf(arg1, arg2);

arg1 ,d formatting flag gSa ftlls ios class esa define fd;k x;k gSa formatting flag
ds }kjk output ij vko';d format action dks apply fd;k tkrk gSaA arg2 dks bit field
dgk tkrk gSa tks formatting flag dks iznf'kZr djrk gSaA setf( ) function ds fy, flag
o bit fields fuEu izdkj gSaA

Format required Flag (arg1) Bit-field (arg2)

Left-justified output ios :: left ios :: adjustfield
Right-justified output ios :: right ios :: adjustfield
Padding after sign or base ios :: internal ios :: adjustfield
Indicator (like +##20)
Scientific notation ios :: scientific ios :: floatfield
Fixed point notation ios :: fixed ios :: floatfield
Decimal base ios :: doc ios :: basefield
Octal base ios :: oct ios :: basefield
Hexadecimal base ios :: hex ios :: basefield
Example: -
#include <iostream.h>
void main( )
{
cout.fill('*');
cout.setf(ios :: left, ios :: adjustfield);
cout.width(10);
cout<<"C++"<<endl;

- 86 –
}
output 
C + + * * * * * * * * * * * *
Example: -
#include <iostream.h>
void main( )
{
cout.fill('*');
cout.precision(3);
cout.setf(ios :: internal, ios :: adjustfield);
cout.setf(ios :: scientific, ios :: floatfield);
cout.width(10);
cout<<-11.45798<<endl;
}
Output 
          

Display the trailing 0 & + sign

;fn ge 10.75, 15.00 vkfn Numbers dks field width use esa ysrs gq, print djuk pkgrs
gSa rks 0 dks automatically print djrs le; gVk fn;k tkrk gSaA dqN Situation esa ge
0 dks Hkh Output esa iznf'kZr djuk pkgrs gSa rks blds fy, setf function dks use
esa fy;k tkrk gSaA setf ds lkFk ios :: showpoint dks single argument dh rjg Pass fd;k
tkrk gSaA
Example: - cout.setf(ios :: showpoint);
blh izdkj ;fn fdlh Hkh Number ds vkxs + sign dks Output ds :i esa iznf'kZr djuk
gks rks mlds fy, setf function ds lkFk showpos flag dks single argument dh rjg pass
fd;k tkrk gSaA
Example : - cout.setf(ios :: showpos);
Program: -
#include <iostream.h>
void main( )
{
cout.setf(ios :: showpoint);
cout.setf(ios :: showpos);
cout.precision(3);
cout.setf(ios :: fixed, ios :: floatfield);
cout.setf(ios :: internal, ios :: adjustfield);
cout.width(10);
cout<<275.5<<endl;
}

Output 
       

Flags that do not have bit fields

Flag Meaning
ios :: showbase Use base indicator on output
ios :: showpos Print + before positive numbers
ios :: showpoint Show trailing decimal point and zeros

- 87 –
 ios :: uppercase Use uppercase letters for hex output
ios :: skipus Skip white space on input
ios :: unitbuf Flush all streams after insertion
ios :: stdio Flush stdout and stderr after insertion
setf( ) dks Use esa ysrs le; fuEu ckrksa dk /;ku j[kuk pkfg,
(1) Flags tc setf( ) ds }kjk set fd;s tkrs gSa rks os rc rd effective jgrs gSa tc rd
mUgsa reset ;k unset u dj fn;k tk;sA
(2) Program esa Format flags dks fdruh ckj Hkh Reset fd;k tk ldrk gSaA
(3) ,d ls T;knk format control dks output value ij apply fd;k tk ldrk gSaA
(4) setf( ) specific flags dks set dj nsrk gSa vkSj ckdh dks unchanged j[krk gSaA

Managing Output With Manipulators

Header File iomanip ds }kjk setof function dks Provide fd;k tkrk gSaA ftUgsa
manipulators dgrs gSaA ftlds }kjk output formats dks manipulate fd;k tk ldrk
gSaA ;s ios member function o flags dh rjg gh use esa yh;s tkrs gSa dqN
manipulators dks ios dh txg Use esa fy;k tkrk gSaA tSls% & 2 ;k 2 ls vf/kd
manipulators dks ,d lkFk Use esa ys ldrs gSaA tSls% &
cout<<manip1<<manip2<<manip3<<i;
cout<<manip1<<i<<manip2<<j;
bl izdkj ds Manipulators dks vyx&vyx Columns esa output display djus ds fy, use
esa fy;k tkrk gSaA eq[;r% ftu manipulators dks use esa fy;k tkrk gSa oks fuEu
gSa% &

Manipulator Meaning Equivalent

setw (int w) Set the field width to w. width( )
setprecision(int d) Set the floating point precision to d. precision( )
setfill(int c) Set the fill character to c. fill( )
setiosflags(long f) Set he format flag f. setf( )
resetiosflags(long f) Clear the flag specified by f. unsetf( )
Endif Insert new line and flush stream. "\n"

Example: - cout<<setw(10)<<123;
mijksDr Example ls 123 Right Justified Form esa print gksxkA
nks ;k nks ls vf/kd values ds output format dks ,d statement esa Hkh iznf'kZr fd;k
tk ldrk gSaA

Example: - cout<<setw(5)<<setprecision(2)<<1.769
<<setw(10)<<setprecision(4)<<sqrt(4)
<<setw(15)<<setiosflags(ios :: scientific)<<sqrt(3);
cout<<endl;
bl mijksDr example ds }kjk 5, 10, 15 field width dks specify fd;k tkrk gSaA
Manipulators rFkk iosfunction dks fdlh Hkh program esa lkFk&lkFk use esa fy;k tk
ldrk gSaA tSls% &
cout.setf(ios :: showpoint);
cout.setf(ios :: showpos);
cout<<setiosflags(ios :: scientific);
cout<<setw(10)<<-1.635<<endl;

- 88 –
ios member function rFkk Manipulator esa main difference ;g gSa fd ios member
function previous format dks return djrs gSaA ysfdu manipulators dks Previous format
state dks return ugha djrs gSaA
Example: - cout.precision(2);
int p = cout.precision(4);
tc bl statement dks execute djrs gSa rks p esa 2 value vk;sxh D;ksafd ;g previous
state vkSj New format state 4 gksxhA
Example: -
#include <iostream.h>
void main( )
{
cout.setf(ios :: showpoints);
cout<<setw(5)<<"N"
<<setw(15)<<"inwards"
<<setw(15)<< "sum";
}

Designing Our Own Manipulators

User }kjk Lo;a ds manipulators dks Hkh Create fd;k tk ldrk gSa tks special purpose
ds fy, cuk;s tkrs gSaA fdlh Hkh Manipulators dks create djus ds fy, fcuk fdlh
argument fuEu syntax dks fy[kk tkrk gSaA

ostream & manipulator (ostream & output)

{
.....
..... (code)
return output;
}
;gka Manipulator, Manipulator dk uke gSaA tSls ;fn Cm. uke dk manipulator cukuk
gks rks blds fy, fuEu Coding dh tk;sxhA
ostream & cm (ostream & out)
{
out<<"centimeter";
return out;
}

bls Call djus ds fuEu statement fn;k tk;sxkA

cout<<36<<cm;
Manipulators dks vyx&vyx operation dh sequence ds lkFk Hkh create fd;k tk ldrk
gSa tSls

ostream & show (ostream & output)

{
output.setf(ios :: showpoint);
output.setf(ios :: showpos);
output << setw(10);
return output;
}

- 89 –