Wednesday, 14 August 2013

C Program In Tamil

பாடம்-5
சி-மொழித் தரவினங்கள்
(Data Types in C)
ஒரு குறிப்பிட்ட பணியைச் செய்து முடிப்பதற்குக் கம்ப்யூட்டரில் புரோகிராம் எழுதுகிறோம். புரேகிராம் என்பது கம்ப்யூட்டருக்குத் தரப்படும் கட்டளைகளின் தொகுப்பாகும். வெறும் கட்டளைகளை வைத்துக் கொண்டு கம்ப்யூட்டரால் எதுவும் செய்ய முடியாது. புரோகிராம் செயல்படுவதற்குத் தேவையான விவரங்களை உள்ளீடாகத் தரவேண்டும். இவ்விவரங்களைத்தான் டேட்டா என்கிறோம். தமிழில் ‘தரவு’ எனலாம்.
ஆக, கம்ப்யூட்டர் புரோகிராம் என்பது ஒரு பணியைச் செய்து முடிப்பதற்கான தீர்வுநெறி (Algorithm), தரவுகள் (Data) - ஆகிய இரண்டையும் உள்ளடக்கியதாகும். சென்ற அத்தியாயத்தில் குறிப்பிட்டுள்ள LEAPYEAR.C என்ற புரோகிராமை எடுத்துக் கொள்ளுங்கள். அது நாம் தரும் ஆண்டினை, லீப் ஆண்டா எனப் பரிசோதித்துச் சொல்லும். நாம் உள்ளீடாகத் தரும் ஆண்டினை டேட்டா என்கிறோம். இத்தகைய தரவுகளை அடித்தளமாகக் கொண்டு, அவற்றைக் கையாளும் கட்டளைகளின் உதவியுடன் சிக்கலான புரோகிராம் மாளிகைகளை எழுப்புகிறோம்.
புரோகிராம்களில் பயன்படுத்தப்படும் ஒவ்வொறு டேட்டாவும் குறிப்பிட்ட இனத்தைச் சேர்த்ததாகவே இருக்கும். LEAPYEAR.C புரோகிராமில்,
int y;
என்று குறிப்பிட்டுள்ளோம். y என்பது ‘இன்டிஜர்’ இனத்தைச் சேர்ந்தது என்பது இதன் பொருள். இதுபோலப், பல்வேறு இனத் தரவுகளைக் கம்ப்யூட்டரில் கையாளுகிறோம்.
ஓர் அலுவலரின் பெயர், வயது, பிறந்த நாள், சம்பளம், திருமணம் ஆனவரா இல்லையா என்ற விவரம் - இவற்றையெல்லாம் புரோகிராமில் எடுத்தாள வேண்டியுள்ளது. இவை முறையே எழுத்துச் சரம் (String), முழுஎண் (Integer), தேதி (Date), பதின்மப் புள்ளி எண் (Real), ஆமில்லை (Logical) போன்ற வெவ்வேறு இன மதிப்புகளாகும். ஒவ்வொரு கம்ப்யூட்டர் மொழியும் தமக்கே உரிய தரவினங்களைக் கொண்டுள்ளன. சி-மொழியில் கையாளப்படும் தரவின வகைகளைப் பார்ப்போம்.
சி-மொழியில் நான்கு அடிப்படைத் தரவினங்கள் (Basic Data Types) உள்ளன. .இவை மூலத் தரவினங்கள் (Primitive Data Types) என்றும் அழைக்கப்படுவதுண்டு. எளிய தரவினங்கள் (Simple Data Types) என்றும் கூறுவர். தரவினம் என்பது ஒரு குறிப்பிட்ட தரவை மட்டுமின்றி அதைப் பயன்படுத்துவது பற்றிய விதிமுறைகளையும் சேர்த்தே குறிக்கிறது. ஒரு தரவினம் குறிப்பிட்ட மதிப்புகளையே (values) ஏற்கும். குறிப்பிட்ட செயல்பாடுகளையே (operations) அதன்மீது நிகழ்த்த முடியும்.
சி-மொழியின் தரவினங்களில் சில உள்-வகைகளும் உள்ளன. மூலத் தரவினங்களின் அடிப்படையில் உருவாக்கப்படும் தருவிக்கப்பட்ட தரவினங்களும் (Derived Data Types) சி-மொழியில் கையாளப்படுகின்றன.
 மூலத் தரவினங்கள் (Basic Data Types)
சி-மொழியின் அடிப்படை அல்லது மூலத் தரவினங்கள்:
1. char
2. int
3. float
4. double
char என்பது ஒற்றை எழுத்து, எண் அல்லது சிறப்புக் குறியைக் (special character) குறிக்கிறது. int என்பது முழு எண்களையும் float என்பது மெய்யெண் (Real Number) எனப்படும் புள்ளி எண்களையும் double என்பது துல்லியப் புள்ளி எண்களையும் குறிக்கின்றன. ஒன்றுக்கு மேற்பட்ட எழுத்துகள் அடங்கிய சரத்தைக் (String) குறிக்கத் தனியான தரவினம் சி-மொழியில் கிடையாது. அதே வேளையில், எண்வகை இனம் int, float, double என்ற மூன்று தனித்தனி தரவினங்களாக அமைந்துள்ளன.
இந்த நான்கு மூலத் தரவினங்களையும் அடிப்படையாகக் கொண்டு அர்ரே, ஸ்ட்ரக்சர், யூனியன், ஈநம், பாயின்டர் என்னும் தருவிக்கப்பட்ட தரவினங்களும் (Derived Data Types) கையாளப்படுகின்றன. இவற்றைப்பற்றி பின்வரும் அத்தியாயங்களில் விரிவாகப் படிப்போம். சி-மொழியில் ஸ்டிரிங் தரவினம் இல்லை. ஸ்டிரிங்குகளைக் கையாள கேரக்டர் அர்ரேக்கள் பயன்படுத்தப்படுகின்றன. சி-மொழியில் தேதிக்கென்று தனி இனம் கிடையாது. அதேபோல் சரி/தவறு (True/Flase) என்ற லாஜிக்கல் இனமும் கிடையாது. ஜீரோ என்கிற எண் மதிப்பு False என்பதற்கும், ஒன்று அல்லது ஏதேனும் ஒரு நிறை எண் (Positive number) True என்ற நிலைக்கும் பயன்படுத்தப்படுவது சி-மொழியின் சிறப்புக் கூறாகும்.
 உள்-வகைகள்
