(i) temp = b;
(ii) b = b+1;
(iii) c = d/temp;
(iv) temp = b+c;
(v) a-temp-1;

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

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

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

#include < iostream >
#include< math.h >
void main ()
{
int 1, b, ar, p;
double d;
1= 20; b = 10;
ar = 1* b;
p=2*(l+b);
d = sqrtl (* 1+ b * b);
cout << "Theareaofrectangle" << ar << endl;
cout << "\n The perimeter of rectangle" << p;
cout << "\n The diagonal ofrectangle" << d;
}

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

வெளியீடு :
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

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

for மடக்கு : போர் மடக்கு ஓர் எளிய மடக்காகும். இது கூற்றுகளை மீண்டும் மீண்டும் இயக்கும். for மடக்கு மூன்று கூற்றுகளை கொண்டிருக்கும் அவை 1. தொடக்க மதிப்பிருத்தல் (Intialization), 2. சோதிப்பு நிபந்தனை அல்லது நிபந்தனை கோவை (Text-expressions) மற்றும் 3. மிகுப்புக் கோவைகள் (Update expressions) இவை அரைப்புள்ளியில் பிரிக்கப்பட்டிருக்க வேண்டும்.
பொது வடிவம்: for (தொடக்க மதிப்பிருத்தல்;சோதிப்பு நிபந்தனை; மிகுப்பு கோவைகள்)
{
நிரல் கூற்று 1;
நிரல் கூறு ;
________ 
}
நிரல் கூற்று -x; தொடக்க மதிப்பிருத்தல் பகுதி, கட்டுப்பாட்டு மாறியை அறிவிக்க அல்லது மாறியின் மதிப்பிருத்த பயன்படுகிறது. இந்த பகுதி ஒரு முறை மட்டும் இயக்கப்படும். பின்னர் நிரல் பாய்வு,சோதிப்பு நிபந்தனை கோவைக்கு செல்லும். கட்டுப்பாட்டு கோவையின் நிபந்தனை சோதிக்கப்பட்டு, அதன் மதிப்பு தவறு என்று வந்தால் நிரல் கூற்று -க்ஸ் இயங்கும் மதிப்பு சரியென்று வந்தால் for மடக்கின் உடற்பகுதி இயக்கப்பட்டு, பின்னர் நிரல் பாய்வு மிகுப்பு கோவைக்கு அனுப்பி வைக்கப்படும். மிகுப்பு கோவை செயல்பட பின்னர், மீண்டும் சோதிப்பு நிபந்தனை கோவைக்கு அனுப்பி வைக்கப்படும்.
எடுத்துக்காட்டு:
# include < iostream >
using namespace std;
int main ( )
{
int i;
for (i = 0; i < 10; i++)

cout << " value of i : " << i << endl;
return 0;
}

உறுப்பு செயற்கூறுகளுக்கு குறிப்பு மூலம் பொருளை அளபுருவாக அனுப்பும் போது,பொருளின் நினைவக முகவரியானது அளபுருவாக அனுப்பி வைக்கப்படும். எனவே அழைக்கப்படும் செயற்கூறானது மெய்யான அளபுருவாக உள்ள பொருளின் மீதே செயல்பாட்டைச் செயல்படுத்தும். செயற்கூறில் (முறையான அளபுருக்களின் மீது)செய்யப்படும் எந்த மாற்றமும் மெய்யான அளபுருவாக உள்ள பொருளின் மீதும் பாதிப்பை ஏற்படுத்தும்.
  குறிப்பு மூலம் அனுப்புதல் முறை செயல்படும் விதம் பற்றிய நிரல்:
#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;
}

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

வரையெல்லை செயற்குறியின் பயன்பாட்டை விளக்கும் நிரல்:
#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

மறுபயனாக்கம் (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) பயனர் உள்ளீடுகளின் பண்புகளை முக்கியமாக, திருப்திசெய்யாவிட்டால், விரும்பியஉள்ளீடு வெளியீடு உறவைதிருப்தி செய்யவடிவமைப்பாளரின் கட்டளையிலிருந்து விடுபடலாம்.
                      

