மிகுப்பு மற்றும் குறைப்பு செயற்குறிகள் 
Increment and Decrement Operators:
++(Plus, Plus) முகப்பு செயற்குறி 
-- (Minus, Minus) குறைப்புச் செயற்குறி ஒரு செயலேற்பியின் மீது மட்டுமே செயற்பட்டு ஒரு புதிய மதிப்பை வழங்குகிறது. எனவே, இந்தச் செயற்குறிகள் ஒருமச் செயற்குறிகள் எனப்படும். மிகுப்பு செயற்குறி செயலேற்பியுடன் 1 என்ற மதிப்பை கூடுகிறது. குறைப்புச் செயற்குறி செயலேற்பியிலிருந்து 1 என்ற மதிப்பை குறைக்கிறது.
எடுத்துக்காட்டாக 
X++என்பது x=x +1 என்பதற்குச் சமம் ➝'x-ன் தற்போதைய மதிப்புடன் 1 ஐ கூட்டுகிறது.
x --என்பது x=x-1 என்பதற்குச் சமம். ➝'x-ன் தற்போதைய மதிப்புடன் 1ஐ குறைக்கிறது.
இந்த மிகப்பு (++)அல்லது குறைப்பு (--) செயற்குறிகள் மாறிகளுக்கு முன்னொட்டாகவோ அல்லது பின்னொட்டாகவோ இருத்தப்படுகிறது. முன்னொட்டு முறையில் செய்லேற்பியை பயன்படுத்துவதற்கு முன்னதாகவோ மிகப்பு அல்லது குறைப்பு செயல்படுத்தப்படும். 
எடுத்துக்கட்டாக:N1=10,N2=20;
S=++N1+ ++N2
பின்வரும் வரைபடம் மேலே கொடுக்கப்பட்டுள்ளன கூற்றின், செயல்படும் முறையே விளக்குகிறது.

மேலே உள்ள எடுத்துக்காட்டில் N-களின் மதிப்புகள் முதலில் 1 மிகுக்கப்பட்டு அதற்குரிய செயலேற்பியில் இருத்தப்படுகிறது.
பின்னொட்டு முறையில், மிகப்பு /குறைப்புக்கு முனதாகவோ செய்லேற்பியில் உள்ள மதிப்பை கணக்கிடுதலுக்காக C++ பயன்படுத்தப்படுகிறது.
எடுத்துக்காட்டாக 
N1=10,N2=20;
S=++N1+ ++N2
பின்வரும் வரைபடம் மேலே கொடுக்கப்பட்டுள்ளன கூற்றின், செயல்படும் முறையே விளக்குகிறது

மேலேகொடுக்கப்பட்டுள்ள எடுத்துக்காட்டில் N1 செயலேற்பியல் திருத்தப்பட்ட மதிப்பு எடுத்துக்கொள்ளப்பட்டு, பிறகு அந்த மிதிப்பானது மிகுக்கப்படுகிறது.(மதிப்பு 1 கூட்டப்படுகிறது)

formula = 4/3 πr³
.#include < iostram.h. >
void main ()
{
float r;
cout < "\n enter the value of r";
cin >> r;
cout << "\n volume of sphere is" << ( 4/3*3.4*r*r*r);
}

தருக்க பிட்நிலை  செயற்குறிகள்  (Logical  bitwise  operators );
& பிட்நிலை  AND  (இரும AND )
| பிட்நிலை OR  (இரும OR )
பிட்நிலை  தனித்த  OR   (இரும XOR )
(i) பிட்நிலை  AND & எனும் செயற்குறி இரண்டு  செயலேற்பிகளின் மதிப்புகளும்  1 (True ) என  இருக்கும் போது  1(true ) எனவும் இல்லையெனில்  0 (false ) எனவும் விடை தரும்.
(ii) பிட்நிலை  OR  | எனும் செயற்குறி , ஏதேனும் ஒரு செயலேற்பி மதிப்பு  1 (true ) என இருக்கும் போது  1 (true) என்ற விடையையும் இரண்டு செயலேற்பிகளின் மதிப்புகளும் 0 (false) என இருக்கும்போது  0 (False ) என்ற விடையையும்  தரும்.
(iii) பிட்நிலை  XOR ()எனும் செயற்குறி  ஒரு  செயலேற்பி மதிப்பு  1 (true ) என இருக்கும் போது  1 (true) என்ற விடையையும், இரண்டு செயலேற்பி களும்  (1 (true) அல்லது  0 (False )) என சமமாக இருக்கும்பொழுது 0 (False ) என்ற விடையையும் தரும்.
AND , OR , XOR -க் காண பிட்நிலை  செயற்குறிகளின் மெய்ப்பட்டியல் (Truth table )

குறியாக்கத்தின் வகைகள் : குறியாக்கத்தின் இரண்டு வகை குறியாக்கத் திட்டங்கள் கீழே பாட்டிலிடப்பட்டுள்ளது.
(i) சமச்சீர் குறியாக்கம் 
(ii) பொது குறியாக்கம் 
சமச்சீர் குறியாக்கம், பொது குறியாக்கம்  முக்கிய குறியாக்கம் மற்றும் சமச்சீர்  மறை குறியாக்கம் இரண்டிற்கும் ஒரே விசையை பயன்படுத்துவதற்கான ஒரு நுட்பமாகும், சமச்சீர் விசை குறியாக்கத்தின் முக்கிய குறைபாடு என்னவென்றால் சம்மந்தப்பட்ட அனைவரும் அதைக் கண்டறிவதற்கு முன்பே தரவை குறியாகப் பயன்படுத்தப்படும் குறியீடாக பரிமாற்ற வேண்டும். எவரேனும் முக்கியத் தகவலை இடைமறித்தால் அவர்கள் எல்லா செய்திகளையும் படிக்கலாம். 

பொது குறியாக்கம்:
(i)  பொது குறியீடு குறியாக்கத்தை சமச்சீரற்ற குறியாக்கவியல் என்று அழைக்கப்படுகின்றது. இது முக்கிய மதிப்பின் ஜோடியின் கருவியை பயன்படுத்துகிறது.
(ii) குறியாக்கம் மற்றும் மறை குறியாக்கம் செயல்முறைக்கு வேறுபட்ட குறியீடு பயன்படுகிறது.  குறியீடு ஒன்று என்பது பொதுவாக தனிப்பட்ட  குறியீடு என்று அழைக்கப்படுகிறது. மறறொன்று பொது  குறியீடு என்று அழைக்கப்படுகிறது.

(iii) தனிப்பட்ட குறியீடு உரிமையாளரால் இரகசியமாக வைக்கப்பட்டிருக்கிறது. பொதுகுறியீடு பகிர்ந்து கொள்ளப்படுகிறது அல்லது பொது மக்களுக்கு அதிகமாக கிடைக்கிறது. பெருநபரின் பொதுவிசையுடன் குறியாக்கப்பட்ட தரவு தொடர்புடைய தனிப்பட்ட குறியீடு மூலமே குறியாக்கம் செய்யப்படும்.

(i) f. = a+b/a
= 5+3/5 ⇒ 5 + 0 = 5.0
f = 5.0
(ii) c = (a++) * d + a
= 5 * 1.5+6 ⇒ 7.5 + 6 = 13.5
c = 13
(iii) c = a * d + b
= 1.5 * 5 + 3
=7.5+3 ⇒ 10.5
c = 10
(iv) c = a - (b++) * (--d)
= 5 - 3 * 0.5
= 5 - 1.5
= 3.5
c =3
(v) f =(++b)*b-a
=4*4-5
=4* - 5
= 16 - 5
f = 11.0

#include < iostream >
#include < math.h >
void main ()
{
int p, t;
double r, si, amt, ei, d;
d=0;
p =5000; r = 10; t = 2;
amt = p * (pow 1+r/l00t);
ci = amt - p;
si=p*r*t/100;
d = ci - si;
cout << "The compound Interest = " << float(cl);
cout << "\n The simple interest=" << si;
cout << "\n the difference of simple and compound interst" << float < d);
}

