ఫలితాన్ని రాబట్టే పదాలివే..!

'సీ' లాంగ్వేజ్‌లో కీ బోర్డు నుంచి సంకేతాలను తీసుకొని, వాటితో కాలిక్యులేషన్స్ చేసి, ఫలితాలను స్క్రీన్‌పై display చేసే ప్రోగ్రామింగ్ చాలా ముఖ్యమైంది. ఈ ప్రోగ్రాం రాయడానికి నాలుగు ముఖ్యమైన విషయాలను గుర్తుంచుకోవాలి అవి:
a) Variable declaration
b) Data reading
c) Calculations
d) Printing Results
1) Variables declare చేయడం
ప్రోగ్రాం రన్ అవుతున్నప్పుడు RAMను కంప్యూటరు వాడుకుంటుంది. మనం ప్రోగ్రాం రాసేటప్పుడు ఇచ్చిన సంఖ్యలతోపాటు కాలిక్యులేట్ చేయగా వచ్చిన సంఖ్యలను కూడా నిక్షిప్తం (Store) చేయాల్సి ఉంటుంది. వీటికి మెమరీ కేటాయించడానికి (allocate) variables declare చేస్తాం. ఉదాహరణకు, గణితంలో మనం కనుక్కోవాల్సిన దాన్ని x అనుకొని సాధిస్తాం. ఇక్కడ xని variable అంటాం. అలాగే programmingలో కూడా variablesను వాడతాం. ఇలా variablesని declare చేయడం అనేది అన్ని programing లాంగ్వేజీల్లోనూ కీలకమైన అంశం.

సీ లాంగ్వేజీలో తీసుకునే variable namesలో Upper case, Lower case, 0 - 9, Underscore (_) అక్షరాలను మాత్రమే వాడతాం. ఈ విషయంలో ఒక్కో programming లాంగ్వేజీకి ఒక్కోవిధంగా నియమాలు ఉంటాయి. సీ లాంగ్వేజీలో తీసుకునే variableలో మొదటి అక్షరం Upper Case, Lower Case, Underscoreలలో ఏదో ఒకదాన్ని మాత్రమే ఉపయోగించాలి.
అంతేకాకుండా మనం తీసుకునే variable names, C లాంగ్వేజీలో ఉండే reserved words కాకూడదు. ఉదాహరణకు ప్రోగ్రాంలో తీసుకునే variable పేరు Main, include లుగా ఉండకూడదు. అంతేకాకుండా ఈ variable ను ఒక్కసారి మాత్రమే declare చేయాలి (ఒకసారి డిక్లేర్ చేసిన variableని ప్రోగ్రాంలో ఎన్నిసార్లయినా వాడుకోవచ్చు). అన్ని variablesనూ, block designingలో మాత్రమే declare చేయాలి. అంటే, Opening Curly braces ({) తర్వాత మాత్రమే declare చేయాలి.
ఉదాహరణ: ప్రోగ్రాంలో వాడాల్సిన Variable Names Salary, Profit, My_salary, Total_Income
ప్రోగ్రాంలో వాడకూడని variable Names
Rama.rao (full stop ఉండకూడదు)
my-salary (minus ఉండకూడదు)
Int (reserved variable):
చాలా సీ లాంగ్వేజ్ కంపైలర్లలో, తీసుకొనే variable పేరు పదకొండు (11) అక్షరాల కంటే ఎక్కువగా ఉండకూడదు. కానీ ఇటీవల వస్తున్న సీ కంపైలర్లు పెద్ద variable పేర్లను కూడా support చేస్తున్నాయి. ఒక variableను డిక్లేర్ చేసినప్పుడు అందులో ఎలాంటి సంఖ్యలను నిక్షిప్తం చేయాలనుకుంటున్నామో కూడా తెలపాలి. దీన్నే variableకు typeను ఇవ్వడం అంటాం. ఏదైనా variableలో పూర్ణ సంఖ్యలను store చేయాలంటే int type అని, పెద్ద పూర్ణ సంఖ్యలను store చేయాలంటే float type అని డిక్లేర్ చేయాలి. అలా కాకుండా వాస్తవ సంఖ్యలను (రియల్ నెంబర్స్) స్టోర్ చేయాలంటే float type అని డిక్లేర్ చేయాలి. సాధారణంగా float type అని రాస్తే కాలిక్యులేషన్‌లో 6th decimal వరకూ ఉపయోగించుకోగలుగుతాం. ఇంకా accurateగా కావాలంటే, variableను double type అని డిక్లేర్ చేయాలి. ఈ సందర్భంలో కాలిక్యులేషన్స్ పదకొండు డెసిమల్ స్థానాల వరకూ వస్తాయి. ఒకవేళ variableలో అక్షరాలను store చేయాలంటే, ఆ variableను character type అని declare చేయాలి.
ప్రోగ్రాంలో memory allocate చేయాలంటే రెండు విషయాలు గుర్తుంచుకోవాలి.
a. variable name
b. variable type
ఉదాహరణ: ముగ్గురు విద్యార్థులు పదోతరగతిలో సాధించిన మార్కులను నిక్షిప్తం చేయాలంటే మూడు variablesను int typeగా డిక్లేర్ చేయాలి. ఎందుకంటే మార్కులు పూర్ణ సంఖ్యలు.
ఈ మూడు variablesను కిందివిధంగా డిక్లేర్ చేయాలి.
int a, b, c;
ఈ statementను variable declaration statement అని అంటారు. లైన్ చివరన ';' (సెమీకొలన్)ను ఉంచడాన్ని మరిచిపోవద్దు.
సీ లాంగ్వేజ్‌లో ప్రతి Executable Statement (మెషిన్ లాంగ్వేజ్‌లోకి translate అయ్యేది)కు చివరన ';' (సెమీకొలన్) ఉండాలి. కంప్యూటరు పైన చెప్పిన statements ని చూసినప్పుడు, మూడు పూర్ణ సంఖ్యలను store (నిక్షిప్తం) చేయడానికి ఎంత మెమరీ కావాలో అంతే కేటాయిస్తుంది.
అదేవిధంగా ఒక గది పొడవు, వెడల్పు, ఎత్తును నిక్షిప్తం చేయాలంటే మూడు float type variables అవసరం. ఎందుకంటే, ఈ కొలతలు ఎప్పుడూ పూర్ణ సంఖ్యలుగా ఉండకపోవచ్చు. float type variablesను, కిందివిధంగా రాస్తాం.
float L, B, H;
or
float Length, Breadth, Height;
or
Float My_Room_Length, My_Room_Breadth, My_Room_Height;
ఏ type variableకు ఎంత మెమరీ allocate అవుతుందో తెలుసుకుందాం.
* Char 1 byte
* int 2 or 4 bytes
* long 4 bytes
* float 4 bytes
* double 8 bytes
ఒకసారి మొమరీ కేటాయించిన తర్వాత, ఆ variable memoryలో ఏముంటుందన్న విషయాన్ని ఎవరూ చెప్పలేరు. మొమరీ కేటాయించిన variablesను Un-initialised variables అంటారు. వాటి valuesను garbage values అంటారు. లేదా God Only Knows Values అని కూడా అంటారు.
Un-initialised variablesను కాలిక్యులేషన్‌లలో ఎప్పుడూ వాడకూడదు. ఒకవేళ వాడినా ఫలితం garbage గానే వస్తుంది. ఒక Variableలోకి meanigful value రీడింగ్ ద్వారా రావచ్చు, direct assignment (int a = 10;) ద్వారా రావచ్చు లేదా కాలిక్యులేషన్స్ ద్వారా రావచ్చు. మనం un-intialised variableను కాలిక్యులేషన్స్‌లో వాడితే, java లాంటి modern languages (5th generation languages)లో errors వస్తాయి. కానీ 'సీ'లో ఇలా రావు. అందువల్లే Javaను strongly typed language అని 'సీ'ని weakly typed language అని అంటారు.
2) డేటా Read చేయడం
డేటా రీడ్ చేసిన తర్వాత వాటిని నిక్షిప్తం చేయడానికి ముందే varaibleను declare చేయడం ద్వారా వాటికి మెమరీ కేటాయిస్తాం. ఇప్పుడు ఆ మెమరీలోకి కీబోర్డు ద్వారా data values ఎలా రీడ్ చేయాలో తెలుసుకుందాం. దీని కోసం scanf అనే ready made function ను (printf లా) ఉపయోగించాలి. దీన్ని వాడుకోవాలంటే, ముందుగా #include అనే statement ను programలో రాయాలి. ప్రోగ్రాం రాసేటప్పుడ scanf functionకు రెండు విషయాలు డిక్లేర్ చేయాలి. అవి:
a. కీ బోర్డు నుంచి ఎన్ని values, ఎలాంటి values రీడ్ చేయాలి. ఈ విషయాన్ని చెప్పడానికి, format string ను ఉపయోగిస్తాం.
ఉదాహరణ: కీబోర్డు నుంచి మూడు పూర్ణసంఖ్యలను రీడ్ చేయమని చెప్పడానికి, మనం ''%d%d%d" ను scanfకు మొదటి argument గా ఇస్తాం. అదే నాలుగు పూర్ణ సంఖ్యలు, రెండు వాస్తవ సంఖ్యలను రీడ్ చేయమని చెప్పడానికి "%d%d%d%d%f%f" అని రాస్తాం. ఇక్కడ %d అంటే పూర్ణసంఖ్య అని, %f అంటే వాస్తవ సంఖ్య అని Scanf అర్థం చేసుకుంటుంది. అలాగే, %ld, %df, %c లను long, double, character type లకు ఉపయోగిస్తాం.
b. రీడ్ చేసిన విలువలను RAM లో ఎక్కడ పెట్టాలో కూడా scanfకు మనం చెప్పాలి. అంటే RAM address లను ప్రోగ్రాంలో ఇవ్వాలి. C లాంగ్వేజ్‌లో ఒక variableకు ముందు ampersand (&) symbol పెడితే, ఆ variableకు కేటాయించిన RAM memory cell number (or) addressను తెలియజేస్తుంది.
ప్రోగ్రాంలో కేటాయించిన memory cell numbersను మాత్రమే scanf లో గానీ, ఇంకా ఎక్కడకైనా గానీ వాడాలి. అలా కాకుండా వేరే అంకెలను వాడితే Program run అవుతున్నప్పుడు, run-time error (bug) వస్తుంది.
ఉదాహరణ: scanf మూడు పూర్ణ సంఖ్యలను రీడ్ చేసి a, b, c అనే మూడు variables లో పెట్టమని చెప్పడానికి వాటి addressలను ఇవ్వాలి. ఉత్తరంపై ఎవరి చిరునామా రాస్తే వారికే వెళుతుంది. ఇక్కడ కూడా అదే నియమం వర్తిస్తుంది. scanf statement మూడు integersను కీబోర్డు నుంచి రీడ్ చేసి, a, b, c అనే variablesలో పెట్టడానికి కిందివిధంగా రాస్తాం.
scanf ("%d%d%d" &a, &b, &c);
అదేవిధంగా amount, rate, time అనే variablesలోకి మూడు float valuesను రీడ్ చేయడానికి
Scanf ("%f%f%f", &amount, &rate , &time); అని రాస్తాం.
3) Calculations చేయడం
రీడ్ చేసిన values తో ఏం కాలిక్యులేట్ చేయాలనేది మన అవసరంపై ఆధారపడి ఉంటుంది. ఏ Operators ఉపయోగించాలి? వాటి అర్థాలేమిటి? తదితర అంశాల గురించి తర్వాతి పాఠ్యాంశాల్లో తెలుసుకుందాం.
4) Results Print చేయడం
ప్రోగ్రాం పూర్తయిన తర్వాత కాలిక్యులేట్ చేసిన ఫలితాన్ని program screen పై Print చేసుకోవచ్చు. Program కరెక్ట్‌గా ఉందా లేదా అనేది Print చేయడం ద్వారానే తెలుస్తుంది. ఉదాహరణకు రేపు పరీక్ష ఉందనుకోండి. ఈ రోజు రాత్రి మనం బాగా చదివాం. అదృష్టం కొద్దీ చదివిన ప్రశ్నలే వచ్చాయి. జవాబులు తెలిసినా సమాధానపత్రంలో రాయలేదు. అప్పుడు మనకు ఎన్ని మార్కులు వస్తాయి?
సున్నా.
ఎందువల్ల?
మనం రాయలేదు కాబట్టి.
అప్పుడు మీరు నాకు జవాబు తెలుసు కదా.. అయినా మార్కులు ఎందుకు వేయలేదు అనుకుంటే కుదరదు. మీకు సమాధానం తెలుసని మూల్యాంకనం చేసేవారికి మీరు రాస్తేనే కదా తెలిసేది. అదేవిధంగా Program కూడా మనం అడిగితేనే, ఫలితాలను screenపై Print చేస్తుంది. ప్రోగ్రాంకు సంబంధించిన సమాధానాలు RAMలో ఉంటాయి. కానీ మనం అడిగితేనే screen పై Print చేస్తుంది. కాబట్టి తెరపై Print చేయడానికి ఉపయోగించే Printing statements కు ప్రాధాన్యం ఉంది.
ప్రోగ్రాం ఔట్‌పుట్‌లో variable valuesను Print చేయాలంటే scanf లా format string ఇవ్వాలి. దీని కోసం variables పేర్లను రాస్తే సరిపోతుంది. వాటి address లను ఇవ్వాల్సిన అవసరం లేదు. ఇది print function requirement (దీన్ని అభివృద్ధి చేసినవారు, అలా రూపొందించారు.)
ఉదాహరణ:
* a, b, c అనే మూడు integer variables విలువలను తెరపై print చేయడానికి కింది printf statementలను ఉపయోగించాలి.
printf("%d %d %d\n", a, b, c);
* విలువలకు మధ్యలో tabకావాలంటే, ఏ '\t' format stringతో కింద చూపినవిధంగా వాడవచ్చు.
printf("%d\t %d\t %d\n", a, b, c);
* ఇలా కాకుండా, మూడు variable values తెరపై ఒక్కోలైన్‌లో రావాలంటే
printf("%d\n %d\n %d\n", a, b, c);
* format stringలో messageలు కూడా రాసుకోవచ్చు.తెరపై "a, b, c values are =" values అని రావాలంటే, printf ను ఇలా రాయాలి.
printf("a, b, c values are = %d, %d, %d\n", a, b, c);
* అదేవిధంగా a, b ల విలువలను print చేయడానికి
printf("a = %d, b = %d, c = %d\n", a, b, c); అని రాయాలి.
మొదటి %d దగ్గర a విలువ, రెండో %d దగ్గర b విలువ print అవుతాయి. ఉదాహరణకు a, b, c విలువలు 10, 20, 30 అనుకుంటే, తెరపై కిందివిధంగా ఫలితం వస్తుంది.
a = 10, b = 20, c = 30
ఈవిధంగా printfను వాడుకొని screenపై ఫలితాలను print చేసుకోవచ్చు.

ఇప్పటి వరకూ మనం నేర్చుకున్న అంశాల ఆధారంగా ఒక ప్రోగ్రాం రాసే విధానాన్ని పరిశీలిద్దాం.
a) ఎన్ని values read చేయాలి? ఏం కాలిక్యులేట్ చేయాలి? అనే అంశాల ఆధారంగా ముందుగా variablesను డిక్లేర్ చేయాలి.
b) scanfను ఉపయోగించి డేటా read చేయడం.
c) ఇచ్చిన ప్రోగ్రాం కోడ్ ఆధారంగా రీడ్ చేసి వాటితో కాలిక్యులేషన్స్ చేయాలి.
d) కాలిక్యులేట్ చేసినవాటిని screenపై రాయమని printf ద్వారా చెప్పాలి.
పైన చెప్పిన స్టేట్‌మెంట్లతోపాటు ప్రోగ్రామర్‌కు కొన్ని సూచనలు చేయడానికి instructionsను వాడతాం. వీటిని user interface statements అంటారు. ఇవి లేకపోయినా program పని చేస్తుంది. కానీ ఒకరు రాసిన ప్రోగ్రాం మరొకరు పరిశీలించినా అర్థమవడానికి ఇవి ఉపయోగపడతాయి.
ఉదాహరణ: మూడు పూర్ణసంఖ్యలను (Integer Values)కీబోర్డు నుంచి enter చేయమని చెప్పడానికి scanf statement ముందు కింది స్టేట్‌మెంట్‌ని రాస్తాం.
printf("Enter three integer values\n");
ఇలాంటివాటినే user interface statements అంటారు.
ఇప్పుడు మనం ఒక చిన్న ప్రోగ్రాం రాద్దాం. ముగ్గురు విద్యార్థుల మార్కులను కీబోర్డు నుంచి read చేసి వాళ్ల మార్కుల సరాసరిని తెరపై print చేయాలనుకుందాం.
i) దీని కోసం మూడు int type variables తోపాటు ముగ్గురి మార్కులను నిక్షిప్తం చేయడానికి ఒక float variable కావాలి. ఎందుకంటే సరాసరి ఎప్పుడూ పూర్ణ సంఖ్యగా ఉంటుందని చెప్పలేం. మొత్తం మీద నాలుగుvariables అవసరం.
ii) Enter three students marks అని User Interface statement రాయాలి.
iii) scanfకు ముందు integersను కీబోర్డు నుంచి రీడ్ చేసి variablesలో నిక్షిప్తం చేయమని చెప్పాలి. ఒకవేళ నాలుగు variables కు value చేస్తే ఎలా ఉంటుంది? ప్రశ్నతోపాటు సమాధానం ఇచ్చినట్లు ఉంటుంది. సరాసరిని మనం కాలిక్యులేట్ చేయాలి. ఏ మూడు మార్కులు ఇచ్చినా, మనకు వాటి సరాసరి కావాలి.
iv) మనం ఇచ్చిన మూడు విలువల సరాసరిని కాలిక్యులేట్ చేయమని చెప్పే statement రాయాలి.
v) calculate చేసిన సరాసరిని screenపై ప్రింట్ చేయమని చెప్పాలి.

ఈ సూచనలను పాటిస్తూ రాసిన ప్రోగాం, దాని output కింద చూపిన విధంగా ఉంటుంది..
Program run అవుతున్నప్పుడు విలువల మధ్యలో space, TAB, new line లలో ఏదో ఒకటి ఇవ్వాలి. ఇక్కడ ఇచ్చిన Programలో మూడు printf statementలను చివరలో ఉపయోగించాం. మనకు screenపై ఏవిధమైన ఫలితం కావాలో, ఆవిధంగా printfను ఉపయోగించవచ్చు. అంతేగానీ మూడూ ఒకేసారి ఉపయోగించాల్సిన అవసరం లేదు.