நான்கு மூலத் தரவினங்களும், அவை ஏற்கும் மதிப்பெல்லைகளை அடிப்படையாகக் கொண்டு, பல்வேறு உட்பிரிவுகளாகப் பிரிக்கப்படுகின்றன: int இனம் மூன்று வகையாக எடுத்தாளப்படுகிறது.
1. short int
2. int
3. long int
மேற்கண்ட மூன்று இனங்களும் நினைவகத்தில் எடுத்துக் கொள்ளும் இடம் (பைட் எண்ணிக்கை) கம்ப்யூட்டரைப் பொறுத்து மாறுபடுகின்றது. அதாவது பீசி, மினி, மெயின் ஃபிரேம்களில் இந்த அளவுகள் மாறுபடலாம். ஆனால் short int என்பது int-ஐவிட அதிக பைட்டுகளை எடுத்துக் கொள்ள முடியாது. சில கம்ப்யூட்டர்களில் short int நினைவகத்தில் எடுத்துக் கொள்ளும் பைட்டு எண்ணிக்கை int எடுத்துக் கொள்வதில் பாதியாக இருக்கலாம். அதேபோல் long int என்பது int அளவைப்போல் இரு மடங்கு இருக்கும். எல்லா கம்ப்யூட்டரிலும் அப்படி இருக்கும் என்று சொல்ல முடியாது. ஆனால் int என்பது long int-ஐவிட அதிக அளவுடையதாக இருக்க முடியாது.
புரோகிராம்களில் தரவினங்களைக் குறிப்பிடுகையில் short int என்பதை வெறுமனே short எனவும், long int என்பதை long எனவும் குறிப்பிட்டால் போதும். டர்போ-சி கம்ப்பைலரைப் பொறுத்தவரை short int என்பதும் int என்பதும் ஒன்றுதான். long int என்பது int -ஐவிட இரு மடங்கு பைட்டு அளவுடையது.
பதின்மப் புள்ளி எண்களைப் பொறுத்தவரை double இனம் float இனத்தைவிட இரு மடங்கு பைட்டுகளை நினைவகத்தில் எடுத்துக் கொள்ளும். இதுவும் கம்ப்யூட்டர் சார்ந்த (Machine Dependent) அளவீடுதான். double இனம் long float எனவும் வரையறுக்கப்படும். அன்சி-சி, long double என்னும் ஒரு புதிய உள்-வகைக்கு வழியமைத்துக் கொடுத்துள்ளது. இது double இனத்தைவிட அதிக அளவு இடத்தை எடுத்துக் கொள்ளும்.
சி-மொழியில் char, int ஆகிய தரவு இனங்களை signed, unsigned ஆகிய பண்புகளினால் வேறுபடுத்திக் காட்ட முடியும். தரவு இனங்களை அறிவிக்கும்போது signed char, unsigned char எனவும் signed int, unsigned int எனவும் signed long, unsigned long எனவும் அறிவிக்க முடியும். signed இனம் நெகட்டிவ், பாஸிட்டிவ் ஆகிய இரு மதிப்புகளையும் ஏற்கும். unsigned இனம் பாஸிட்டிவ் மதிப்புகளை மட்டுமே ஏற்கும். இதன் காரணமாய் unsigned இனம் ஏற்கும் உச்சமதிப்பு signed இனத்தின் உச்சமதிப்பைவிட இருமடங்கு இருக்கும்.
short, long, signed, unsigned ஆகியவை தனித் தரவினங்களாகக் கருதப்படுவது இல்லை. இச்சொற்கள் பண்பேற்றிகள் (Qualifiers அல்லது Modifiers) என்று அழைக்கப்படுகின்றன. எனவேதான் இத்தகைய அடைமொழி பெற்ற தரவினங்களை ‘உள்-வகை’ எனக் குறிப்பிட்டுள்ளோம். தரவின அறிவிப்பில் வெறுமனே char, int, long எனக் குறிப்பிட்டால் signed char, signed int, signed long ஆகிய இனங்களையே குறிக்கும்.
 தரவு இனம், மதிப்பெல்லை, நினைவக அளவு
இதுவரை நாம் பார்த்த தரவினங்கள் மற்றும் அவற்றின் உள்-வகைகள் ஏற்கும் மதிப்புகளின் எல்லைகளையும், இவ்வினங்கள் நினைவகத்தில் எடுத்துக் கொள்ளும் பைட் அளவுகளையும் கீழே உள்ள பட்டியலில் காண்க:
தரவு இனம்மதிப்பின் எல்லைநினைவக அளவு (பைட்டில்)
signed char-128 to +1271
char-128 to +1271
unsigned char0 to 2551
signed short int-32768 to +327672
short int-32768 to +327672
unsigned short int0 to 655352
signed int-32768 to +327672
int-32768 to +327672
unsigned int0 to 655352
signed long int-2147483648 to +21474836474
long int-2147483648 to +21474836474
unsigned long int0 to 42949672954
float.4 x 10-38 to 3.4 x 10384
long float.7 x 10-308 to 1.7 x 103088
double.7 x 10-308 to 1.7 x 103088
long double.7 x 10-4932 to 1.7 x 10493210
பட்டியலின் இறுதியில் குறிப்பிட்டுள்ள நினைவக அளவு கம்ப்யூட்டருக்குக் கம்ப்யூட்டர் வேறுபடலாம். சில கம்ப்பைலர்கள் char என அறிவிக்கப்படும் தரவினத்தை எப்போதும் unsigned char இனமாகவே கருதிக்கொள்ளும். அதாவது char என்பது 0 முதல் 255 வரையிலான மதிப்புகளையே எடுத்துக்கொள்ளும். நெகட்டிவ் மதிப்புகளை ஏற்காது. எனவே char இனத்தைக் கம்ப்பைலருக்கு ஏற்பப் பயன்படுத்த வேண்டும் என்பதை மனதில் கொள்க.
int என அறிவிக்கப்பட்ட மாறியில் 36767-ஐவிடப் பெரிய எண்ணை இருத்தி வைக்க முடியாது. எடுத்துக்காட்டாக 200 x 200 என்ற பெருக்குத் தொகையின் விடையை ஓர் int மாறியில் இருத்த முடியாது. உங்கள் புரோகிராமில்,
int n;
n = 200 * 200;
என்று, கட்டளைகள் அமைந்துள்ளதாக வைத்துக் கொள்வோம். புரோகிராமைக் கம்ப்பைல் செய்யும்போது, கம்ப்பைலர் பிழை எதுவும் சுட்டாது. புரோகிராமைச் செயல்படுத்தும்போது இயக்கநேரப் பிழை (Run Time Error) எதுவும் நிகழாது. ஆனால், புரோகிராம் தவாறான விடையைக் காட்டும். n என்னும் மாறியில் 40000 என்னும் மதிப்பு இருக்காது. இதுபோன்ற தருணங்களில் n என்னும் மாறியை long என அறிவித்துக் கொள்ள வேண்டும். உங்கள் புரோகிராம்களில் கணக்கீடுகளை மேற்கொள்ளும்போது தரவினங்களின் மதிப்பெல்லைகளை நினைவில் வைத்துக் கொள்வது முக்கியம்.
[பாடம்-5 முற்றும்]

பாடம்-6
சி-மொழியில் மாறிகள்
(Variables in C)
கம்ப்யூட்டர் மொழிகளில் டேட்டாவை இரண்டு வகையாகக் கையாள முடியும்:
1. மாறிகள் (variables)
2. மாறிலிகள் (constants)
ஒரு புரோகிராம் செயல்படுத்தப்படும்போது, மதிப்பு மாறக்கூடிய வாய்ப்பிருக்கும் டேட்டா, மாறி (variables) எனப்படுகிறது. LEAPYEAR.C புரோகிராமை எடுத்துக் கொள்வோம். அதில் y-ன் மதிப்பு ஒவ்வொரு முறை புரோகிராம் இயக்கப்படும்போதும், நமது உள்ளீட்டுக்கு ஏற்ப மாறுகின்றது. எனவே, இதனை மாறி என்கிறோம். மாறிலி (constants) என்பது மாறா மதிப்பைக் கொண்டது. மாறிலி அறிவிக்கப்படும்போது அதில் இருத்தப்படும் மதிப்புப் புரோகிராமில் பின் எப்போதும் மாற்றப்பட முடியாதது. முதலில் மாறிகள் பற்றிக் காண்போம்.
நாம் பார்த்த நான்கு தரவு இனங்களில் மட்டும் இன்றி, அவற்றின் உள்-வகைகளிலும், தருவிக்கப்பட்ட தரவு இனங்களான அர்ரே, ஸ்ட்ரக்சர், யூனியன், ஈநம், பாயின்டர் ஆகிய தரவு இனங்களிலும் மாறிகள் அறிவிக்கப்பட்டுக் கையாளப்படுகின்றன. சி-மொழியில் லாஜிக்கல் (அல்லது பூலியன்) மாறிகள், ஸ்டிரிங் மாறிகள் கிடையாது என்பதை மனதில் இருத்துங்கள்.
மாறிகளைப் புரோகிராம்களில் எடுத்தாள்வதற்குப் பல்வேறு வழிமுறைகளும் விதிமுறைகளும் வரையறுக்கப்பட்டுள்ளன. அவற்றை எடுத்துக்காட்டுகளுடன் விரிவாகக் காண்போம்.
 மாறிகளின் பெயர்கள்