பின்வரும் காரணங்களுக்காக வலைதளங்கள் பொதுவாக குக்கிகளை பயன்படுத்துகின்றன.
1.இணைய தளத்திற்கு சென்று பார்த்தவர்கள் பற்றிய விவரங்களை சேகரிக்க, இந்த இணைய தளத்தை பெரும்பாலும், எத்தனை பார்வையாளர்கள் பார்வையிட்டனர் எவ்வளவு நேரம் பார்வையிட்டார்கள் என்பதையும் கண்காணிக்கலாம்.
2.இது வலை தளத்தில் பயனரின் அனுபவத்ததை தனிப்பயனாக்க உதவுகிறது.
3. குக்கிகள் பயனர் பற்றியத் தனிப்பட்ட தகவல்களை சேமித்து வைக்க உதவும்.
4.இதன் மூலம் ஒரு பயனர் தளத்திற்கு திரும்பும் போது அதிக அனுபவங்கள் பெறப்படுகின்றன. 

(i) சமூக கட்டமைப்பு : சமூக கட்டமைப்பு ஒரு நபரின் பலவீனத்தை தவறாக பயன்படுத்துதல் தீங்கிழைக்கும்  இணைப்புகளை கிளிக் செய்வதன் மூலமும் அல்லது நுணுக்கங்கள் மூலம் கணிப்பொறியை அணுகுவதாலும் பெறப்படுகிறது. ஃபிஷிங் மற்றும் ஃபார்மிங் சமூக கட்டமைப்புகளுக்கு உதாரணங்கள் ஆகும்.
(ii) ஃபிஷிங்: ஃபிஷிங் என்பது கணிப்பொறி குற்றத்தின் ஒரு வகை ஆகும். கடவுச்சொல் மற்றும் கிரெடிட் கார்டு எண்கள் உள்ளீட்ட பயனர் தரவை திருடுவதற்கு பயன்படுத்தப்படும். ஒரு மின்னஞ்சலில் ஒரு உடனடி உரைச் செய்திப்பெட்டியை திறக்கும் போது அது  பாதிப்புக்குள்ளாகி தீங்கிழைக்கக்கூடிய இணைப்புகள் அல்லது இணைப்புகளை விநியோகிக்க ஃபிஷிங் பயன்படுகிறது. ஒரு பாதிக்கப்பட்டவரிலமிருந்து முக்கிய உள்நுழைவு சான்றுகளை பிரித்தெடுத்தல் உட்பட பலவிதமான செயல்பாடுகளை செய்ய முடியம்.
(iii) ஃபார்மிங் (Pharming) : ஃபார்மிங் என்பது ஒரு தனிப்பட்ட கணிப்பொறியின் அல்லது சேவையகத்தின் தீங்கிழைக்கும் குறியீடு உள்ள மோசடியான ஒரு நடைமுறை ஆகும். பயனரின் அனுமதி இல்லாமல் தவறான வழி நடத்துகிறது. பயனரை மோசடி செய்ய ஷேக்கர்கள் முயற்சி செய்து வலைதளத்தின் போக்கை திசை திருப்பின் ஒரு இணையத் தாக்குதல் ஆகும். 

#include < iostream >
using namespace std;
int main()
{
int radius;
float pi = 3.14;
cout << "\n Enter Radius (in cm): ";
cin >> radius;
float perimeter=(pi+2)*radius; // dynamic initialization
float area = (pi*radius*radius)/2; // dynamic initialization
cout << "\n Perimeter of the semicircle is " << perimeter << " cm";
cout << "\n Area of the semicircle is " << area << "sq.cm";
வெளியீடு:
Enter Radius (in cm): 14
Perimeter of the semicircle is 71.96 cm
Area of the semicircle is 307.72 sq.cm

வெளியீடு :
My profession is : Teacher
My age is : 24
I can walk
I can talk
I can teach Maths.
My profession is : football
My age is 21
I can walk.
I can talk.
I can play football.

# include < iostrearn >
using namespace std;
class student // base class
{
private:
char name[20];
int rno;
public:
void acceptnamei)
{
cout << ''\n Enter roll no and name .. '';
cin >> rno >> name;
}
void displayname()
{
cout << "\n Roll no :-n << rno;
cout<< "\n Name :-n<< name<< endl;
} };
class exam : public student
Iiderived class with single base class public:
{
public:
int mark1, mark2 ,mark3,mark4,mark5,mark6;
void acceptmark ()
{
cout << ''\n Enter lang,eng,phy,che,csc,mat marks .. '';
cin>> mark1 >> mark2 >> mark3 >> mark4 >> mark5 >> mark6;
}
void displaymark () {
cout << ''\n\t\t Marks Obtained n;
cout << ''\n Language .. "<< mark1 ;
cout << ''\n English .. "< cout << ''\n Physics .. "<< mark3;
cout << ''\n Chemistry .. "<< mark4;
cout<< ''\n Comp.sci .. "<< mark5;
cout <<' '\n Maths .. "<< mark6;
}
};
class detail //base classs 2
{
int dd,mm,yy;
char c1[4];
public:
void acceptdob ()
{
cout << ''\n Enter date,month,year in digits and class .. '';
cin >> dd >> mm>> yy>> cl;
}
void displaydob ()
{
cout <<''\n class :-'' << cl;
cout<< ''\t\tDOB :, '' << dd<< ''_'' << mm << ''_'' << yy<< end1;
}
};
class result: public exam,public detail
// inherits from exam ,which itself is a
// Iiderived class and also from class detail
{
int total;
void showresult ()
{
total=mark1 +mark2+mark3+ mark4+mark5+mark6;
cout<< "\n TOTAL MARK SCORED
"<< total;
}
};
int main ()
{
result r1;
.r1.acceptname ( );
// calling base class function using derived class object
r1.acceptmark ( );
// calling base class which itsel is a derived class function using its derived class object
r1. acceptdob ( );
cout << ''\n\n\t\t MARKS STATEMENT'' ;
r1.displayname ( );
// calling base class function using derived class object
r1. displaydob ();
r1.displaymark ();
// calling base class which itsel is a derived class function using its derived class object
r1. showresult (); // calling the child class function 
return 0;
}
வெளியீடு :  
Enter roll no and name .. 11201 RAGURAM
Enter lang,eng,phy,che,csc,mat marks .. 100 100 100
100100 100
Enter date,month,year in digits and class .. 14 01
2002 XII
MARKS STATEMENT
Roll no :-11201
Name :-RAGURAM
class :-XII DOB : 14 - 01 -2002 '
Marks Obtained
Language.. 100
English .. 100
Physics .. 100
Chemistry.. 100
Comp.sci .. 100
Maths .. I00
TOTAL MARK SCORED: 600

இனக்குழுவின் பொருளானது இரண்டு முறைகளில் உருவாக்கப்படுகிறது.
1.முழுளாவியா பொருள் (Global Object)
2.உள்ளமை பொருள் (Local Object)
1.முழுளாவியா பொருள் (Global Object)
அனைத்து செயற்கூறுகளில் உடற்பகுதிக்கு வெளியில் அல்லது இனக்குழுவின் அறிவிப்பை முடித்து வைக்கும் கொக்கி வடிவ அடைப்பை (braces)தொடர்ந்து பொருளானது அறிவிக்கப்பட்டால் அது முழுத்தளாவிய மாறி எனப்படும். இனக்குழுவில்/நிரலில் உள்ள அனைத்து செயற்கூறுகளும் அப்பொருளைப் பயன்படுத்திக் கொள்ள முடியும்.
2.உள்ளமை பொருள் (Local Object)
ஒரு பொருளானது செயற்கூறினுள் அறிவிக்கப்பட்டால் அது உள்ளமை பொருள் எனப்படும். செயல்கூறுக்கு வெளியில் இருந்து இப்பொருளை அணுக முடியாது. 