இணையான விதி Identity
A + 0 = A  A. 1 = A 
மாற்று விதி Complement
A + A = 1  A + A = 0
இடமாற்ற விதி Commutative
A + B = B + A  A.B = B.A
தொடர் விதி  Associative
A + (B+C) = (A +B) + C
A. (B.C) = (A.B).C
பகிர்வு விதி Distributive
A.(B+C) = A.B + A.C
A + (B.C) = (A+B).(A+C)
வெற்று கூறு Null Element
A + 1 = 1  A.0 = 0
மாற்றியின் மாற்றி Dnvolution 
(A) = A
உள்ளீடும் வெளியீடும் சமம் Indempotency
A + A = A  A. A= A
தன்னகத்தே ஏற்றுக்கொள்ளுதல் Absorption
A + (A . B) = A    A. (A + B) = A
3rd பகிர்வு விதி Distributive
A + A. B = A + B 
டிமார்கன் விதி
(A + B)' = A' . B'
(A.B)' = A' + B'

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) எனலாம்.
இந்தமுறையில், கணிப்பொறி "தண் தொடக்கமுறையில்" தொடங்கியது போல் அனைத்துப் புறக்கருவிகளின் இணைப்பை உறுதி செய்து தொடங்குவதில்லை.
மேலும், தொடக்கமுறையில் முதன்மைநினைவகத்தில், முந்தையஇயக்கத்தின் போது பயன்படுத்தப்பட்ட தகவல்கள் முறையாக இரண்டாம் நிலை நினைவகத்திற்கு மாற்றப்படாத நிலை ஏற்படுவதால், தகவல்கள் அழியும் நிலையும், கணிப்பொறியின் இயக்க அமைப்பு பழுதடையும் நிலையும் ஏற்படும்.

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

எத்தனை துண்டுகள், எத்தனை வெட்டுக்கள் என்பதைக் குறிக்க முறையே p, c என்ற  மாறிகளைப் பயன்படுத்தலாம். ஒவ்வொரு முறை வெட்டும்போதும், வெட்டுகளின் எண்ணிக்கை ஒன்று கூடுகிறது, துண்டுகளின் எண்ணிக்கை ஒன்று கூடுகிறது. இதை ஒரு மதிப்பிருத்தலின் மூலம் குறப்பிடலாம்.
p, c := p+1, c+1
முழு சாக்லேட்டை வெட்டும் செயல்முறையை ஒரு மடக்கைக் கொண்டு விளக்கலாம். தொடங்கும்போது ஒரேயொரு துண்டு உள்ளது, ஒருமுறைகூட வெட்டப்படவில்லை. அதாவது, p = 1, c = 0 மொத்தத் தனித்தனி சதுரங்களின் எண்ணிக்கை nம் சமமாகும்போது மடக்கு முடிவடைகிறது.
p, c :=p + 1, C+1
p-c என்பது, p, c:=p+1, c+1 என்ற மதிப்பிருத்தலின் மாற்றுமிலி என்று எடுத்துக்காட்டு 8.2இல் பார்த்தோம். p-c=k என்க. இதில் k ஒரு நிலையான மதிப்பு, நெறிமுறையில் எந்தெந்த இடங்களில் p-c=k என்பது மெய்யாக இருக்கிறது என்று கீழே கொடுக்கப்பட்டுள்ள நெறிமுறையிலும், பாய்வுப்படம் காணப்படுள்ளது.
P, c:=0, 1
1   --p-c = k
while p \(\neq \)n
2   --p-c=k
p, c:=p1+, c1+
3   --p-c=k
4  --p - c=k, p=n
p-c = k என்ற மடக்கு மாற்றமிலி, மடக்கின் தொடக்கத்தில் (முதல் வரி) மெய்யாக இருக்கிறது. மேலும், மடக்கின் தொடக்கத்தில் p - c =1. எனவே, k = 1 மடக்கு மாற்றமிலிலி p-c = 1 எனக் குறிப்பிடலாம்.
மடக்கு முடியும்போது (நான்காவது வரி), மடக்கு மாற்றிமிலி, p-c= 1 இன்னும் மெய்யாக இருக்கிறது. மேலும், மடக்கின் நிபந்தனை p \(\neq \)n என்பது பொய்யாக உள்ளது. எனவே, p - c = 1,
p=n இவைகளிலிருந்து
(1) p-c = 1 என்பது மடக்கு மாற்றமிலி
(2) p = n என்பது மடக்கின் முடிவு
(3) n-c=1 என்பது (1), (2) வது வரிகளிலிருந்து
(4) c=n-1 என்பது (3) வது வரியிலிருந்து
மடக்கு முடியும்போது சதுரங்களின் எண்ணிக்கையைவிட வெட்டுகளின் எண்ணிக்கை ஒன்று குறைவாக இருக்கிறது.