புரோகிராமில் பயன்படுத்தப்படும் டேட்டா கம்ப்யூட்டரின் நினைவகத்தில் பதிந்து வைக்கப்பட்டு எடுத்தாளப்படுகின்றது. தேவையானபோது எடுத்தாள அதற்கு ஒரு பெயர் இருக்க வேண்டும். எனவே, புரோகிராமில் பயன்படுத்தப்படும் டேட்டாவுக்குப் பொருத்தமான ஒரு பெயரைச் சூட்டுகிறோம். அதாவது, டேட்டாவை நினைவகத்தில் பதிந்து வைக்க ஓர் இடத்தை ஒதுக்கீடு செய்து, அந்த இடத்துக்கு ஒரு பெயர் (Label) சூட்டுகிறோம். அப்பெயரையே மாறி (variable) என்கிறோம்.
மாறிகளின் பெயர்கள் எப்படி அமைய வேண்டும் என்பதற்கான விதிமுறைகள்:
(1) மாறிகளின் பெயர்கள் அதிக அளவாக எட்டு எழுத்துகள் இருக்கலாம். ஆனால் புதிய கம்ப்பைலர்கள் 16 அல்லது அதற்கு மேற்பட்ட எழுத்துகளையும் ஒத்துக் கொள்கின்றன. அதிக அளவாக 31 எழுத்துகளை அடையளம் காண முடியும் என அன்சி-சி வரையறுத்துள்ளது.
(2) மாறிகளின் பெயர்கள் எண்ணாகவோ, எண்ணில் தொடங்குமாறோ இருக்கக் கூடாது.
(3) மாறிகளின் பெயரில் இடவெளி (space) இடம்பெறக் கூடாது.
(4) அண்டர் ஸ்கோர் தவிர பிற சிறப்புக் குறிகள் இடம்பெறக் கூடாது.
(5) மாறிகளின் பெயர்களாக சி-மொழியின் சிறப்புச் சொற்களைப் (Reserved Words) பயன்படுத்தக்கூடாது.
மாறிகளின் சரியான பெயர்களுக்கு எடுத்துக்காட்டுகள்:
1. a, b, c, ab, xyz, A, Bc,aBC
2. a1, B2, C2c, x1y2z3
3. name, age, pay, area, redius
4. SUM, Sum, sum, average, dBASE
5. a_1, file_2, basic_pay, data_of_birth
6. lotus123, art312C, sys5ver6
மாறிகளுக்கு எப்போதுமே பொருத்தமான பெயர்களைச் சூட்ட வேண்டும். வெறுமனே ஒற்றை எழுத்துகளை மட்டுமே மாறிகளின் பெயர்களாக அறிவிப்பது சிறந்த முறை ஆகாது. ஒரு பணியாளரின் பெயர், வயது, சம்பளம் போன்றவற்றைக் கையாள முறையே a, b, c எனக் குறிப்பிடக் கூடாது. பொருத்தமாக name, age, salary எனப் பெயரிடலாம். total amount, rate of interest என இரண்டு மூன்று சொற்களில் மாறிகளின் பெயர்களை அமைக்க விரும்பினால் சொற்களுக்கு இடையே அண்டர் ஸ்கோர் பயன்படுத்தி, total_amount, rate_of_interest என மாறிகளின் பெயர்களை அறிவிக்க வேண்டும். மாறிகளின் பெயர்கள் எப்போதும் சிறிய எழுத்தில் இருப்பதே மரபு.
மாறிகளின் தவறான பெயர்களுக்கு எடுத்துக்காட்டுகள்:
(1) 2, 32, 123 - எண்களாக இருக்கக் கூடாது
(2) 2A, 4BCD, 5digit - எண்ணில் தொடங்கக் கூடாது
(3) basic pay, date of birth - இடவெளி கூடாது
(4) yes/no, bill.amt, month-total - சிறப்புக் குறிகள் கூடாது
(5) int, char, float - சிறப்புச் சொற்கள் கூடாது
(6) while, do, else, return - கட்டளைச் சொற்கள் கூடாது
 மாறிகளை அறிவித்தல்
புரோகிராம்களில் மாறிகளை அறிவிக்கும் முறைக்குச் சில எடுத்துக்காட்டுகளைப் பார்ப்போம்.
char ch;
int age;
long salary;
float radius;
double area;
ஒரே இனத்தில் ஒன்றுக்கு மேற்பட்ட மாறிகளையும் அறிவிக்க முடியும்.
int i, j, k;
float radius, area;
ஒரே இனமாக இருந்த போதிலும் வேறுவேறு பயன்பாடுகளுக்கான மாறிகளைத் தனித்தனி வரிகளில் அறிவிப்பது மரபாகும்.
int i, j;
int length, breadth;
 அறிவிப்பும் வரையறுப்பும் (Declaration & Definition)
ஒரு மாறி, மதிப்பை ஏற்ற பிறகே ‘இனிஷியலைஸ்’ செய்யப்பட்டதாகக் கொள்ளப்படும். இனிஷியலைஸ் செய்யப்பட்ட பிறகே அந்த மாறி வரையறுக்கப்பட்டதாகக் (defined) கருதப்படும். இனிஷியலைஸ் செய்யப்படாத மாறியை எக்ஸ்பிரஷன்களில் பயன்படுத்தினால் கம்ப்பைலர் எச்சரிக்கை செய்யும்.
ஒரு மாறியை இரண்டு வழிகளில் இனிஷியலைஸ் செய்யலாம். மாறியை அறிவித்த பிறகு புரோகிராமின் வேறோர் இடத்தில் அதில் மதிப்பை இருத்துவது ஒரு முறை. அறிவிக்கும்போதே அதில் தொடக்க மதிப்பை இருத்துவது இன்னொரு முறை.
int a;
...........
a = 5;
என்று மதிப்பிருத்தலாம்.
int sum = 0;
int a = 100;
char ch = ‘A’;
என்றும் மாறிகளை வரையறுக்கலாம். ஒரே அறிவிப்பில் ஒன்றுக்கு மேற்பட்ட மாறிகளை அறிவிக்கும்போது, சிலவற்றை மட்டும் இனிஷியலைஸ் செய்யலாம்.
int m, n, sum = 0;
int start = 1, end, step = 5, sum;
என்றெல்லாம் அறிவிக்க முடியும். மிகவும் கறாராகக் கூறுவது எனில்,
int m;
என்று மாறியை மட்டும் மதிப்பிருத்தாமல் குறிப்பிடுவது ‘அறிவிப்பு’ (Declaration) எனப்படும்.
int m = 5;
என்றோ,
int m;
m = 5;
என்றோ மாறியை இனிஷியலைஸ் செய்வது ‘வரையறுப்பு’ (Definition) எனப்படும். எந்தவொரு மதிப்பையும் ஏற்காமல் அறிவிப்பு நிலையிலேயே இருக்கும் மாறி வரையறுக்கப்படாத மாறி எனப்படுகிறது.
சி-மொழிப் புரோகிராமில் பெரும்பாலும் மாறிகள் புரோகிராமின் அல்லது ஒரு ஃபங்ஷனின் தொடக்கத்திலேயே அறிவிக்கப்படுகின்றன. மிக அரிதாக ஒரு பிளாக்குக்குள் மாறிகள் அறிவிக்கப்படுவதுண்டு. { } என்னும் இரட்டை அடைப்புக் குறிகளுக்குள் அமையும் கட்டளைத் தொகுதி சி-மொழியில் பிளாக் எனப்படுகிறது இதைப்பற்றி பின்னர் விரிவாக படிப்போம்.
main() அல்லது வேறு ஃபங்ஷனில் அல்லது பிளாக்கில் மாறிகளின் அறிவிப்புக்கு முன்பாக printf(), scanf() ஃபங்ஷன்களோ அல்லது வேறெந்தக் கட்டளையுமோ இடம்பெறக் கூடாது. இன்னொரு கோணத்தில் சொல்வதெனில், சி-மொழிப் புரோகிராமில் மாறிகளை இடையிடையே நினைத்த இடத்தில் அறிவித்துக் கொள்ள முடியாது. மேலேயுள்ள புரோகிராமை நன்றாகக் கூர்ந்து கவனியுங்கள். radius, pai, area ஆகிய மாறிகள்/மாறிலிகள் தொடக்கத்திலேயே அறிவிக்கப்பட்டுள்ளன.
printf(“\nEnter redius:”);
scanf(“%d, &redius);
float area;
area = pai * redius * redius;
என்று கட்டளைகள் அமைத்தால் புரோகிராம் கம்ப்பைல் ஆகாது.
ஒரு ஃபங்ஷனுக்குள் அல்லது ஒரு பிளாக்கினுள் ஒரே பெயரில் இரண்டு மாறிகள் இருக்க முடியாது. அதாவது ஒருமுறை அறிவித்த மாறியை மீண்டும் அறிவிக்க முடியாது. அதாவது, ஏற்கெனவே அறிவிக்கப்பட்ட ஒரு மாறியின் பெயரில் வேறொரு மாறியை அறிவிக்க முடியாது. வெவ்வேறு ஃபங்ஷன்களில் அல்லது வெவ்வேறு பிளாக்குகளில் ஒரே பெயரில் வெவ்வேறு மாறிகளைப் பயன்படுத்த முடியும்.
மாறிகளை அறிவிக்கும் விதம் தொடர்பாக, மனதில் பதிய வைக்க வேண்டிய விவரங்களைத் தொகுத்துக் காண்போம்:
(1) மாறிகள் புரோகிராம், ஃபங்ஷன் அல்லது பிளாக்கின் தொடக்கத்திலேயே அறிவிக்கப்பட வேண்டும்.
(2) மாறிகளின் இனத்தை முன்கூட்டியே தெரிவித்துவிட வேண்டும். இனம் சுட்டாத மாறி இருக்க முடியாது. வேறுசில மொழிகளில் இருப்பதுபோல் முதலில் மாறியை அறிவித்துவிட்டுப் பிறகு இனத்தைத் தீர்மானிக்க சி-மொழியில் அனுமதி இல்லை.
(3) ஒரு ஃபங்ஷனுக்குள் அல்லது ஒரு பிளாக்கினுள் ஒரே பெயரில் இரண்டு மாறிகள் இருக்க முடியாது.
(4) ஓர் இன மாறியில் வேறு இன மதிப்பை இருத்த முடியாது. (int மாறி என அறிவித்து விட்டால், அதில் float மதிப்பை இருத்தி வைக்க முடியாது). இனமாற்றம் செய்து இருத்தலாம். இனமாற்றம் பற்றிப் பிறகு படிப்போம்.
(5) ஒரு மாறியை அறிவிக்கும்போதே அதில் தொடக்க மதிப்பையும் இருத்த முடியும்.
(6) ஒரே இனமுள்ள பல மாறிகளை ஒரே வரியில் முன்னறிவிக்கலாம். இரண்டு மாறிகளுக்கிடையே காற்புள்ளி இடவேண்டும்.
(7) மதிப்பு இருத்தப்பட்ட மாறி இனிஷியலைஸ் செய்யப்பட்ட மாறி எனப்படும். இனிஷியலைஸ் செய்யப்பட்ட மாறி வரையறுக்கப்பட்ட மாறி ஆகிறது.
(8) வரையறுக்கப்படாத அதாவது இனிஷியலைஸ் செய்யப்படாத (மதிப்பு இருத்தப்படாத) மாறிகளை எக்ஸ்பிரஷன்களில் பயன்படுத்தக் கூடாது.
[பாடம்-6 முற்றும்]