பொருள்நோக்கு நிரலாலாக்க மொழியின் மிக முக்கியமான பண்புக்கூறுகளுள் ஒன்று தரவு மறைப்பு (Data hiding) என்பதாகும். இது நிரலில் உள்ள செயற்கூறானது, இனக்குழுவிற்குள் அறிவிக்கப்பட்டிருக்கும் உறுப்புகளை (தரவு உறுப்புகள், உறுப்புச் செயல் கூறுகள்) அணுகுவதற்குத் தடை விதிக்கிறது. இனக்குழுவின் உறுப்புகளை அணுக தடைவிதிப்பதற்கு இனக்குழுவினுள் அறிவிக்கப்பட்டிருக்கும் Private,Protected மற்றும் Public என்ற சிறப்புச் சொற்கள் பயன்படுகிறது.
சொற்களானது அணுகியல்புடன்  வரையறுப்பிகள் என அழைக்கப்படுகின்றன. இனக்குழு உறுப்புகளின் கொடாநிலை அணுகியல்பானது Private ஆகும்.
1. Public உறுப்புகள்: Public அணுகியல்புடன் கூடிய உறுப்புகளை இனக்குழுவிற்கு வெளியில் இருந்தும் அணுக முடியும். Public என அறிவிக்கப்பட்ட தரவு உறுப்புகளை எவ்வித உறுப்பு செயல்பாடுகளின் உதவியுமின்றி அணுக முடியும். அதாவது தரவு உறுப்புகளுக்கு மதிப்பைக் கொடுக்கவோ அல்லது மதிப்பைப் பெறவோ முடியும்.உறுப்பு செயற்கூறுகள் தேவை இல்லை.
2.Private உறுப்புகள்: Private அணுகியல்புடன்  கூடிய இனக்குழு உறுப்புகளை இனக்குழுவிற்கு வெளியில் இருந்து அணுகமுடியாது.இனக்குழுவின் உறுப்பு செயற்கூறுகள் மட்டுமே தரவு உறுப்புகளை அணுக முடியும். கொடாநிலையாக இனக்குழுவின் உறுப்புகள் அனைத்தும் Private அணுகியல்புடன் அறிவிக்கப்படும்.
3.Protected உறுப்புகள்: Protected அணுகியல்புடன் அறிவிக்கப்பட்ட தரவு உறுப்புகளும், உறுப்பு செயற்கூறுகளும் private அணுகியல்பு கொண்ட உறுப்புகளைப் போலவே செயல்படும். ஆனால் அந்த இனக்குழுவை அடிப்படையாகக் கொண்டு தருவிக்கப்பட்ட இனக்குழுவிற்குள்ளும் அணுக முடியும்.

இந்த முறையில் அளபுருவின் குறிப்பை அல்லது முகவரியை முறையான அளபுருவில் நகலெடுக்கும் முகவரியின் மூலம் அழைப்பதால் முறையான அளபுருவின் மதிப்பில் ஏதேனும் மாற்றம் செய்தால் மெய்யான அளபுருவில் அந்த மாற்றம் பிரிதிபலிக்கும்.
#include < iostream >
using namespace std;
void display(int &x) //passing address of a//
{
x=x*x;
cout << "\n\n The Value inside display function (n1 x n1):" <<x;
}
int main()
{
int n1;
cout << "\n Enter the Value for N1:";
cin >> n1;
cout << "\n The Value of N1 is inside main function Before passing: " << n1;
display(n1);cout << "\n The Value of N1 is inside main function After passing (n1 x n1):" << n1; return(0);
}
வெளியீடு:
Enter the Value for N1:45
The Value of N2 is inside main function Before passing:45
The Value inside display function (n1 x n1):2025
The Value of N1 is inside main function After passing (n1 x n1):2025.

ஒரு செயற்கூறை அழைக்கும் கூற்று நிரல் பெயர்ப்பியை செயற்கூறுக்கு (வரையறுக்கப்பட்ட செயற்கூறுகள் அடுக்கங்களில் (STACKS) சேமிக்க்கப்படும்) தாவச் செய்து மற்றும் செயற்கூறு செயல்பாட்டின் பின் அழைப்புக்கூறுக்கு அடுத்திருக்கும் கட்டளைக்குத் தாவச்செய்கிறது. இதனால் நிரலின் இயக்க நேரத்தின் வேகம் குறையும். சிறிய செயற்கூறின் வரையறுப்புக்கு அடுக்கங்களைப் பயன்படுத்துவதை குறைக்க Inline செயற்கூறுகள் பயன்படுத்தலாம்.
inline செயற்கூறு மூல நிரலில் சாதாரணச் செயற்கூறு போன்றே தோற்றமளிக்கும். ஆனால் செயற்கூறின் கட்டளைகள் முழுமையும் அழைப்புக் கூற்றுக்குப் பதிலாக அப்படியே நிரலில் செருகப்பட்டுவிடும். Inline சிறப்புச் சொல்லை செயற்கூறின் தலைப்பில் இணைத்து அந்த செயற்கூறை inline செயற்கூற்றாக மாற்ற முடியும்.
தொடரியல்: inline <திருப்பி அனுப்பும் வகை> <செயற்கூறின் பெயர் (தரவு வகை அளபுருக்களின் பெயர் 1... தரவு வகை அளபுருக்களின் பெயர் N -வரை)>
inline செயற்கூற்றுகளின் நன்மைகள்:
(i) inline செயற்கூறுகள் வேகமாக செயல்படும் ஆனால் அதிக நினைவக இடத்தை எடுத்துக் கொள்ளும்.
(ii) அடுக்கங்களை பயன்படுத்தும் போது உள்ள சிக்கல்பாட்டினைக் குறைக்கிறது.
நிரல்:
#include < iostream >
using namespace std;
inline float simpleinterest(float p1,float n1, float r1)
return(si 1);
}
int main ()
{
float si, p,n,r;
cout << "\nEnter the Principle Amounts Rs.:";
cin >>p;
cout << "\nEnter the Number of Years:";
cin>>n;
cout << "\nEnter the Rate Interest:";
cin >>r;
si=simpleinterest(p,n,r);
cout << "\n The Simple Interest=Rs." << si;
return 0;
}

#include < iostream >
using namespace std;
int factorial (int); // Function prototype //
int main ()
{
int no;
cout << ''\n Enter a number to find its factorial:'';
cin >>no;
cout << ''\n Factorial of number '' << no <<'' = '' << factorial (no);
return 0;
}
int factorial (int  m)
{
if (m > 1)
{
return m* factorial (m -1);
}
else
{
return 1;
}
}

வெளியீடு :  
Enter a number to find its factorial : 5
Factorial of number 5 = 120

வரையெல்லை தெளிவுபடுத்தும் செயற்குறி (scope  resolution operator ) : வரையெல்லை  தெளிவுபடுத்தும் செயற்குறி  ஒரு மாறியின்  மறைந்து கிடக்கும் வரையெல்லையை வெளிக்கொணரும். வரையெல்லை  தெளிவுபடுத்தும் செயற்குறி :: இதற்கு பயன்படுகிறது
பொதுமையான மாறியும்  உள்ளமை மாறியும் ஒரே பெயரை கொண்டிருப்பதால் பொதுமையான மாறி யை இயக்க வரையெல்லை  தெளிவுபடுத்தும் செயற்குறி பயன்படுத்தும் ஒரு எடுத்துக்காட்டு:
நிரல் :
//  Program to show that we can access a global varrable 
// using scope resolution operator :: where there is a local
// variable with same name //
#include < iostream >
using namespace std;
int x = 45; // Global Variable x
int main ()
{
int x = 10; // Local Variable x
cout << ''\n Value of global x is '' << :: x ;
cout << ''\n\n Value of loval x is '' << x;
return 0;
}
வெளியீடு :
Value of global x is 45
Value of local x is 10  
                       

while மடக்கு : While மடக்கும் கட்டுப்பாடு பாய்வு கூற்றாகும். இது ஒரு மடக்கினை கொடுக்கப்பட்ட நிபந்தனை சரியாக இருக்கும் வரை, மீண்டும் மீண்டும் இயக்கும். while மடக்கு ஒரு நுழைவு சோதனை மடக்காகும். இதில் சோதிப்பு கோவை முதலில் மதிப்பீடு செய்யப்பட்ட பின்னரே மடக்கினுள் உள்ளே நுழையும்.
while மடக்கின் கட்டளை அமைப்பு:
while(நிபந்தனை சோதிப்புக் கோவை)
{
மடக்கின் உடற்பகுதி;
}
கூற்று -x ;
while மடக்கில்,நிபந்தனை சோதிப்பு கோவை மதிப்பீடு செய்யப்பட்டு அதன் முடிவு சரி என வந்தால், மடக்கின் உடற்பகுதி இயக்கப்பட்டு மீண்டும் while மடக்கிற்கு கட்டுப்பாடு அனுப்பி வைக்கப்படும்.

