Article

EDP

C & DS

Engg.Chemistry

Engg.Physics



Character Variables అంటే ఏమిటి?
ముందు chapterలలో ఇప్పటివరకు మనం calculationsలలో int, float, long, double అనే variablesను ఉపయోగించడం తెలుసుకున్నాం. ఒక్కోసారి మనం మనుషుల పేర్లను, చిరునామాలను, బ్లడ్ గ్రూపులను, studentల గ్రేడ్ లను, మనుషుల DNAలను ప్రోసెస్ చేయాల్సి వస్తుoది. అప్పుడు character variables అనే వాటిని వాడాల్సి ఉంటుంది. ఒక integer variable లోకి 12 అయినా 33321 అయినా, మరేదయినా integer నంబరును store చేయవచ్చు. అలాగే, ఒక float variable లోకి 1.2223 అయినా 322.122 అయినా, మరేదయినా float నంబరును store చేయవచ్చు. అలాగే, ఒక character variable లోకి ఈ కింద ఇచ్చిన ASCII table 1 లోని ఒక symbolను మాత్రమే స్టోర్ చేయవచ్చు. ఈ కింద ఇచ్చిన table 1. లో, C లాంగ్వేజీలో వాడగలిగిన symbols వాటి decimal, Hex, Octal values ఉన్నాయి. వీటి గురించి మరింతగా తర్వాత తెలుసుకుందాం. C లాంగ్వేజీలో ఒక character variableకు ఒక byte allocate అవుతుంది.



Table 1: ASCII Table

ఒక integer variableకు ఒక integer value(constant)ను ఇస్తే ఆ integer value(constant) కి సంబంధించిన binary code ఆ variableకు allocate చేసిన memory లో స్టోర్ అవుతుంది. ఉదాహరణకు, int x=109 లో 109 కి సంబంధిచిన binary code(01101101), xకు allocate చేసిన memory లో స్టోర్ అవుతుంది. ఇది float variablesకు కూడా వర్తిస్తుంది. అలాగే, ఒక character variableకు ఒక symbol assign చేస్తే, దాని ASCII code ( unique code ) ఆ variableకు allocate చేసిన memoryలో స్టోర్ అవుతుంది. దీనిని మనం మార్చలేం. ఏ రెండు symbolsకూ ఒకే ASCII code ఉండదు.

మామూలుగా, 1278 లాంటి వాటిని integer constants అని, 12.333 లాంటి వాటిని float constants అని అంటారు. అలాగే, ఏ symbol అయినా single quotes మధ్యలో ఉంటే (ఉదాహరణకు ‘A’,’X’, ‘9’, ‘\n’), దానిని character constant అని అంటారు. ఉదాహరణకు, ఈ statementను గమనించండి.

char v=’A’;

ఇక్కడ A అనే symbol(character constant)ను, v అనే character variableకు assign చేస్తున్నాం. ఇప్పుడు, v value ఏమిటి అoటే symbol A లేక symbol capital A అని చెబుతాం. అప్పుడు ఆ symbol ASCII code, v అనే variable memoryలో స్టోర్ అవుతుంది. అంటే, 01000001(అంటే డెసిమల్ 65) అనే binary నంబరు v variable memory లో స్టోర్ అవుతుంది. దీనినే, symbol A ASCII code 65 అని కూడా చెప్పవచ్చు. అలాగే, capital letters (A-Z) ASCII codes: 65-90, lower case letters ASCII codes: 97-122, digits 0-9 ASCII codes 48-57. అన్ని కంప్యూటర్లూ ఇలాగే తీసుకుంటాయి. కాబట్టి ఏ కంప్యూటరులో type చేసినా, మనం ఏ కంప్యూటరులో చూసినా ఒకే రకంగా ఉంటాయి. దీనినే ASCII compatibility అని అంటారు.