பாடம்-7
சி-மொழியில் மாறிலிகள்
(Constants in C)
ஒரு புரோகிராமில் எப்போதுமே மாற்றப்படும் சாத்தியக்கூறு இல்லாத ஒரு டேட்டாவை மாறிலி (Constant) என்கிறோம். சி-மொழியில் இரண்டு வகையாக மாறிலிகள் செயல்படுத்தப்படுகின்றன. (1) #define பதிலீடுகள் மூலமாக. இத்தகைய மாறிலிகள் ‘குறியீட்டு மாறிலிகள்’ (Symbolic Constants) என்று அழைக்கப்படுகின்றன. (2) const என்னும் பண்பேற்றி (Qualifier) மூலமாக. இத்தகைய மாறிலிகள் ‘பண்பேற்றிய மாறிகள்’ (Qualified Variables) எனப்படுகின்றன. இவ்விரண்டு வகைகளையும் எடுத்துக் காட்டுகளுடன் பார்ப்போம்.
 நேரடி மதிப்பு
புரோகிராமில் எப்படிப்பட்ட இடங்களில் மாறிலியைப் பயன்படுத்த முடியும் என்பதற்கு ஒரு சரியான எடுத்துக்காட்டைப் பார்ப்போம். பயனாளரிடம் இருந்து ஆர அளவை (radius) பெற்று வட்டத்தின் பரப்பளவைத் திரையிடும் புரோகிராமைப் பாருங்கள்:
/* Program No. */
/* AREA1.C */
#include <stdio.h>
main()
{
      int radius;
      float area;
      printf(“\nEnter radius: “);
      scanf(“%d”, &radius);
      area = 3.14 * radius * radius;
      printf(“Area of the circle is %f”, area);
}
இந்தப் புரோகிராமில் பரப்பளவைக் காணும் கட்டளையில் 3.14 என்னும் மதிப்பை நேரடியாகப் பயன்படுத்தி உள்ளோம். இந்தப் புரோகிராமை எத்தனை முறை இயக்கினாலும், ஆர அளவை எப்படிக் கொடுத்தாலும் 3.14 என்னும் மதிப்பு மாறப்போவதில்லை. ஒரே புரோகிராமில் வெவ்வேறு இடங்களில் வட்டத்தின் பரப்பளவை காணவேண்டி இருந்தாலும் இதே 3.14 மதிப்பைத்தான் பயன்படுத்த வேண்டியிருக்கும்.
3.14 என்பது இந்தப் புரோகிராமில் மட்டும் அல்ல உலகிற்கே ஒரு பொதுவான எண் அல்லவா? இப்படிப்பட்ட உலகப் பொதுவான எண்களை மட்டும் அல்ல உங்கள் புரோகிராமிற்கு மட்டும் பொதுவான (மதிப்பு மாறாத) எண்களைக்கூட இப்படி நேரடியாகக் கணக்கீடுகளில் பயன்படுத்தக் கூடாது. இந்தப் புரோகிராமைப் படிப்பவர்களுக்கு 3.14 என்ற எண்ணின் முக்கியத்துவம் புலப்படாமலே போகும். புரோகிராமை எழுதியவர்க்கே, பல நேரங்களில், எக்ஸ்பிரஷன்களில் காணப்படும் இதுபோன்ற எண்கள் புதிர் எண்களாகத் தோன்றும். மொழி வல்லுநர்கள் இத்தகைய எண்களை ‘மேஜிக் எண்கள்’ எனக் கிண்டலாகக் குறிப்பிடுவர். புரோகிராமுக்குப் பொதுவான இப்படிப்பட்ட மாறா மதிப்புகளை நேரடியாகப் பயன்படுத்தக்கூடாது என்பது அவர்களின் கருத்து. அவற்றை ஒரு மாறிலி வழியாகவே பயன்படுத்த வேண்டும். எப்படி எனப் பார்ப்போம்.
 குறியீட்டு மாறிலி