நிபந்தனை சோதிப்பு கோவை முடிவு தவறு என வரும்போது,பாய்வுக் கட்டுப்பாடு கூற்று -X அனுப்பி வைக்கப்படும்.
(எ.கா)
# include < iostream >
using namespace std;
int main ( ) 
{
int i =1, sum = 0;
while (i < = 10)
{
sum = sum +i
i++;
}
cout << " The sum of 1 to 10 is " << sum;
return ;
}
வெளியீடு:
The sum of 1 to 10 is 55
மேலே கொடுக்கப்பட்ட நிரலில், முழு எண் மாறி i யின் மதிப்பு 1 என்றும் சம் என்ற மாறியின் மதிப்பு 0 என்றும் மதிப்பிருத்தப்பட்டுள்ளது. while மடக்கு i < 10 என்ற நிபந்தனையை சோதித்து,அதன் முடிவு i என்ற மாரியின் மதிப்பு sum மாறியுடன் கூட்டப்படும். பின்னர் i யின் மதிப்பு 1 மிகுக்கப்படும். மீண்டும் நிபந்தனை i < 10 சோதிக்கப்படும். இப்பொழுது 2 < 10, சரி என்பதால் sum என்ற மாறியுடன் 2 கூட்டப்படும். இது போன்று i யின் மதிப்பு 112 ஆகும் வரை நடைபெறும். இப்பொழுது 11 < 10 என்ற சோதனை தவறு என வருவதால், while மடக்கை விட்டு வெளியே செல்லும். மடக்கை விட்டு வெளியே வந்ததும், sum மாறியின் மதிப்பு வெளியிடப்படும்.

ஓர் இனக்குழுவின் பொருளானது மற்றொரு இனக்குழுவின் உறுப்பாக அறிவிக்கப்படும் முறையானது கன்டைனர் இனக்குழு எனப்படும். இம்முறையில் ஒரு இனக்குழுவின் பொருளானது மற்றொரு இனக்குழுவினுள் அறிவிக்கப்பட்டிருக்கும்.
 கன்டைனர் இனக்குழுவுடன் கூடிய நிரல்:
#include< iostream >
using namespace std;
class outer
{
int date;
public:
void get();
};
class inner
{
int value;
outer ot; // object ot of class outer is declared in
class inner
public;
void getdata();
};
void outer : :get()
{
cout << "\nEnter a value";
cin>>data;
cout << "\nThe given value is"<< data

void inner:: getdata()
{
cout << "\nEnter a value";
cin>>value;
cout << "\nThe given value is "<< value;
ot.get(); //calling of get() of class outer in
getdata() of class inner
}
intmain()
{
inner in;
in.getdata();
return();
}
intmain()
{
inner in;
in.getdata();
return();
}

உறுப்பு செயற்கூறுகளுக்கு குறிப்பு மூலம் பொருளை அளபுருவாக அனுப்பும் போது,பொருளின் நினைவக முகவரியானது அளபுருவாக அனுப்பி வைக்கப்படும். எனவே அழைக்கப்படும் செயற்கூறானது மெய்யான அளபுருவாக உள்ள பொருளின் மீதே செயல்பாட்டைச் செயல்படுத்தும். செயற்கூறில் (முறையான அளபுருக்களின் மீது)செய்யப்படும் எந்த மாற்றமும் மெய்யான அளபுருவாக உள்ள பொருளின் மீதும் பாதிப்பை ஏற்படுத்தும்.
  குறிப்பு மூலம் அனுப்புதல் முறை செயல்படும் விதம் பற்றிய நிரல்:
#include< iostream >
using namespace std;
class Sample
{
private:
int num;
public:
void set (int x)
{
num=x;
}
void pass(Sample &obj 1, Sample &obj2)//objects are passed
{
obj 1.num= 100;// value of the object is changed inside the function
obj2.nurn=200;// value of the object is changed inside the function
cout << "\n\n changed value of object 1 " << obj 1.num;
cout << "\n\n changed value of object 2" << obj2.num;
void print()
{
cout< }
} ;
intmain()
{
clrscr();
Sample s1;
Sample s2;
Sample s3;
//assigning values to the data member of objects
s1.set(10);
s2.set(20);
cout << "\n\t\t\Eaxmple program for pass by
reference\n\n\n";
//printing the values before passing the object
cout << "\n\nValue of object! before passing";
s1.print();
cout << "\n\nValue of object2 before passing";
s2.print();
// passing object s1 and s2
s3.pass(s1,s2);
//printing the values after returning to main
cout << "\n\nValue of object 1 after passing";
s 1.print();
count << "\n\nVa'ile of object 2 after passing";
s2.print();
return 0;
}

மடக்கின் பகுதிகள்:
ஒவ்வொரு மடக்கும் பல்வேறு பயன்பாடுகளுக்கான நான்கு கூறுகளை கொண்டுள்ளது.
(i) தொடக்க மதிப்பிலிருந்து கோவை 
(ii) சோதிப்பு நிபந்தனை கோவை 
(iii) புதுப்பித்தல்/மிகுத்தல் கோவை 
(iv) மடக்கின் உடற்பகுதி 
(i) தொடக்க மதிப்பிலிருந்து கோவைகள்: நிரலின் கட்டுப்பாடு மடக்கினுள் நுழையும் முன் கட்டுப்பாட்டு மாறிகள் தொடக்க மதிப்பிருத்தும் கோவையின் கீழ் இடம் பெறும். கட்டுப்பாட்டு மாறியில் தொடக்க மதிப்பிருத்தல் மடக்கு செயல்படும் முன்பாக, ஒரே ஒரு முறை தான் செயல்படுத்தப்படும்.
(ii) பரிசோதிப்பு நிபந்தனை கோவை: பரிசோதிப்பு நிபந்தனை கோவை என்பது ஒரு மடக்கின் உள்ளே அமைந்துள்ள உடற்பகுதியிலிருக்கும் கட்டளைத் தொகுதி நிறைவேற்றப்பட்ட வேண்டுமா இல்லையா என்பதை தீர்மானிக்கும் கோவை அல்லது நிபந்தனையாகும்.
பரிசோதிப்பு நிபந்தனை கோவையின் சோதிப்பு நிலையை அடிப்படையாகக் கொண்டு, மடக்குகளை நுழைவு சோதிப்பு மடக்கு மற்றும் வெளியேறல் சோதிப்பு மடக்கு என இரண்டு வகையாக பிரிக்கப்படுகிறது.
(iii) புதுப்பித்தல்/மிகுத்தல் கோவை: இது மடக்கு கட்டுப்பாட்டு மாறியின் மதிப்பை மாற்றம் செய்வதற்கு பயன்படுகிறது இந்த கூட்டு, மடக்கின் உடற்பகுதி செயல்பட்டு முடிந்த பின், மடக்கின் இறுதியில் செயல்படுத்தப்படுகிறது.
(iv) மடக்கின் உடற்பகுதி : மடக்கின் உடற்பகுதி என்பது மீண்டும் மீண்டும் நிறைவேற்றப்பட வேண்டிய கூற்று அல்லது கட்டளைத் தொகுதியை குறிக்கும். நுழைவு சோதிப்பு மடக்கில், முதலில் நிபந்தனை கோவை செயல்படுத்தப்பட்டு, சுழியம் அல்லாத எண்ணாக இருப்பின், மடக்கின் உடற்பகுதி செயல்படுத்தப்படும் இல்லையெனில் மடக்கு முடிவு பெறும்.

if-else மற்றும் switch கூற்றின் இடையே உள்ள முக்கிய வேறுபாடுகள்.
(i) if கூற்றின் உள்ளே அமைந்திருக்கும் கோவை, ஐபி தொகுதியின் உள்ளே தரப்பட்டுள்ள கட்டளைகளை செய்லபடுத்துவதோ அல்லது else தொகுதியின் கீழ் உள்ளவையோ என்பதை தீர்மானிக்க, அவ்வாறின்றி, Switch கூற்றினுள் அமைந்திருக்கும் கோவை.
(ii) ஒரு if எல்ஸ் கூற்றானது, பல தேர்வுகளுக்கு பல கூற்றுகளை பயன்படுத்துகின்றது. அவ்வாறின்றி, Switch கூற்றானது, பல தேர்வுகளுக்கு ஒரு கோவையைப் பயன்படுத்துகிறது.
(iii) if-எல்ஸ் கூற்று சமமானதா என்பதையும் தருக்க (நிபந்தனை) கோவையையும் சரிப்பார்க்கிறது. ஆனால் Switch சமமானதா என்பதை மட்டும் சரிப்பார்க்கிறது.
(iv) If-கூற்று முழு எண், குறியுரு சுட்டு அல்லது மிதப்புப் புள்ளி வகை அல்லது பூலியன் வகை தரவினங்களை மதிப்பீடு செய்கிறது, அவ்வாறின்றி, switch கூற்று குறியுரு அல்லது முழு எண் தரவு வகையை மட்டுமே மதிப்பீடு செய்யும்.
(v) ஐபி தொகுதியின் கீழுள்ள கட்டளைத் தொகுதி நிறைவேற்றப்படும் அல்லது எல்ஸ் தொகுதியின் கீழுள்ள கட்டளைத் தொகுதி நிறைவேற்றப்படும். switch கூற்றினுள் அமைந்திருக்கும் கோவை தவறு என ஆகும் போது, default கூற்று இயக்கப்படும்.
(vi) if else கூற்றில் தேவையான திருத்தங்களை மேற்கொள்ளுவதும், திருத்தம் தேவைப்படும் இடங்களை கண்டறிவதும் மிகவும் கடினம். எனவே if கூற்றை பதிப்பாய்வு செய்வது கடினமானதாகும், அவ்வாறின்றி, switch கூற்றுகளில் திருத்தங்களை எளிதாக கண்டறிய முடிவதால், பதிப்பாய்வு செய்வதும் எளிதாகிறது.

struct Employee{char name[50]; int age; float salary};
நிரல்:
#include < iostream >
using namespace std;
struct Employee
{
char name[50];
int age;
float salary;
};
int main()
{
structEmployeee1;
cout << "Enter Full name:";
cin >> e1.name;
cout << endl << Enter age:";
cin >> e1.age;
cout << "endl'< "Enter salary:";
cin >> e1.salary;
cout << "\n Displaying Information." <<endl;
cout << "Name: << e1.name << endl;
cout << "Age: " <<e1.age<< endl:
cout << "Salary:" << e1.salary;
return 0;
}
வெளியீடு:
Enter Full name:
Ezhil
Enter age:
27
Enter salary:
40000.00
Displaying Information
Name: Ezhil
Age: 27
Salary: 40000.00

10 மாணவர்களின் மதிப்பெண்களை பிடித்து அவற்றின் சராசரியை காணும் ஒரு நிரல்:
#include < iostream >
using namespace std;
int main()
{
int marks[10], sum=0;
float avg;
for(int i=0; i < 10; i++)
{
cout << "\n Enter Mark" << i+1 << " =";
cin >> marks[i];
sum=sum+marks[i];
}
avg=sum/10, 0;
cout << "\n The Total Marks: " << sum;
cout << "\n The Average Mark: " << avg;
}
வெளியீடு:
Enter Mark 1=41
​​​​​​​Enter Mark 2=98
​​​​​​​Enter Mark 3=65
​​​​​​​Enter Mark 4=75
​​​​​​​Enter Mark 5=35
​​​​​​​Enter Mark 6=82
​​​​​​​Enter Mark 7=64
​​​​​​​Enter Mark 8=5
​​​​​​​Enter Mark 9=58
​​​​​​​Enter Mark 10=68
The Total Marks:591
​​​​​​​The Average Mark:59

C++ மொழியில் 10 மதிப்புகளை உள்ளீடாக பெற்று அதில் ஒற்றை எண்களின் எண்ணிக்கை (odd numbers) மற்றும் இரட்டை எண்களின் எண்ணிக்கையை (Even numbers) காண்பதற்கான நிரல்.
#include < iostream >
using namespace std;
int main()
{
int num[10], even=0, odd=0;
for (int i=0; i < 10; i++)
{
cout << "\n Enter Number" << i+1 << "=";
cin >> num[i];
if (num[i] % 2==0)
++even;
else
++odd;
}
cout << '\n There are " << even << " Even Numbers";
cout << "\n There are "<< pdd << "Odd Numbers";
}
வெளியீடு:
Enter Number 1=78
Enter Number 2=52
Enter Number 3=32
Enter Number 4=66
Enter Number 5=41
Enter Number 6=68
Enter Number 7=27
Enter Number 8=65
Enter Number 9=28
Enter Number 10=94
There are 6 Even Numbers
There are 4 odd Numbers

விதிமுறைகள்:
(i) switch கூற்றில் தரப்பட்டுள்ள கோவையின் விடை மாறிலி மதிப்பாக இருத்தல் வேண்டும் இல்லையெனில் அது ஒரு பிழையான வடிவமாகும்.
(ii) ஒரே மதிப்பு இரண்டு கேஸ் கூற்றுகளில் அனுமதிக்கப்பட மாட்டாது.
(iii) default கூற்று கட்டாயமில்லை 
(iv) switch கூற்றின் நிரல் தொகுதியை நிறைவு செய்ய break கூற்று பயன்படுகிறது. நிரல் பாய்வு break கூற்றை அடையும்போது, switch கூற்றிலிருந்து வெளியேறி, switch கூற்றை தொடர்ந்து கொடுக்கப்பட்டுள்ள நிரல் கூற்றுகளை இயக்கும்.
(v) break கூற்று கொடுப்பது கட்டாயமில்லை. break கூற்று கொடுக்கப்படவில்லை எனில், case நிபந்தனை நிறைவேற்றப்படும் நிரல் கூற்றை தொடர்ந்து உள்ள அனைத்து கூற்றுகளும் கட்டுப்பாடின்றி இயங்கும்.
(vi) பின்னலான switch கூற்றுகளும் அமைக்கப்படும்.

ஒரு if கூற்று, மற்றொரு if கூற்றை கொண்டிருந்தால் அது பின்னலான ஐபி கூற்று என்று அழைக்கப்படுகிறது. பின்னலான if கூற்றுகள், பின்வரும் மூன்று வடிவங்களில் அமைக்கப்படும். 
அவையாவன
(i) ஒரு if கூற்றுக்கு உள்ளே மற்றொரு if கூற்றை அமைத்தல் 
(ii) ஒரு if கூற்றின் else கூற்றுக்குள் மற்றொரு if  கூற்றை அமைத்தல் 
(iii) ஒரு if கூற்றுக்கு உள்ளே ஒரு ஐபி கூற்றும், எல்ஸ் கூற்றுக்கு உள்ளே மற்றொரு if கூற்றும் அமைத்தல்.
இந்த மூன்று வடிவங்களின் கட்டளை அமைப்பு கீழே கொடுக்கப்பட்டுள்ளது.
ஒரு if கூற்றுக்கு உள்ளே மற்றொரு if கூற்றை  அமைத்தல்
if (கோவை)
{
மெய் பகுதியின் கூற்றுகள்;
}
else 
{
மெய்யற்ற பகுதி கூற்றுகள்;
}
}
else 
else-பகுதியின் உடற்பகுதி;
ஒரு if கூற்றின் else கூற்றுக்குள் மற்றொரு if கூற்றை  அமைத்தல்
if (கோவை-1)
{
மெய் பகுதியின் உடற்பகுதி ;
}
else
{
if (கோவை)
{
மெய் பகுதி கூற்றுகள் ;
}
else 
{
மெய்யற்ற பகுதி கூற்றுகள்;
}
}
ஒரு if கூற்றுக்கு உள்ளே ஒரு if கூற்றும்,else கூற்றுக்கு உள்ளே மற்றொரு if கூற்றும் அமைத்தல்.
if (கோவை)
{
if (கோவை)
{
மெய் பகுதி கூற்றுக்கள்;
}
else 
{
மெய்யற்ற பகுதி கூற்றுக்கள்;
}
}
else 
{
if (கோவை)
{
மெய் பகுதி கூற்றுகள்;
}
else 
{
மெய்யற்ற பகுதி கூற்றுகள்;
}
}
   

நேரியல் தேடலுக்கான நிரல்:
#include < iostream >
using namespace std;
int Search(int arr[], int size, int value)
{
for (int i=0; i < size; i++)
{
if (arr[i] =value)
return i; // return index value
}
return-1;
}
int main()
{
int num[10], val, id;
for (in i=0; i < 10; i++)
{
cout << "\n Enter value" << i+ 1 << "=";
cin >> num[i];
}
cout << "\n Enter a value to be searched:";
cin >> val;
id=Search(num, 10,val);
if(id==-1)
cout << "\n Given value is not found in the array ..";
else
cout << "\n The value is found at the " << id+1 << "th/ed element";
return 0;
}

#include < iostream >
#include < conio.h >
using namespeace std;
int main ()
{
int row, col, m1[10][10], m2[10][10], sum[10][10];
cout <<"Enter the number of rows:";
cin >> row;
cout << "Enter the number of column:";
cin >> col;
cout << "Enter the elements of 1st marrixr: " << endl;
for (int i =0; i < row; i++) {
for (int j =0; j < col; j++) {
cin >> m1[i][j];
}
}
cout << "Enter the elements of 2nd matrix: " << endl;
for (int i =0; i < row; i++)
for (int j =0; j < col; j++)
cin >> m1[i][j];
}
cout << "Enter the elements of 2nd matrix: " << endl;
for (int i =0; i < row; i++)
for (int j =0; j < col; j++)
cin >> m2[i][j];
}
}
cout << "Output: "<< endl;
for (int i =0; i < row; i++)
for (int j =0; j < col; j++)
{
sum[i][j]=m1 [i][j]+m2[i] [j];
cout << sum[i][j] <<" ";
}
cout << endl << endl;
}
getch();
return 0;
}