ఇంతకు ముందే ఒక character variableకు ఒక symbol ఇవ్వవచ్చు అని తెలుసుకున్నాం. ఇది 0-9కు కూడా వర్తిస్తుంది. ఇవి కూడా అక్షరాలే కదా? అంటే, char v=’2’; అనే దానిలో digit 2ను v అనే variableకు ఇస్తున్నామని అర్ధం. అప్పుడు, 2 ASCII code (00110010), v variable memory లో స్టోర్ అవుతుంది. అంటే symbol 2 ASCII code 00110010. ఇక్కడ మనకు కొద్దిగా confusion వస్తుంది. Integer 2, digit 2 లేక symbol 2కు మధ్య వ్యత్యాసం ఏమిటి అని?. కంప్యూటరులో వీటికి వ్యత్యాసం ఉంది. కింద ఇచ్చిన table 2 ఈ వ్యత్యాసాన్ని విశదీకరిస్తుoది. Integer ఇస్తే కంప్యూటరులో ఎలా స్టోర్ అవుతుంది, digit ఇస్తే ఏం స్టోర్ అవుతుందో యీ table 2 ద్వారా తెలుసుకోవచ్చు.


Table 2 Difference between integers 0-9 and character 0-9 or digit 0-9.

C ప్రొగ్రాంలోని arithmetic expressionsలో, character variables, character constantsను వాడితే, వాటి ASCII codesను ఉపయోగించి expressionsను evaluate చేస్తుంది. ఒక విధంగా character variables, character constantsను integers తో సమాంగా అనుకుంటాం. కొన్ని సార్లు దాని స్థానం లో దీన్ని, దీని స్థానం లో దాన్ని ఉపయోగించడం సహజం. ఈ కింద ఇచ్చిన ప్రోగ్రాం దీన్ని explain చేస్తుంది.

Example 1: ఈ ప్రోగ్రాంలో రెండు variablesను వాడాం, అందులో ఒకటి character, ఇంకొకటి integer type. వాటికి కొన్ని valuesను assign చేసి వాటిని %c, %d formatలను వాడి print చేయించాం. అంటే, ఈ ప్రోగ్రాం character స్థానం లో integerను , integer స్థానంలో characterను వాడవచ్చు అని తెలుసుకోవచ్చు.

#include<stdio.h>
int main()
{
     char v=’A’;
     int p=65;
     printf(“%c%d\n”, v,v);
     printf(“%c%d\n”, p,p);
     return (0);
}

పై ప్రోగ్రాంను రన్ చేసినప్పుడు స్క్రీన్ ఇలా ఉంటుంది.

Example 2: Capital letterను input గా తీసుకొని దానికి సమానమైన lower case letterను ఇవ్వడానికి ప్రోగ్రాం.
Solution: ASCII code table నుoచి మనం ఒక విషయాన్ని గ్రహించవచ్చు. అదేమిటి అంటే, capital అక్షరాల, lower case అక్షరాల ASCII codeల మధ్య భేధం 32. కాబట్టి తీసుకున్నcapital అక్షరానికి 32 కలిపితే దానికి సమానమైన lower case అక్షరం వస్తుంది. అలాగే lower case అక్షరంలో నుంచి 32 తీసేస్తే దానికి సమానమైన upper case అక్షరం వస్తుంది. ఈ కింద ఇచ్చిన ప్రోగ్రాం దీన్ని వఉపయోగించుకొని పని చేస్తుంది.

#include<stdio.h>
int main()
{
     char v, p;
     printf(“Enter an upper case character\n”);
     scanf(“%c”, &v);
     p = v+32;
     printf(“%c%c\n”, v, p);
     return (0);
}

పై ప్రోగ్రాంను రన్ చేసినప్పుడు స్క్రీన్ ఇలా ఉంటుంది.

Example 3: ఒక digit ను ఒక character variable లోకి రీడ్ చేసి దాని విలువను 17తో multiply చేసి వచ్చిన వాల్యూను ప్రింట్ చేయడానికి ప్రోగ్రాం.
Solution: Table 2ను చూస్తే మనకు ఒక విషయం తెలుస్తుంది. Digits ASCII code విలువలు 48 నుంచి 57 వరకు ఉన్నాయి. ఈ విలువల నుంచి 48 తీసేస్తే, మనకు 0-9 వస్తాయి. అంటే, ఒక digit ASCII code లో నుంచి digit value కావాలంటే 48 తీసేయాలి. ఈ కింద ఇచ్చిన ప్రోగ్రాం దీన్ని ఉపయోగించుకొని పని చేస్తుంది. ఇందులో 48 తీయకుండా చేస్తే ఏమవుతుందో కూడా ఒక variable (p) ద్వారా చూపించాం. మనకు రావాల్సిన వాల్యూ q లో ఉంటుంది.