சி-மொழியில் குறியீட்டு மாறிலிகளை வரையறுக்க, #define என்னும் கட்டளைச் சொல் பயன்படுத்தப்படுகிறது. புரோகிராமின் தொடக்கத்தில்,
#define PAI 3.14
என்று அறிவித்து விட்டுப் புரோகிராமின் உள்ளே,
area = PAI * radius * radius;
என்று பரப்பளவைக் கணக்கிட வேண்டும். கீழே உள்ள புரோகிராமை நோக்குங்கள்:
/* Program No. */
/* AREA2.C */
#include <stdio.h>
#define PAI 3.14
main()
{
      int radius;
      float area;
      printf(“\nEnter radius: “);
      scanf(“%d”, &radius);
      area = PAI * radius * radius;
      printf(“Area of the circle is %f”, area);
}
#define என்பதைக் கம்ப்பைல் பணிக்கு முந்தைய நெறியுறுத்தம் (pre-processor directive) என்று கூறுவர். அதாவது புரோகிராமில் எங்கெல்லாம். PAI இடம்பொற்றுள்ளதோ. அங்கெல்லாம் 3.14 என்ற மதிப்பு பதிலிடப்பட்டு, அதன்பிறகே புரோகிராம் கம்ப்பைல் செய்யப்படும்.
இவ்வாறு புரோகிராமில் கையாளும் மாறா மதிப்புகளை மாறிலிகளாகக் கையாளுவதில் இரண்டு வகையான நன்மைகள் உள்ளன:
(1) PAI ஒரு மாறா மதிப்பு என்பது புரோகிராமைப் படிப்பவர்க்கு எளிதில் புலனாகும். பொருள் பொதிந்ததாகவும் உள்ளது.
(2) PAI - யின் மதிப்பை இன்னும் துள்ளியமாக 3.142 என்றோ அல்லது 3.1415 என்றோ பயன்படுத்த எண்ணினால் #define வரையறுப்பில் மாற்றினால் போதும். நேரடியாக மதிப்பை பயன்படுத்தி இருந்தால், அம்மதிப்பு இடம்பெற்ற அத்தனை கணக்கீடுகளையும் கண்டறிந்து மாற்ற வேண்டும். மிகப் பெரிய புரோகிராம்களில் இது ஒரு சிக்கலான பணியாகும்.
புரோகிராமின் தொடக்கத்தில் மாறிலியை அறிவித்தபின் புரோகிராமின் உள்ளே,
PAI = 3.142;
என்று புதிய மதிப்பைப் புகுத்த முடியாது. சரியாகச் சொல்வதெனில், ஒரு மதிப்பு இருத்தும் கட்டளையில் (assignment statement) இடப்புறத்தில் PAI -ஐப் பயன்படுத்த முடியாது.
 குறியீட்டு மாறிலியின் வரையறுப்புகள்
ஒரு #define அறிவிப்பில் ஒரேயொரு மாறிலியை மட்டுமே குறிப்பிட முடியும். வெவ்வேறு மாறிலிகளுக்கு தனித்தனி #define அமைக்க வேண்டும்.
#define   TRUE       1
#define   FALSE      0
#define   TOP         100
#define   EOF         -1
#define   PERIOD   ‘.’
#define   NAME       “Sivalingam”
ஒரு #define அறிவிப்பில் உள்ள மாறிலியை அடுத்துவரும் #define அறிவிப்பில் பயன்படுத்திக் கொள்ளமுடியும்.
#define   START   100
#define   NEXT     START + 1
என்று பயன்படுத்த முடியும்.
#define கட்டளையில் int, char, string மதிப்புகளைத் தவிர unsigned, long மதிப்புகளையும், octal, hexa decimal மதிப்புகளையும் அறிவிக்க முடியும்.
#define   CR                 0x0D     /* hexa value 13 */
#define   LINE_FEED   012     /* octal value 12 */
#define   PORT             25U   /* unsigned value 25 */
#define   LIMIT             40000L /* long value 40000 */
#define   BELL             ‘\007’   /* character value 7 */
#define   NEW_LINE   ‘\n’      /* newline character */
#define   TAB               ‘\t’     /* tab character */
#define கட்டளையைப் பயன்படுத்தும்போது கருத்தில் கொள்ள வேண்டிய முக்கிய விவரங்கள்:
(1) main() ஃபங்ஷனுக்கு வெளியே புரோகிராமின் தொடக்கத்தில் அமைய வேண்டும்.
(2) #define கட்டளையின் இறுதியில் அரைப்புள்ளி கிடையாது.
(3) #define வரையறுப்பில் தரவினத்தைக் குறிப்பிட வேண்டிய தில்லை. மதிப்பினைக் கொண்டே கம்ப்பைலர் அடையாளம் கண்டு கொள்ளும்.
(4) ஒரு #define-ல் ஒரு மாறிலியை மட்டுமே வரையறுக்க முடியும்.
(5) மாறிலிகளின் பெயர்கள் எப்போதும் பெரிய எழுத்துகளில் இருப்பது மரபு.
 மதிப்புருக்கள் (Literals)
int n = 25;
char ch = ‘A’;
average = 12.345 / 6.0;
printf (“Welcome to C!”);
என்பது போன்ற கட்டளைகளில் இன்டிஜர், கேரக்டர், ஸ்ட்ரிங் மதிப்புகளைப் பயன்படுத்துகிறோம். இப்படிப்பட்ட மதிப்புகளை மாறா மதிப்பு (Constant Values) என்கிறோம். மாறிலி (Constant) என்று கூறினாலும் தவறில்லை. சில ஆசிரியர்கள் இவற்றை மதிப்புருக்கள் (Literals) என்று அழைக்கின்றனர். ஒவ்வொரு தரவினத்திலும் ஏற்கெனவே அட்டவணையில் கொடுக்கப்பட்ட வரம்புகளுக்குள் ஏதேனும் ஒரு மதிப்பை மாறியில் இருத்த முடியும் அல்லது கணக்கீட்டில் பயன்படுத்த முடியும். எடுத்துக்காட்டுகள்:
char        - ‘a’, ‘A’, ‘5’, ‘?’, ‘=’
int           - 25, 32767, 0, -8, +65, 037
long         - 0L, 25L, 100000L
unsigned - 0U, 65000U, 25U
octal        - 03, 012, 0345
hexa        - 0x01A, 0xFFF, 0Xf0ab
float         - 12.345F, 5.0F, -8.3F, +1.234F
double     - 12.345, 5.0, -8.3, +1.23, 1.23E+5, 1.234e-8
string       - “Kumar”, “Long Live”, “12345”
சி-மொழியில் ஒற்றையெழுத்து கேரக்டர் மதிப்பை ஒற்றை மேற்கோள் குறிகளுக்குள்ளும், ஸ்டிரிங் மதிப்புகளை இரட்டை மேற்கோள் குறிகளுக்குள்ளும் குறிப்பிட வேண்டும் என்பதை நினைவில் கொள்க. குறிப்பிடத்தக்க செய்தி என்ன வெனில், சி-மொழியில் ஸ்டிரிங் மாறிகள் கிடையாது. ஆனால், ஸ்டிரிங் மாறிலிகள் (அதாவது மதிப்புருக்கள்) உண்டு.
 const என்னும் பண்பேற்றி
புரோகிராமில் மாறிலிகளை அறிவிப்பதற்கு அன்சி-சி-யில் ஒரு புதிய முறை புகுத்தப்பட்டது. const என்னும் பண்பேற்றி (Qualifier) அறிமுகப்படுத்தப்பட்டது.
const float pai = 3.142;
என்று ஒரு மாறிலியை அறிவிக்கலாம். இங்கே pai என்பது float மாறி. const என்னும் அடைமொழியால் ஒரு மாறிலியாக மாற்றப்பட்டுள்ளது. இவ்வாறு const என்று அறிவித்துவிட்டால் புரோகிராமில் பின்னோர் இடத்தில்,
pai = 3.1415;
என்று புரோகிராமரே நினைத்தாலும் மாற்ற முடியாது. const என அறிவிக்கும்போது கட்டாயமாக அதில் ஒரு தொடக்க மதிப்பு இருக்க வேண்டும். அதாவது,
const float pai;
என்று அறிவிக்க முடியாது. AREA2.C புரோகிராமை const பயன்படுத்தி எழுதிப் பார்ப்போமா?
/* Program No. */
/* AREA3.C */
#include <stdio.h>
main()
{
      int radius;
      float area;
      const float pai = 3.14;
      printf(“\nEnter radius: “);
      scanf(“%d”, &radius);
      area = pai * radius * radius;
      printf(“Area of the circle is %f”, area);
}
இந்தப் புரோகிராமின் வெளியீடு முந்தைய புரோகிராமின் வெளியீடு போலவே இருக்கும். const அறிவிப்பில் ஒன்றுக்கு மேற்பட்ட மாறிலிகளை வரையறுக்க முடியும்.
const int start = 100, end = 200;
const char ch = ‘A’, int limit = 1000, float pai = 3.14;
மாறிலிகளை அறிவிக்கும் விதம் தொடர்பாக, மனதில் பதிய வைக்க வேண்டிய விவரங்களைத் தொகுத்துக் காண்போம்:
(1) மாறிலிகள் புரோகிராமின் தொடக்கத்திலேயே அறிவிக்கப்பட்டுவிட வேண்டும்.
(2) மாறிலிகளை #define அல்லது const என்ற முறையில் அறிவிக்கலாம்.
(3) #define அறிவிப்பில் மாறிலியின் பெயரும் அதன் மதிப்பும் இடம்பெற வேண்டும்.
(4) #define அறிவிப்பில் தரவு இனத்தைக் குறிப்பிட வேண்டிய தேவையில்லை. மதிப்புகளைக் கொண்டே தரவு இனத்தைக் கம்ப்பைலர் புரிந்து கொள்ளும்.
(5) #define, main()-க்கு வெளியே இடம்பெற வேண்டும்.
(6) #define அறிவிப்பின் இறுதியில் அரைப்புள்ளி கிடையாது.
(7) const அறிவிப்பில் தரவு இனத்தைக் குறிப்பிட வேண்டும்.
(9) ஒரு மாறிலியை const என அறிவிக்கும்போது கட்டாயமாக அதில் ஒரு தொடக்க மதிப்பை இருத்த வேண்டும். அந்த மதிப்பை புரோகிராமில் வேறு எங்கும் மாற்ற முடியாது.
(10) ஒரே const-ல் ஒன்றுக்கு மேற்பட்ட மாறிலிகளை அறிவிக்க முடியும்.
(11) மாறிகள் அல்லது மாறிலிகளில் இருத்தப்படும் மதிப்புகளும் எக்ஸ்பிரஷன்களில் பயன்படுத்தப்படும் மதிப்புகளும் மதிப்புரு (Literal) என்றும், சில வேளைகளில் மாறிலி (Constant) என்றும் அழைக்கப்படுவதுணடு.
[பாடம்-7 முற்றும்]