செயற்கூற்றுக்கு இரு பரிமாண அணியை அனுப்ப:
ஒரு பரிமாண அணியை செயற்கூறாக அனுப்பி மதிப்பெண்களை வெளியிடும் நிரல்.
#include < iostream >
using namespace std;
void display (in m[5]);
int main()
{
int marks[5]={88, 76, 90, 61, 69};
display(marks);
return 0;
}
void display (int m[5])
{
cout << " Displaying Marks;" << endl
for(int i=0; i<5; ++i)
{
cout << "Student" << i+1 << ":" << m[1] << endl;
}
}
வெளியீடு:
Dispalying marks:
Student 1:88
Student 2:76
Student 3:90
Student 4:61
Student 5:69

குறியுறு அணியை அளபுருவாக கொண்ட செயற்கூறு
#include < iostream > 
using namespace std;
int main ()
{
char str[100];
void display(char s[]);
cout << "Enter a string";
getline(cin, str);
display(str);
return 0;
}
void display (char s[])
{
cout << "You entered char array: " << s << endl;
}
Enter a string: Welcome to C++ programming.
You entered char array: welcome to C++ programming.

இனக்குழுவின் உறுப்பு செயற்கூறுகளுக்கு மதிப்பு மூலம் அனுப்புதல் முறையில் பொருளை அளபுருவாக அனுப்பும்போது, செயற்கூறானது பொருளினை நகல் எடுத்து அதன் மீது செயல்பாடுகளைச் செயல்படுத்தும்.
எனவே செயற்கூறினுள் பொருள்களின் மீது செய்யப்படும் எந்த மாற்றமும் (முறையான அளபுருவாக உள்ள பொருளின் தரவு உறுப்புகளின் மீது) மெய்யான பொருளின் (மெய்யான அளபுருவாக உள்ள பொருளின் தரவு உறுப்புகளின் மீது ) மீது எந்த பாதிப்பையும் ஏற்படுத்தாது.
விளக்க நிரல்:   
#include< iostream >
using namespace std;
class Sample
{
private:
int num;
public:
void set(int x)
{
nurn =x;
}
void pass(Sample obj 1, Sample obj2) // objects are passed
{
obj l.nurn= 100; // value of the object is changed inside the function
obj2.num=200; // value of the object is changed inside the function
cout << "\n\n Changed value of object1 " << obj 1.
num;
cout << "\n\n Changed value of object2" << obj2.
num;
}
void print()
{
cout<< num;
}
};
int main()
{
//object declarations
Sample s1;
Sample s2;
Sample s3;
//assigning values to the data member of objects
s1.set(10);
s2.set(20);
cout << "\n\t\t Example program for pass by value\n\n\n";
//printing the values before passing the object
cout << "\n\nValue of objectl before passing;
s1.print();
cout << "\n\nValue of object2 before passing";
s2.print();
// passing object s1 and s2
s3.pass(s1,s2);
//printing the values after returning to main
cout << "\n \nValue of object! after passing";
s 1.print(); .
cout << "\n\nValue of object2 after passing";
s2.print();
return 0;
}

வரையெல்லை செயற்குறியின் பயன்பாட்டை விளக்கும் நிரல்:
#include< iostream >
using namespaces std;
int a=100;
class A
{
int a;
public:
void fun ()
{
a=20; 
a+=::a; //using global variable value
cout << a;
}};
int main()
{

clrscr();
A a1;
a1.fun();
return 0;
}
வெளியீடு :
120
 

#include< string.h >
#include< iostream >
using namespace std;
class strings
{
public:
char s[20];
void getstring( char str[])
{
strcpy(s,str);
}
void operator+(strings);
};
void strings::operator+(strings ob)
{
strcat(s,ob.s);
cout << "\nConcatnated String is:" << s;
}
int main( )
{
strings ob 1, ob 2;
char string 1[10], string2[10];
cout << "\nEnter First String:";
cin >> string 1;
ob1.getstring(string 1);
cout << "\nEnter Second String:";
cin >> sting2;
ob2.getstring(string2);
//Calling + operator to Join/Concatenate strings
ob1+ob2;
return 0;
}
Enter First String:COMPUTER
Enter Second String:SCIENCE
Concatenated String is:COMPUTERSCIENCE