#include<stdio.h>
int main()
{
     char v; int p, q;
     printf(“Enter a digit (0-9)\n”);
     scanf(“%c”, &v);
     p = 17*v;
     q = 17*(v-48);
     printf(“%c %d %d\n”, v, p, q);
     return (0);
}

పై ప్రోగ్రాం రన్ చేసినప్పుడు స్క్రీన్ ఈ విధంగా ఉంటుంది.

Example 4: ఒక విద్యార్థి test marks (0-100) రీడ్ చేసి అతడి గ్రేడ్ ను print చేయడానికి ప్రోగ్రాం ఇది. ఎన్ని మార్కులు వస్తే ఏ గ్రేడ్ రావాలో ఈ కింది table చూపిస్తుంది.

Solution: ఇచ్చిన టేబుల్ ను చూస్తే మనకు ఒక విషయం తెలుస్తుంది. అదేమిటంటే, ప్రతి 20 మార్కులకు ఒక గ్రేడ్ మారుతుంది. కాబట్టి మనం ఇచ్చిన marks లో ఎన్ని 20లు ఉన్నాయో కనుక్కోని దానిని నాలుగు నుంచి తీసివేసి, symbol Aకు కలిపితే మనకు కావాల్సిన గ్రేడ్ వస్తుంది. కాని ఈ logic 100 ఇస్తే పని చేయదు. 100తో వేరే symbol answer లాగా వస్తుంది. దీనిని కరెక్ట్ చేయడానికి, marks 100 అయితే 1 లేకపోతే 0 వచ్చే విధంగా (m==100) అనే ఒక చిన్న logic అదనంగా ఈ కింది ప్రోగ్రాంలో ఉపయోగించాం.

#include<stdio.h>
int main()
{
     int m;
     char v;
     printf(“Enter a student mark (0-100)\n”);
     scanf(“%d”, &m);
     v = ’A’+ (4- m/20 )+( m==100 );
     printf(“Grade=%c\n”, v);
     return (0);
}

పై ప్రోగ్రాంను రన్ చేసినప్పుడు స్క్రీన్ ఇలా ఉంటుంది.

అదే ప్రోగ్రాంను ఈ విధంగా కూడా రాయవచ్చు. ఇక్కడ, ముందు ప్రోగ్రాంలో వాడిన v = ’A’+ (4- m/20 )+( m==100 )లో A బదులు 65 పెట్టి 4 ను బయటకు లాగి simplify చేస్తే వచ్చింది.

#include<stdio.h>
int main()
{
     int m;
     char v;
     printf(“Enter a student mark (0-100)\n”);
     scanf(“%d”, &m);
     v = 69-m/20+(m==100);
     printf(“Grade=%c\n”, v);
     return (0);
}

Example 5: ఒక విద్యార్థి test గ్రేడ్ రీడ్ చేసి అతడి గ్రేడ్ పాయింట్ ను print చేయడానికి ప్రోగ్రాం ఇది. ఏ గ్రేడ్ పాయింట్ వస్తే ఏ గ్రేడ్ ఇవ్వాలో ఈ కింది table చూపిస్తుంది.

Solution: ఇచ్చిన టేబుల్ ను చూస్తే మనకు ఒక విషయం తెలుస్తుంది. అదేమిటంటే, ప్రతి గ్రేడ్ changeకు 2 గ్రేడ్ పాయింట్ లు వస్తున్నాయి. మనం A గ్రేడ్ ( ASCII code, 65) ఇస్తే మనకు 10 రావాలి, మనం B (ASCII code, 66) గ్రేడ్ ఇస్తే మనకు 8 రావాలి. గమనిస్తే, మనం ఇచ్చిన గ్రేడ్ ను 70 లో నుంచి తీసివేసి, 2 తో హెచ్చవేస్తే, మనకు కావాల్సిన గ్రేడ్ పాయింట్ లు వస్తాయి. ఈ కింద ఇచ్చిన ప్రోగ్రాం దీన్ని ఉపయోగించి పని చేస్తుంది.