பாடம்-8
சி-மொழியில் இனமாற்றங்கள்
(Type Conversions in C)
ஒரு புரோகிராமில் char, int, float, double ஆகிய தரவினங்களில் அறிவிக்கப்பட்ட மாறிகளில், ஓர் இனத்தின் மதிப்பை வேறோர் இனத்தின் மதிப்பாக எடுத்தாளும் முறையே இனமாற்றம் (Type Conversion) எனப்படுகிறது. சி-மொழியைப் பொறுத்தவரைப் புரோகிராமரின் தலையீட்டிலும், புரோகிராமரின் தலையீடு இல்லாமலும் இத்தகைய இனமாற்றம் சாத்தியம். சி-மொழியில் char மதிப்பை int மதிப்பாகவும், int மதிப்பை char மதிப்பாகவும், int மதிப்பை float அல்லது double-ஆகவும், float அல்லது double மதிப்புகளை int ஆகவும் மாற்றிக் கையாளலாம். இத்தகைய இனமாற்றம் இரண்டு வழிகளில் நடைபெறுகிறது:
(1) உட்கிடை இனமாற்றம் (Implicit Type Conversion)
(2) வெளிப்படை இனமாற்றம் (Explicit Type Conversion)
இந்த இருவகையான இனமாற்றங்களும் சி-மொழியில் எவ்வாறு நடைபெறுகின்றன என்பதை எடுத்துக்காட்டுகளுடன் பார்ப்போம்.
 உட்கிடை இனமாற்றம் (Implicit Type Conversion)
கம்ப்யூட்டர் புரோகிராம்களில் இனமாற்றம் என்பது அவ்வப்போது தேவைப்படும். குறிப்பாகக் கணக்கீடுகளில் இது தேவைப்படுகிறது. ஓரினத்தில் உருவாக்கப்பட்ட ஒரு மாறியின் மதிப்பை வேறோர் இன மதிப்போடு கணக்கீடுகளில் பயன்படுத்தும்போது இத்தகைய தேவை எழும். அதுபோன்ற தேவையை அறிந்து கொள்ள சில எடுத்துக்காட்டுகளைப் பார்ப்போம். கீழேயுள்ள புரோகிராமை எழுதி இயக்கிப் பாருங்கள்:
/* Program No. */
/* TYPECAS1.C */
#include <stdio.h>
main()
{
      int a=10, b=4;
      float c;
      c = a / b;
      printf("a=%d, b=%d, a/b=%3.1f", a, b, c);
}
இந்தப் புரோகிராமை இயக்கிப் பார்த்தால்,
a = 10, b = 4, a/b = 2.0
என்றுதான் விடை கிடைக்கும். ஏனெனில், a, b இரண்டும் int-ஆக இருப்பதால் a/b என்பதும் int-ஆகத்தான் இருக்கும். எனவே 2.0 தான் விடையாக வரும். 2.5 வராது. விடையை ஒரு float மாறியில் இருத்துவதாலேயே விடை 2.5 என்று ஆகிவிடாது. int மதிப்புகளில் செய்யப்படும் கணக்கீட்டின் விடை int மதிப்பாகவே இருக்கும் என்பது அறிக. மேற்கண்ட புரோகிராமைச் சிறிதே மாற்றுங்கள்:
/* Progarm No.2.4 */
/* TYPECAS2.C */
#include <stdio.h>
main()
{
      int a = 10;
      float b = 4, c;
      c = a / b;
      printf("a=%d, b=%1.0f, a/b=%3.1f", a, b, c);
}
இந்தப் புரோகிராம்,
a = 10, b = 4, a / b = 2.5
என்று காண்பிக்கும். float மதிப்புகளுக்கிடையே நடைபெறும் கணக்கீட்டின் விடைதானே float மதிப்பாக இருக்கும். இங்கே, b-யின் மதிப்பு float-ஆகவும், a-யின் மதிப்பு int-ஆகவும் இருந்தும் float மதிப்பு எவ்வாறு விடையாக வந்தது? மேலும் ஒரே இனத்தைச் சார்ந்த மதிப்புகளுக்கு இடையேதான் கணக்கீடு சாத்தியம். இங்கே ஓர் int மதிப்புக்கும், ஒரு float மதிப்புக்கும் இடையே வகுத்தல் எவ்வாறு சாத்தியமாயிற்று? இங்குதான் உட்கிடை இனமாற்றம் பங்கு வகிக்கிறது. c = a / b என்ற கணக்கீட்டில் c-யும், b-யும் float-ஆக இருப்பதால் a-யின் மதிப்பும் float-ஆக மாற்றப்பட்டு, விடையும் float மதிப்பாகவே கிடைத்துவிடுகிறது. ஏற்கெனவே நாம் பார்த்த AREA3.C புரோகிராமை இங்கே நினைவு கூருங்கள். அதில்
area = pai * radius * radius;
என்ற கட்டளை இடம் பெற்றுள்ளது. radius என்பது int இனமாக இருந்த போதிலும் pai என்பது float-ஆக இருப்பதால், radius என்பது float-ஆக மாற்றப்பட்டு அவற்றின் பெருக்குத் தொகையும் float இனமாகவே இருக்கும். எனவேதான் area என்பது float-ஆக அறிவிக்கப்பட்டுள்ளது. இவ்வாறு, இரண்டு தரவு இனங்களிடையே செய்யப்படும் கணக்கீட்டில், கீழ்நிலை இனம் மேல்நிலை இனமாகத் தாமாகவே மாற்றப்பட்டுவிடும். இந்த இனமாற்றத்தைக் கம்ப்பைலர் செய்கிறது. உட்கிடை இனமாற்றத்தில் இடம்பெறும் இனங்களின் தகுதி வரிசை int, long , float, double என்றவாறு அமையும். int, long-ஆக மாறி, விடை long-லேயே கிடைக்கும். அதுபோலவே int-ம் double-ம் மோதினாலும், float-ம் double-ம் மோதினாலும் விடை double-இல்தான் கிடைக்கும்.
இவ்வாறு சி-மொழிக் கணக்கீடுகளில் புரோகிராமரின் தலையீடு இல்லாமல் தாமாகவே (Implicitly) இனமாற்றம் நிகழ்கிறது. இந்த இனமாற்றம் தற்காலிகமானதே. கணக்கீட்டில் இனமாற்றம் அடையும் ஒரு மாறி தனது மூல இனத்தை இழப்பதில்லை. கணக்கீட்டிற்குப் பிறகு அது மூல இனத்திலேயேதான் நீடிக்கும்.
எண்வகை இனங்களுக்குள் நடைபெறும் உட்கிடை இனமாற்றம் போலவே சி-மொழியில் char இனத்துக்கும் int இனத்துக்கும் இடையிலும் உட்கிடை இனமாற்றம் சர்வ சாதாரணமாக நடைபெறுகிறது. எந்த அளவுக்கு என்றால் ஒரு குறிப்பிட்ட மதிப்பெல்லைக்குள் char இனத்தை int இனமாகவே கையாளும் அளவுக்கு இந்த இனமாற்றம் நடைபெறுகிறது. எப்படி எனப் பார்ப்போம்.
 char, int இரண்டும் ஓரினமா?