//Complex number addition and subtraction
#include < iostream >
using namespace std;
class complex
{
int real, img;
public;
void read( )
{
cout << "\nEnter the REAL PART :";
cin >> real;
cout << "\nEnter the IMAGINARY PART :";
cin >> img;
}
complex operator +( complex c2)
{
complex c3;
c3.real=real+c2.real;
c3.img=img+c2.img;
return c3;
}
complex operator -(complex c2)
{
complex c3;
c3.real=real-c2.real;
c3.img=img-c2.img;
return c3;
}
void display( )
{
cout << real << "+" << img << "i";
}
};
int main ( )
{
complex c1,c2,c3;
intchoice, cont;
do
{
{
cout << "\t\t COMPLEX NUMBERS\n\n1.ADDITION\n\n2.SUBTRACTION\n\n";
cout << "\nEnter your choice:";
cin >> choice;
if(choice== 1 llchoice==2)
{
cout << "\n\nEnter the First Complex Number";
C1.read( );
cout << "\n \n Enter the Second Complex Number";
C2.read( );
}
switch(choice)
{
case 1 :c3=c1 +c2; // binary + overloaded
cout << "\n\nSUM = ";
c3.dispaly( );
break;
case 2 :c3=c1-c2; // binary -overloaded
cout << "\n\nResult = ";
c3.display ( );
break
default :cout << "\n\nUndefined Choice";
}
cout << "\n\nDo You Want to Continue? (1-Y,0-N)";
cin >> cout;
}while(cout== 1);
return 0;
}
வெளியீடு:
COMPLEX NUMBERS
1. ADDITION
2. SUBTRACTION
   Enter your choice: 1
Enter the first Complex Number
Enter the REAL PART: 3
Enter the IMAGINARY PaRT: 4
Enter the second Complex Number
Enter the REAL PART: 5
Enter the IMAGINARY PART: 8
SUM = 8 + 12i
Do You Want to Continue? (1-Y,0-N)1
COMPLEX NUMBERS
1. ADDITION
2. SUBTRACTION
Enter your choice: 2
Enter the First Complex Number
Enter the REAL PART: 8
Enter the IMAGINARY PART: 10
Enter the Second Complex Number
Enter the REAL PART: 4
Enter the IMAGINARY PART: 5
Result = 4+5i
Do You Want to Continue?(1-Y,0-N)0

மறுபயனாக்கம் (RE- usability): ஒரு முறை எழுதுதல் பலமுறை பயன்படுத்துதல் இனக்குழு பயன்படுத்தி இதை நிறைவேற்றலாம்.
மிகைமை (Redundancy):
மரபுரிமம் தரவு மிகைமைக்கு சிறந்த சான்றாகும். பல இனக்குழுக்களுக்கு வேவையான ஒரே செயல்பால்பாட்டை ஒரு பொது இனக்குழுவின் மூலம் வரையறுத்து அவற்றை மரபுரிமம் தருவிக்கப்பட்ட இனக் குழுவின் மூலம் தருவித்துக்கொள்ளலாம்.
எளிய பராமரிப்பு (Easy Maintenance) : ஏற்கனவே இருக்கும் குறிமுறையில் சிறிய மாற்றங்களைச் செய்து புதிய பொருளை உருவாக்க முடியும். மேலும் இதை பராமரிப்பது மாற்றங்கள் செய்வதும் எளிது.
பாதுகாப்பு (Security): தரவு மறைப்பு மற்றும் அருவமாக்கம் தேவையான தரவுகளை மட்டும் கொடுப்பதால் தரவு பாதுகாப்பு பராமரிக்கப்படுகிறது.
பொருள் நோக்கு நிரலாக்கத்தின் தீமைகள் (Disadvantages of OOP ) 
அளவு (Size ): பொருள் நோக்கு நிரலானது மற்ற நிரல்களை விட அளவில் பெரியது.
உழைப்பு (Effort) : பொருள் நோக்கு நிரலை உருவாக்குவதற்கு அதிக உழைப்பு வேவைப்படுகிறது.
வேகம் (Speed): பொருள் நோக்கு நிரல்கள் அதிக அளவின் காரணமாக பிற நிரல்களை விட மெதுவாக செயல்படுகிறது. 

1. Start மற்றும் END என்று குறிக்கப்பட்ட சிறப்பு பெட்டிகள் ஒரு இயக்கத்தின் மற்றும் முடிவை குறிப்பிடப் பயன்படுகிறது
 
2. உள்ளீடு  மற்றும் வெளியிடுகள், நாற்கர வடிவ பெட்டில் குறிப்பிடப்பட்டுள்ளது
 
3. வெளியேறும் ஒற்றை அம்புக்குறியுடன் தோன்றும் ஒரு செவ்வகபெட்டியிலுள்ள கூற்று அடுத்து இயக்கப்படும்
 
4. கட்டுப்பாட்டு கூற்று இரண்டு வெளியேறும் அம்புக்குறிகளை ''true'' மற்றும் ''flase'' என்ற விவரத் துணுக்குகளை கொண்ட ஒரு வைரவடிவ பெட்டியின் உள்ளேகுறிப்பிடப்பட்டுள்ளது 
'5. 'true'' என்ற குறிக்கப்பட்ட அம்புக்குறி , கொடுக்கப்பட்ட நிபந்தனை மெய் எனில் , இயக்கப்பட்ட வேண்டிய அடுத்த பெட்டியைகுறிக்கும் 
'' false'' என்ற குறிக்கப்பட்ட அம்புக்குறி , கொடுக்கப்பட்ட நிபந்தனை பொய் எனில் , அடுத்து இயக்கப்பட்ட வேண்டிய அடுத்த பெட்டியைகுறிக்கும் 
                         

நெறிமுறை வடிவமைப்பாளருக்கும் மற்றும் நெறிமுறைபயனர்களுக்கும் இடையே ஒரு ஒப்பந்தமாக ஒரு நெறிமுறை குறிப்பிடப்படுகிறது, ஏனென்றால் வடிவமைப்பாளர் மற்றும் பயனரின் உரிமைகள் மற்றும் பொறுப்புகளை அது வரையறுக்கிறது.
i) உள்ளீடுகளின் தேவையான பண்புகளை திருப்திப்படுத்துவது பயனரின் பொறுப்பு, ஆனால் அது வடிவமைப்பாளரின் உரிமை.
ii) விரும்பிய உள்ளீடு -வெளியீடு உறவு வடிவமைப்பாளரின் பொறுப்பு மற்றும் பயனரின் உரிமை.
iii) பயனர் உள்ளீடுகளின் பண்புகளை முக்கியமாக, திருப்திசெய்யாவிட்டால், விரும்பியஉள்ளீடு வெளியீடு உறவைதிருப்தி செய்யவடிவமைப்பாளரின் கட்டளையிலிருந்து விடுபடலாம்.
                      

நாம் அடிப்படைகட்டுமான தொகுதிகளை பயன்படுத்தி நெறிமுறைகளை கட்டமைக்கிறோம்.
அவை
1) தரவு
2) மாறிகள்
3) கட்டுப்பாடு ஓட்டம்
4) செயற்கூறுகள்
தரவு (Data)
i) நெறிமுறைகள் தரவை உள்ளீட்டாக பெற்ற அதை செயல்படுத்தி வெளியீட்டை வழங்குகின்றது
ii) கணிப்பொறிகள் தரவுகளை செயல்படுத்துவதற்கான கட்டளைகளை வழங்குகின்றன.
   எண்கள் மற்றும் உரை போன்ற பல்வேறு வகையான தரவுகள் உள்ளன.
மாறிகள் (Variables)
i) தரவுகளை சேமிப்பதற்கு மாறிகள் பெயரிடப்பட்ட பெட்டிகளாக பயன்படுகிறது.
ii) தரவுகளை செயல்படுத்தும் போது கிடைக்கும் விடைகளை மாறிகளில் சேமிக்கவேண்டும்.
iii) ஒரு மாறியில் சேமிக்கப்படும் தரவு அந்த மாறிக்கான மதிப்பு என்று அழைக்கப்படுகிறது.
கட்டுப்பாட்டு பாய்வு (Control flow)
i) ஒரு நெறிமுறை என்பது படிப்படியான கூற்றுகள் ஆகும். இருப்பினும், ஒரு கூற்றை நிறைவேற்றிய பின்னரே, அடுத்த கூற்றை செயல்படுத்த வேண்டும் என்பது நெறிமுறைகளில் கட்டாயம் இல்லை.
ii) அடுத்தடுத்து செயல்படுத்தப்பட வேண்டிய கூற்றுகள், செயல்பாட்டின் நிலைமையைச் சார்ந்தது.
iii) ஆகையால் கூற்றுகள் நெறிமுறையில் எழுதப்பட்டுள்ள வரிசையில் நிறைவேற்றப்படாமல், வேறுவரிசையில் நிறைவேற்றப்படலாம். இந்த வரிசையில் நிறைவேற்றப்படும் கூற்றுகள் கட்டுப்பாடு பாய்வு என்று அறியப்படுகிறது.
செயற்கூறுகள் (Functions)
i) நெறிமுறைகள் மிகவும் சிக்கலானதாக இருக்கும். ஒரு நெறிமுறையின் மாறிகளின் மற்றும் அதைசார்ந்த மாறிகள் அதிகமாக இருக்கலாம். பின்னர், நெறிமுறைகளை சரியாக உருவாக்ககடினமாக இருக்கும்.
ii) அத்தகையசூழ்நிலைகளில், நாம் ஒரு நெறிமுறையை பகுதிகளாக உடைக்கிறோம், ஒவ்வொன்றையும் தனித்தனியாக கட்டமைத்து, பின்னர் முழுமையான நெறிமுறைபகுதிகளை ஒருங்கிணைக்கலாம்.
iii) ஒரு நெறிமுறையின் பகுதிகள் செயல்பாடுகள் என அறியப்படுகின்றன. ஒரு செயற்பாடு ஒரு துணை நெறிமுறையாகும். இது ஒரு உள்ளீட்டை பெற்று, செயல்படுத்தி வெளியீட்டை வெளியீடுகிறது, உள்ளீடு மற்றும் வெளியீட்டின் உறவை திருப்தி செய்கிறது.