#include<stdio.h>
int main()
{
     char v;
     int p ;
     printf(“Enter a student grade in a test (A-E)\n”);
     scanf(“%c”, &v);
     p = 2*(70-v);
     printf(“Points=%d\n”, p);
     return (0);
}

పై ప్రోగ్రాంను రన్ చేసినప్పుడు స్క్రీన్ ఇలా ఉంటుంది.

Example 6: ఒక విద్యార్థి అయిదు టెస్టుల్లో గ్రేడ్ లను తీసుకొని అతడి గ్రేడ్ పాయింట్ యావరేజ్ ను ప్రింట్ చేయాలి. గ్రేడ్ పాయింట్ రూల్స్ ప్రీవియస్ Example లో ఇచ్చినవి తీసుకొవాలి. ఉదాహరణకు AABCA input లాగా ఇస్తే, రావాల్సిన యావరేజ్ (10+10+8+6+10)/5=8.8. అలాగే, ACCBD input లాగా ఇస్తే, యావరేజ్ (10+6+6+8+4)/5=34/5=7.8 రావాలి.
Solution: ఇoతకు ముందు ప్రోగ్రాంలో ఒక గ్రేడ్ తీసుకొని గ్రేడ్ పాయింట్ ప్రింట్ చేశాం. ఈ ప్రోగ్రాంలో అయిదు గ్రేడ్ లు తీసుకొని వాటి యావరేజ్ కావాలి కాబట్టి ఇంతకు ముందు ప్రోగ్రాంలో వాడిన logicను ప్రతి గ్రేడ్ మీద వాడి మొత్తం లెక్కగట్టి యావరేజ్ కనుక్కోవాలి. ఈ కింద ఇచ్చిన ప్రోగ్రాంలో ప్రతి టెస్ట్ లో గ్రేడ్ ను substitute చేసి simplify చేస్తే వచ్చిన expressionను వాడాం. ఉదాహరణకు AABCA input గా ఇస్తే, P=’A’, Q=’A’, R=’B’, S=’C’, T=’A’ అవుతాయి. అప్పుడు GPA = 2*(70-(P+Q+R+S+T)/5.0); expression GPA=2*(70-(65+65+66+67+65)/5.0)=6.8 అవుతుంది.

#include<stdio.h>
int main()
{
     char P, Q, R, S, T;
     float GPA;
     printf(“Enter a student grades in 5 tests\n”);
     scanf(“%c%c%c%c%c”, &P, &Q, &R, &S, &T);
     GPA = 2*(70-(P+Q+R+S+T)/5.0);
     printf(“Grade Point Average=%f\n”, GPA);
     return (0);
}

పై ప్రోగ్రాంను రన్ చేసినప్పుడు స్క్రీన్ ఈ విధంగా ఉంటుంది.

Example 7: ఒక విద్యార్థి కి సంబంధించి అయిదు టెస్టుల్లో గ్రేడ్ లను తీసుకొని అతడు పాస్ అయ్యాడా లేదా ఫెయిల్ అయ్యాడా చెప్పాలి. పాస్ అవ్వాలంటే గ్రేడ్ పాయింట్ యావరేజ్ 5 ఉoడాలి. అంతే కాకుండా ప్రతి టెస్టులో at least D గ్రేడ్ రావాలి. గ్రేడ్ పాయింట్ రూల్స్ ఇంతకు ముందు ఇచ్చిన ప్రోగ్రాం ప్రకారం తీసుకోవాలి.
Solution: ఇంతకు ముందు ప్రోగ్రాం చూస్తే ఇది చిన్న మార్పుతో ఉన్న ప్రోగ్రాం. ఇక్కడ కూడా గ్రేడ్ పాయింట్ యావరేజ్ కావాలి. ప్రతి టెస్టులో D గ్రేడ్ రావాలి అనే దానిని మనం ఇలా కూడా చెప్పవచ్ఛు కదా? ఏ టెస్టులో కూడా E గ్రేడ్ రాకూడదని?. కాబట్టి ఈ ప్రోగ్రాంలో ఎన్ని టెస్టుల్లో E గ్రేడ్ వచ్చిందో కనుక్కొని ఒక variable(np)లో స్టోర్ చేస్తాం. దీనిని, గ్రేడ్ పాయింట్ యావరేజ్ ను ఉపయోగించి పాస్ లేదా ఫెయిల్ చెబుతాం.

#include<stdio.h>
int main()
{
     char p, q, r, s, t;
     float gpa; int np;
     printf(“Enter a student graded in 5 test\n”);
     scanf(“%c%c%c%c%c”, &p, &q, &r, &s, &t);
     gpa = 2*(5-((p+q+r+s+t)/5.0-‘A’));
     np=(p==’E’)+(q==’E’)+(r==’E’)+(s==’E’)+ (t==’E’);
     /* This gives in how many of the tests candidate has got ‘E’ grades.*/

     ((np==0)*(gpa>=5))?printf(“Passed\n”): printf(“Failed \n”);
     return (0);
}

పై ప్రోగ్రాంను రన్ చేసినప్పుడు స్క్రీన్ ఈ విధంగా ఉంటుంది.

Example 8: Alphabetను రీడ్ చేసి అది upper case లేక lower case అని ప్రింట్ చేయాలి. దానికి సమానమైన వేరే case Alphabetను కూడా ప్రింట్ చేయాలి.
Solution: దీనిని రెండు విధాలుగా చేయవచ్చు. ఇచ్చిన Alphabet, A-Z మధ్యలో ఉందా లేదా అని చెక్ చేసి ఉండి ఉంటే upper అని లేకపొతే lower అని చెప్పవచ్చు. ఇంకోవిధంగా చెప్పాలంటే, ఇచ్చిన Alphabet, a-z మధ్యలో ఉందా అని చెక్ చేసి, ఉంటే lower అని లేకపొతే upper అని చెప్పడం. ఈ కింది ప్రోగ్రాంలో రెండూ ఉపయోగించాం. అలాగే, ఇంతకు ముందు చేసినట్లే, lowerను upper లోకి చేయడానికి 32 తీసేస్తాం, అలాగే upper ను lower లోకి చేయడానికి 32 కలుపుతాం.

#include<stdio.h>
int main()
{
     char v;
     printf(“Enter an alphabet\n”);
     scanf(“%c”, &v);
     ((v>=’A’)*(v<=’Z’))?printf(“Upper\n”):printf(“Lower\n”);
     ((v>=’a’)*(v<=’z’))?printf(“Lower\n”):printf(“Upper\n”);
     v=((v>=’A’)*(v<=’Z’))? v+32 : v-32;
     printf(“%c\n”, v);
     return (0);
}

పై ప్రోగ్రాంను రన్ చేసినప్పుడు స్క్రీన్ ఈ విధంగా ఉంటుంది.

Example 9: ఒక characterను రీడ్ చేసి vowel అయితే “YES” అని లేకపోతే “NO” అని ప్రింట్ చేయాలి.
Solution: ముందుగా ఇచ్చిన character లోయర్ అయితే దానిని అప్పర్ లోకి మార్చి, అ తర్వాత vowels (AEIOU లతో) పోలుస్తాం.

#include<stdio.h>
int main()
{
     char v;
     printf(“Enter an alphabet\n”);
     scanf(“%c”,&v);
     v = ((v>=’a’)*(v<=’z’))?v-32:v;
     ((v==’A’)+(v==’E’)+(v==’I’)+(v==’O’)+(v==’U’))?printf(“Yes\n”):printf(“No\n”);
     return (0);
}

పై ప్రోగ్రాంను రన్ చేసినప్పుడు స్క్రీన్ ఈ విధంగా ఉంటుంది.

ESCAPE Characters (OR) Special Characters

C లాంగ్వేజీలో ఈ కింద ఇచ్చిన వాటిని కూడా characters లాగా తీసుకుంటుంది. అంతే కాకుండా keyboard మీద ఉన్న ప్రతి అక్షరానికి ఒక character ఉంటుంది. కొన్ని మనం చూడలేం, కానీ వాటి effectను చూడవచ్చు. ఉదాహరణకు, Left Arrow, Right Arrow, Page Up, Page Down, అన్నీ కూడా system పాయింట్ లో ఒక character. వీటినన్నింటినీ ESCAPE Characters అని అంటారు.

     \n new line;
     \a beep;
     \f form feed;
     \t tab;
     \b backspace;

Example 10: ఈ ప్రోగ్రాం “Escape Characters” ఎలా ఉపయోగించాలో తెలియజేస్తుంది. ఈ ప్రోగ్రాం output కింద ఇచ్చినట్లు ఉంటుంది. అంతే కాకుండా బీప్ soundలు మూడు సార్లు మొదటి printf తో వస్తాయి.
A
A
A A
A
#include<stdio.h>
int main()
{
     char p=’A’, q=’\n’, r=’\t’, s=’\b’, t=’\a’;
     printf(“%c%c%c”, t, t, t);
     printf(“%c%c%c\n”, p, q, p);
     printf(“%c%c%c\n”, p, r, p);
     printf(“%c%c%c\n”, p, s, p);
     return (0);
}

పై ప్రోగ్రాంను రన్ చేసినప్పుడు స్క్రీన్ ఈ విధంగా ఉంటుంది.

Using Ready made functions

Characterలను ప్రోసెస్ చేయడానికి readymade functions కూడా ఉన్నాయి. ఉదాహరణకు, “isupper” అనే function ఒక characterను తీసుకొని అది upper case character అయితే 1 return చేస్తుంది, లేకపోతే 0 return చేస్తుంది. ఒక విషయం గుర్తుంచుకోవాలి మనం. function లోకి ఒక character పంపాలి అంటే అది character variable అయినా కావచ్చు, character constant అయినా కావచ్చు, character expression అయినా కావచ్చు. ఈ functionలను వాడాలంటే “Turbo C” లో <ctype.h> header ను మొదటలో include చేయాలి. అదే, Unix/Linux లో ఉన్న gcc compilerలో లేదా Dev C++/Codeblocks compilerలలో అయితే <stdlib.h> header ను మొదటలో include చేయాలి. కింద ఇచ్చిన టేబుల్ లో వాటిని ఎలా వాడాలో, అవి ఏం చేస్తాయో వివరంగా ఉంది.



Table 3: Character manipulation functions

Example 11: ఈ కింది ప్రోగ్రాం ఒక Characterను ఇన్ పుట్ లాగా తీసుకొని అది అప్పరా లేదా లోయరా అని ప్రింట్ చేసి దానిని వేరే case లోకి మార్చి ప్రింట్ చేస్తుంది. ఇదే ప్రోగ్రాం ఇంతకు ముందు కూడా రాశాం. కానీ ఇక్కడ readymade functionsను వాడి చేస్తున్నాం.

#include<stdio.h>
#include<ctype.h>
     int main()
{
     char v;
     printf(“Enter character\n”);
     scanf(“%c”,&v);
     (isupper(v))?printf(“Upper\n”):printf(“Not Upper\n”);
     v=isupper(v)?tolower(v):toupper(v);
     printf(“%c\n”, v);
     return (0);
}

పై ప్రోగ్రాంను రన్ చేసినప్పుడు స్క్రీన్ ఈ విధంగా ఉంటుంది.

ఈ అధ్యాయం లో character variables అంటే ఏమిటి, వాటిని ఎలా వాడాలి అని తెలుసుకున్నాం. అలాగే వాటితో ఉపయోగించగలిగిన readymade functions గురించి నేర్చుకున్నాం.


NB Venkateswarlu
M.Tech(IIT-Kanpur)
Ph.D (BITS),PDF(UK),
Sr.Prof., CSE, AITAM, Tekkali

  • Industry      Interaction

    Higher Education

    Job Skills

    Soft Skills

    Comm. English

    Mock Test

    E-learning