சி-மொழியில் char இனத்தை int இனமாகவும், int மதிப்பை char ஆகவும் கையாள முடியும். உங்கள் புரோகிராமில் ஓர் எண்வகை மாறியின் மதிப்பை -128 முதல் 127 வரைதான் கையாளுகிறீர்கள் எனில் அதனை int என்பதற்குப் பதிலாக signed char என அறிவித்துக் கொள்ளலாம். 0 முதல் 255 வரைதான் கையாளுகிறீர்கள் எனில், அதனை unsigned char என அறிவித்துக் கொள்ளலாம். அதேபோல char மதிப்புகளை int மதிப்புகளாகவே எடுத்தாள முடியும். அதாவது char இனம் மூலம் செய்து முடிக்க வேண்டிய வேலைகளை int இனம் மூலமாகவே சாதித்துக் கொள்ள முடியும். அதற்கு சி-மொழியின் உட்கிடை இனமாற்றம் துணைபுரிகிறது. இதன் காரணமாக “சி-மொழியைப் பொறுத்தவரை அனைத்துத் தரவினங்களும் எண்வகையைச் சார்ந்தவையே. எழுத்துவகை (கேரக்டர், ஸ்ட்ரிங்) இனங்களே கிடையாது” என்று கூறுவாரும் உண்டு.
int என்று அறிவிக்கப்பட்ட ஒரு மாறியை அதன் மதிப்பு -128 லிருந்து +127 வரை அல்லது 0 விலிருந்து 255 வரை இருக்கும் பட்சத்தில் அதனை char இனமாகவே கையாள முடியும் என்பதற்கு ஓர் எடுத்துக்காட்டுப் பார்ப்போம். கீழே உள்ள புரோகிராமைப் பாருங்கள்:
/* Program No.2.3 */
/* CHARINT2.C */
#include <stdio.h>
main()
{
      int alpha=65;
      printf("\nASCII value is %d", alpha);
      printf("\nASCII character is %c", alpha);
}
இந்தப் புரோகிராமைச் செயல்படுத்தினால்,
ASCII value is 65
ASCII character is A
என்று திரையில் காட்டும். இதில் குறிப்பிடத்தக்க செய்தி என்னவெனில், alpha என்ற int இன மாறியின் மதிப்பை %d என்ற குறியீட்டில் காண்பிக்கச் சொன்னால் 65 என்றும், %c என்ற குறியீட்டில் காண்பிக்கச் சொன்னால் A என்றும் காண்பிக்கிறது. A என்னும் ஆங்கில எழுத்தின் ஆஸ்க்கி மதிப்பு 65 என்பது நீங்கள் அறிந்ததே. இங்கே %c என்னும் வடிவமைப்புக் குறியீடே (format specifier) இனமாற்றத்தை நிகழ்த்தி விடுகிறது. கீழ்க்காணும் புரோகிராமையும் இயக்கிப் பாருங்கள்:
/* Program No.7 */
/* CHARINT3.C */
#include <stdio.h>
main()
{
      char alpha='A';
      printf("\nASCII character is %c", alpha);
      printf("\nASCII value is %d", alpha);
}
இந்த புரோகிராமைச் செயல்படுத்தினால்,
ASCII character is A
ASCII value is 65
என்று காட்டும். alpha என்னும் char இன மாறியின் மதிப்பை %c என்ற குறியீட்டில் A எனவும், %d என்ற குறியீட்டில் 65 எனவும் காட்டுகிறது. இன்னும் ஒரு புரோகிராமைப் பாருங்கள்:
/* Program No.2.*/
/* CHARINT1.C */
#include <stdio.h>
main()
{
      char alpha = 'A';
      char beta;
      beta = alpha + 1;
      printf("\nAlpha is %c", alpha);
      printf("\nBeta is %c", beta);
}
இந்தப் புரோகிராமைச் செயல்படுத்திப் பாருங்கள்.
Alpha is A
Beta is B
என்று மிகச் சரியாகவே காண்பிக்கும். முந்தைய புரோகிராமைவிட ஒரு படி மேலே போய் alpha என்ற கேரக்டர் மாறியில் உள்ள A என்னும் மதிப்பில் 1 என்னும் எண்ணை நேரடியாகக் கூட்ட முடிகிறது. beta = alpha + 1 என்ற கணக்கீட்டில் + என்னும் கணக்கீட்டுச் செயற்குறி (arithmatic operator) alpha என்னும் char மதிப்பை int மதிப்பாக இனம் மாற்றிக் கணக்கீட்டைச் செய்ய உதவுகிறது. அதேபோல், = என்னும் மதிப்பிருத்தல் செயற்குறி (assignmaent operator) ஓர் int மதிப்பை char மதிப்பாக இனம் மாற்றி, beta என்னும் char மாறியில் இருத்த உதவுகிறது. இந்த உட்கிடை இனமாற்றங்களைப் புரோகிராமரின் தலையீடின்றிக் கம்ப்பைலரே முன்னின்று செய்து முடிக்கிறது.
மேற்கண்ட புரோகிராம்களில் char மாறிகளில் கேரக்டர் மதிப்பையும் int மாறிகளில் இன்டிஜர் மதிப்பையும் இருத்தி வைத்து, கேரக்டராகவோ இன்டிஜராகவோ நம் விருப்பப்படி எடுத்தாள முடிந்தது. அடுத்து நம்முன் உள்ள கேள்வி, char மாறியில் இன்டிஜர் மதிப்பையும், int மாறியில் கேரக்டர் மதிப்பையும் இருத்தி வைத்துக் கையாள முடியுமா என்பதுதான். அப்படியும் முடியும் என்பதை அடுத்த புரோகிராமில் காண்க:
/* Program No. */
/* ALPBETA1.C */
#include <stdio.h>
main()
{
      int alpha = ‘A’;
      char beta = 66;
      printf(“int alpha = %d\n”, alpha);
      printf(“char alpha = %c\n”, alpha);
      printf(“int beta = %d\n”, beta);
      printf(“char beta = %c”, beta);
}
இந்தப் புரோகிராமின் வெளியீடு இவ்வாறு இருக்கும்:
int alpha = 65
char alpha = A
int beta = 66
char beta = B
இதிலும் உட்கிடை இனமாற்றங்களை இடம், பொருள், ஏவல் கருதிக் கம்ப்பைலர் உட்கிடை இனமாற்றங்களைச் செய்து முடிக்கிறது. char, int இனங்களுக்கு இடையே நடைபெறும் உட்கிடை இனமாற்றத்தின் உச்சத்துக்கு இன்னோர் எடுத்துக்காட்டைப் பாருங்கள்:
/* Program No */
/* ALPHBETA.C */
#include <stdio.h>
main()
{
      const char alpha = ‘A’, beta = ‘B’;
      int sum = alpha + beta;
      int product = alpha * beta;
      printf(“alpha = %c\n”, alpha);
      printf(“beta = %c\n”, beta);
      printf(“alpha + beta = %d\n”, sum);
      printf(“alpha * beta = %d”, product);
}
இந்தப் புரோகிராமின் வெளியீடு இவ்வாறு அமையும்:
alpha = A
beta = B
alpha + beta = 131
alpha * beta = 4290
கேரக்டர் இன மாறிகளை எண்களைப் போலக் கூட்டவும் பெருக்கவும் முடிகிறது. காரணம் உட்கிடை இனமாற்றம் என்னும் சிறப்புக் கூறே ஆகும். இங்கே உட்கிடை இனமாற்றம் நிகழ்த்தப்பட வேண்டும் என்பதைக் கணக்கீட்டுச் செயற்குறிகள் கம்ப்பைலருக்கு உணர்த்துகின்றன. எனவே மேற்கண்ட கணக்கீடுகள் சாத்தியமாகின்றன. உட்கிடை இனமாற்றத்தின் காரணமாய், எவ்வித ஃபங்ஷன்களின் துணையும் இல்லாமலேயே, ஓர் int மதிப்பை கேரக்டராகவும், ஒரு char மதிப்பை இன்டிஜராகவும் கையாள முடியும் என்பது சி-மொழியின் சிறப்புக் கூறாகும். இதன் காரணமாகவே ’சி-மொழி இன உணர்வு (type sensitive) அற்ற மொழி’ என்ற பழிச்சொல்லுக்கும் ஆளாகிறது.
இன்னொரு முக்கியமான விவரத்தை நீங்கள் மனதில் வைத்துக் கொள்ள வேண்டும். தரவினப் பாடத்தில் (பாடம்-5) கொடுக்கப்பட்டுள்ள அட்டவணையைக் கவனியுங்கள். char இனம் என்று அறிவிக்கப்படுகிற மாறி (variable) -128 லிருந்து +127 வரையுள்ள மதிப்புகளைத்தான் ஏற்றுக் கொள்ளும். நாம் மேலே பார்த்த புரோகிராம்களில் char என்று அறிவிக்கப்பட்டுள்ள மாறிகள் signed char வகையைச் சார்ந்தவைதான். டர்போ-சி-யைப் பொறுத்தவரை வெறுமனே char என்று குறிப்பிட்டால் signed char என்றே எடுத்துக் கொள்ளப்படும். ஆனால் char இன மாறியின் மதிப்பை 0 லிருந்து 255 வரை கையாள வேண்டும் என எண்ணினால் அந்த மாறியை unsigned char என்று அறிவிக்க வேண்டும்.
பொதுவாக, சி-மொழிப் புரோகிராமர்கள் தங்கள் புரோகிராம்களில் 0 முதல் 255-க்குள் பாஸிட்டிவ் இன்டிஜர் மதிப்புகளை மட்டுமே ஏற்கும் மாறிகளை unsigned char என்றே அறிவிப்பர். எடுத்துக்காட்டாக day, month போன்ற விவரங்களைக் கையாள, int இனத்தைவிட unsigned char இனமே மிகவும் பொறுத்தமானதாகும். காரணம் அவை முறையே 1 முதல் 31 வரை, 1 முதல் 12 வரை மதிப்புகளையே ஏற்கின்றன.
 வெளிப்படை இனமாற்றம் (Explicit Type Conversion)
மேற்கண்ட TYPECAS2.C புரோகிராமில் b என்ற மாறியை float-ஆக மாற்றியுள்ளோம். இவ்வாறு மாற்றாமல், a, b இரண்டையும் int ஆகவே வைத்துக் கொண்டு, விடையை மட்டும் float-ல் பெறவும் வழியுண்டு.
/* Program No. */
/* TYPECAS3.C */
#include <stdio.h>
main()
{
      int a=10, b = 4;
      float c;
      c = (float)a / b;
      printf("a = %d, b = %d, c = %3.1f", a, b, c);
}
இந்தப் புரோகிராமை இயக்கிப் பார்த்தால்,
a = 10, b = 4, c = 2.5
என்று விடையாகக் கிடைக்கும். இதில் a, b இரண்டும் int இனத்தைச் சார்ந்தவைதாம். c-யின் மதிப்பைக் கணக்கிடும்போது மட்டும் a என்ற மாறியைத் தற்காலிகமாக float என்று கருதிக் கொள்ளுமாறு வெளிப்படையாக (Explicitly) கட்டளை அமைத்துள்ளோம். a, float-ஆக இருப்பதால் b-யும் தாமாகவே float-ஆக மாற்றப்பட்டுவிடும். எனவே விடையும் float-ல் கிடைத்துவிடும். இவ்வாறு புரோகிராமர் தலையிட்டு வெளிப்படையாக இனமாற்றம் செய்யும் செயல்முறை இனமாற்றுகை(Typecasting) எனப்படுகிறது.
சில வேளைகளில் ஒரு float இன மதிப்பில் முழு எண் பகுதி (Integer portion) மட்டும் தேவைப்படுகிறது எனில், அதற்கும் வழியுள்ளது. கீழேயுள்ள புரோகிராமைக் கவனியுங்கள்:
/* Program No. */
/* TYPECAS4.C */
#include <stdio.h>
main()
{
      float x = 5.84;
      printf("\nValue of x : %4.2f", x);
      printf("\nInteger Portion: %d", (int)x);
}
இந்தப் புரோகிராமின் விடை 5 என்று காண்பிக்கும். இவ்வாறு ஒரு float மதிப்பில் உள்ள int மதிப்பை மட்டும் எடுத்தாள நமக்கு இனமாற்றம் (Type Casting) வழி வகுக்கிறது.
 Type Conversion Vs. Type Casting
Type Conversion, Type Casting இரண்டும் ஒன்றா? வேறு வேறா? வேறுபட்டவை எனில் இரண்டையும் வேறுபடுத்திக் காட்டுக. இவ்வாறெல்லாம் நேர்முகத் தேர்வுகளில் கேள்வி கேட்கப்படுவதுண்டு. இதற்குப் பதில் என்ன?
இரண்டும் சொல்தொடர்களுக்கும் வெவ்வேறு பொருள் என்பதில் ஐயமில்லை. ஆனால் கம்ப்யூட்டர் மொழிகளில் அதனை எவ்வாறு வேறுபடுத்திக் காட்டுவது என்பதில்தான் ஐயம் எழுகிறது. சில ஆசிரியர்கள் உட்கிடை இனமாற்றத்தை Type Conversion என்றும், வெளிப்படை இனமாற்றத்தை Type Casting என்றும் மிக எளிதாக விளக்கம் அளிக்கின்றனர். வேறுசில ஆசிரியர்கள் Type Casting என்பது காரணம் (cause), Type Conversion என்பது விளைவு (effect) எனவும் விளக்கம் அளிக்கின்றனர். இந்த இரண்டு வகையான விளக்கங்கங்களுள் மிகச் சரியானது எது?
ஆங்கிலச் சொற்களுக்கான நேரடியான பொருள் எதுவாக இருந்த போதிலும், கம்ப்யூட்டர் மொழிகளில் புரோகிராமர் வெளிப்படையாக இனமாற்றம் செய்யும் செயல்பாட்டையே Typecasting என்னும் சொல்லால் குறிப்பிடுகின்றனர். அச்செயல்பாட்டின் மூலம் Type Conversion என்னும் நிகழ்வு நிகழ்த்தப்படுகிறது. உட்கிடை இனமாற்றம், வெளிப்படை இனமாற்றம் இரண்டிலுமே இனமாற்றம் (Type Conversion) நிகழ்கிறது. முதலாவதில் இனமாற்றத்தைக் கம்ப்பைலர் நிகழ்த்துகிறது. இரண்டாவதில் புரோகிராமர் நிகழ்த்துகிறார். புரோகிராமர் நிகழ்த்தும் இனமாற்றமே (Type Coversion) Typecasting எனப்படுகிறது. எனவே மேற்கண்ட இரண்டு வகையான விளக்கங்களுள் இரண்டாவது விளக்கமே சரியானவை எனலாம்.
Type Conversion, Type Casting ஆகியவற்றுக்கு இணையாக நாம் பயன்படுத்தும் இனமாற்றம், இனமாற்றுகை என்னும் இரண்டு தமிழ்ச் சொற்களும் தாமாகவே இரண்டுக்கும் இடையேயான வேறுபாட்டை விளக்கி நிற்கின்றன.
[பாடம்-8 முற்றும்]

tholil ulagam தொழில் at

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)