i) ஒரு கணிப்பொறியை இயக்கும் அடிப்படைமென்பொருள் "இயக்கஅமைப்பு" (டீளுடீயீநசயவபே  ளுலளவநஅ) ஆகும்.
ii) ஒரு கணிப்பொறி தொடங்கும் போது அதன் முதன்மைநினைவகத்தில் எந்தத் தகவல்களும் இருக்காது. அதேநேரத்தில், அதன் "படிக்கமட்டும் நினைவகத்தில்" (ROM - Read Only Memory) ஏற்கனவேஎழுதப்பட்ட "மின் இணைப்பில் சுயஆய்வு" (POST - Power On Self Test) என்றநிரல் முதலில் இயங்கத் தொடங்கும்.
iii) இந்தநிரல் கணிப்பொறியில் இணைக்கப்பட்டுள்ள அனைத்துப்புறக்கருவிகளும் (முதன்மை நினைவகம், விசைப்பலகை, திரையகம் போன்ற), இயங்கும் நிலையில் உள்ளதாஎன ஆய்வு செய்யும்.
iv) அனைத்தும் சரியான நிலையில் இருந்தால் மட்டுமே, தொடர்ந்து "அடிப்படைஉள்பளீட்டுவெளியீட்டு முறைமை" (BIOS - Basic Input output System) யை இயக்கும். இந்தச் செயல்முறை "தொடங்குதல்" (Booting) என அழைக்கப்படுகிறது.
v) அதன் பின்னர், Boot Strap Loader என்றநிரல், "இயக்கஅமைப்பு" மென்பொருளை வன்வட்டிலிருந்து, முதன்மைநினைவகத்திற்கு அனுப்புகின்றது. இப்போது கணிப்பொறி திரையில், நமது கணிப்பொறியில் நிறுவப்பட்டுள்ளஇயக்க அமைப்பு மென்பொருள் (விண்டோஸ் / லினக்ஸ் அல்லது வேறு ஏதேனும் ஒரு இயக்க அமைப்பு) இயக்கத்தொடங்கும்.
ஒரு கணிப்பொறியில் இரண்டு வகையான "தொடங்குதல்" (Booting) முறைகள் உள்ளன. அவை
1) தண் தொடக்கம் (Cold booting)
2) உடன் தொடக்கம் (Warm booting)
1) தண் தொடக்கம் (Cold booting)
ஒரு கணிப்பொறியை முதன்முதலில் தொடங்குவதைத் தண் தொடக்கம் அல்லது வன் தொடக்கம் (Hard booting) எனலாம்.
இந்தத் தொடக்கமுறையில், பயனர் மின் இணைப்பைத் தொடங்கும் போது, படிக்கமட்டும் நினைவகத்தில் உள்ள POST நிரல் இயங்கத் தொடங்கும்.
2) உடன் தொடக்கம் (Warm booting)
இயங்கிக்கொண்டிருக்கும் ஒரு கணிப்பொறியை ஏதேனும் ஒரு சூழலில் அதன் இயக்கத்தை நிறுத்தி மீண்டும் தொடங்குதலை உடன் தொடக்கம் அல்லது மென் தொடக்கம் (Soft booting) எனலாம்.
இந்தமுறையில், கணிப்பொறி "தண் தொடக்கமுறையில்" தொடங்கியது போல் அனைத்துப் புறக்கருவிகளின் இணைப்பை உறுதி செய்து தொடங்குவதில்லை.
மேலும், தொடக்கமுறையில் முதன்மைநினைவகத்தில், முந்தையஇயக்கத்தின் போது பயன்படுத்தப்பட்ட தகவல்கள் முறையாக இரண்டாம் நிலை நினைவகத்திற்கு மாற்றப்படாத நிலை ஏற்படுவதால், தகவல்கள் அழியும் நிலையும், கணிப்பொறியின் இயக்க அமைப்பு பழுதடையும் நிலையும் ஏற்படும்.

(i) (11101)₂

(ii) (1102)₂ = 1 x 2³ + 1 x 2² + 0 x 2¹ + 1 x 2⁰
= 8 + 4 + 0 + 1
= (13)₁₀

1. அனைத்து நவீன கணிப்பொறிகள் மற்றும் தொலைதொடர்பு சாதனங்களில் பரவலாக பயன்படுத்தப்படும்  ஓர் முக்கிய குறியீட்டு முறையுனிகோட் ஆகும் 
2. ASCII குறியீட்டு முறைக்கு பிறகு மிகப்பிரபலமான ஓர் முறைதான் யுனிகோட் குறியீட்டு முறையாகும் 
3. ASCII குறியீட்டு முறை 8பிட் அளவில் , 256 எழுத்துருக்களுக்கு மட்டுமே குறியிட  முடியும். எனவே ASCII முறையில் ஆங்கிலம் மற்றும் ஐரோப்பிய மொழிகளை மட்டுமே கையாள முடிந்தது
4. உலகில் உள்ளமற்ற மொழிகளை கையாளும் திறன் ASCII  குறியீட்டு முறைக்கு இருக்கவில்லைகுறிப்பாக, நமது இந்திய மொழிகளான தமிழ் . மலையாளம் , தெலுங்கு, கன்னடம்  போன்றவற்றை ASCII யில் கையாள முடியாத நிலை இருந்தது
5. எனவே உலகின் அனைத்து மொழிகளுக்கும் ஒரே குறியீட்டு முறையை ஏற்படுத்தும் நோக்கில் உருவாக்கப்பட்டது
6. இது 16பிட் முறையில்  65536 எழுத்துருக்களை கையாளும் திறன் பெற்றது.யூனிகோட் முதல் பதிப்பு  1991 வெளியிடப்பட்டது. யூனிகோட் குறியீட்டு முறை, பதினாறு நிலை எண் முறையில் குறியிடப்படுகின்றது.

அவர் வரிசையின் நீளத்தைத் தானாகவே கணக்கிடுவதற்குப் பதிலாக, வரிசையில் முதலாவது நிற்கிற வாடிக்கையாளர் Aயிடம், வரிசையின் நீளம் என்ன? என்று கேட்கிறார். வாடிக்கையாளார் A, வாடிக்கையார் B யிடம், நீளம் என்ன? என்று கேட்கிறார். வாடிக்கையாளார் B வாடிக்கையாளர் C யிடம் கேட்கிறார். இப்படி ஒவ்வொருவரும் தனக்குப்பின் இருப்பவரிடம் கேட்கிறார்கள். வரிசையின் கடைசியில் இருக்கும் வாடிக்கையாளர் E என்று வைத்துக்கொள்வோம். அவரிடம் இந்தக் கேள்வியைக் கேட்கும்போது, அவர் தன்னிடம் கேட்ட D யிடம் “1’’ என்று பதிலளிக்கிறார். D,“1+1=2” என்று Cக்குப்
பதிலளிக்கிறார். C,“1+2=3” என்று Bக்குப்
பதிலளிக்கிறார். B,“1+3=4” என்று A க்குப்
பதிலளிக்கிறார். A,“1+4=5” என்று தன்னிடம் கேட்ட சேவையாளருக்குப் பதிலளிக்கிறார்.

விடை (-2₁₀) - (-6₁₀) = 4₁₀

படிநிலை 1:

படிநிலை 2:

படிநிலை3:
-12 மற்றும் 5க்கான இருநிலை கூட்டல்:

12₁₀ 5₁₀ 7₁₀

படிநிலை 1: -21 மற்றும் 5யை இருநிலை எண் வடிவில் மாற்றுதல்:

படிநிலை 2:

படிநிலை 3:
-21 மற்றும் 5க்கான இருநிலை கூட்டல்: