C++లో Getch() అంటే ఏమిటి?
C++లో, 'cstdio' హెడర్ ఫైల్ అనే లైబ్రరీ ఎక్కువగా getch() ఫంక్షన్ కోసం ఉపయోగించబడుతుంది. Getch() కూడా “conioలో నిర్వచించబడింది. h” హెడర్ ఫైల్ కంపైలర్-నిర్దిష్టమైనది మరియు ఇది పూర్తిగా C++ లైబ్రరీ స్టాండర్డ్‌లో భాగం కానందున ఇది ప్రామాణికం కాని ఫంక్షన్. గెట్చ్ యొక్క సంక్షిప్తీకరణ 'పాత్ర పొందండి' మరియు వినియోగదారు ఇన్‌పుట్‌ను పాస్ చేసే వరకు కొంత కాలం పాటు అవుట్‌పుట్ స్క్రీన్‌పై ఉండటానికి ఇది ఉపయోగించబడుతుంది.
ఉదాహరణల సహాయంతో ఈ భావనను సరిగ్గా వివరిద్దాం. ఇక్కడ, మేము సరైన దృశ్యాల సహాయంతో C++లో getch() పద్ధతి యొక్క సింటాక్స్, వినియోగం మరియు ప్రవర్తన గురించి తెలుసుకుందాం.
దృష్టాంతం 1: మెనూ-డ్రైవెన్ అప్లికేషన్‌లో Getch()ని ఎలా ఉపయోగించాలి
మేము వివిధ ఎంపికలను జాబితా చేసే మెను-ఆధారిత చిన్న అప్లికేషన్ గురించి చర్చిద్దాం. ప్రతి ఎంపిక రెస్టారెంట్ మెనూ వంటి విభిన్న ప్రయోజనాల కోసం రూపొందించబడింది. ఈ ఉదాహరణ యొక్క కోడ్ స్నిప్పెట్ కింది వాటిలో జోడించబడింది:
#
#
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
చార్ ఎంపిక ;
std :: కోట్ << 'రెస్టారెంట్ మెనూ: \n ' ;
std :: కోట్ << '1. ఎంపిక 1: పిజ్జా \n ' ;
std :: కోట్ << '2. ఎంపిక 2: బర్గర్ \n ' ;
std :: కోట్ << '3. ఎంపిక 3: కేక్ \n ' ;
std :: కోట్ << 'మీ ఎంపికను నమోదు చేయండి:' ;
ఎంపిక = పొందండి ( ) ; // వినియోగదారు ఇన్‌పుట్ ఇవ్వండి మరియు getch() ఎంటర్ బటన్‌ను నొక్కకుండానే ఇన్‌పుట్‌ను చదువుతుంది
మారండి ( ఎంపిక ) {
కేసు '1' :
std :: కోట్ << ' \n మీరు 'పిజ్జా' ఎంచుకోండి \n ' ;
బ్రేక్ ;
కేసు '2' :
std :: కోట్ << ' \n మీరు 'బర్గర్' ఎంచుకోండి \n ' ;
బ్రేక్ ;
కేసు '3' :
std :: కోట్ << ' \n మీరు 'కేక్' ఎంచుకోండి \n ' ;
బ్రేక్ ;
డిఫాల్ట్ :
std :: కోట్ << '\ ఎంపిక లేదు - ఆర్డర్ లేదు \n ' ;
}
తిరిగి 0 ;
}
ముందుగా, మేము ప్రోగ్రామ్ ప్రారంభంలో అవసరమైన ప్రామాణిక లైబ్రరీలను ప్రకటిస్తాము. మేము ప్రధాన ఫంక్షన్ లోపల లాజిక్‌ను సృష్టిస్తాము మరియు ప్రోగ్రామ్ యొక్క ప్రధాన ఫంక్షన్ లోపల ఏదైనా ఎక్జిక్యూటబుల్ అవుతుంది. ఇక్కడ, మేము 'ఎంపిక' వేరియబుల్‌ని ప్రకటిస్తాము, దీని డేటా రకం అక్షరం. అప్పుడు, మేము కన్సోల్ స్క్రీన్‌పై కనిపించే మెనుని సృష్టిస్తాము. మేము వినియోగదారుకు 'పిజ్జా', 'బర్గర్', 'కేక్' మరియు 'నో చాయిస్' వంటి విభిన్న ఎంపికలతో కూడిన 'రెస్టారెంట్ మెనూ'ని అందిస్తాము.
వినియోగదారు ఇన్‌పుట్ ఈ వేరియబుల్‌లో నిల్వ చేయబడుతుంది మరియు ఎంచుకున్న ఎంపిక ప్రకారం స్వయంచాలకంగా అవుట్‌పుట్‌ను ప్రదర్శిస్తుంది కాబట్టి మేము వేరియబుల్ ఎంపికకు getch()ని పాస్ చేస్తాము. మెను నుండి ఎంపికను ఎంచుకోవడానికి, మేము స్విచ్() ఫంక్షన్‌ని ఉపయోగిస్తాము మరియు ఈ ఫంక్షన్‌లో “ఎంపిక” పాస్ చేస్తాము. 'స్విచ్' పద్ధతిలో, మేము ఒక్కొక్క ఎంపికకు వ్యతిరేకంగా కేసులను ఒక్కొక్కటిగా చేస్తాము. C++లోని “స్విచ్” పద్ధతిలో, స్టేట్‌మెంట్ ముగింపును సూచించే ప్రతి కేసు ముగింపులో బ్రేక్ స్టేట్‌మెంట్ ఎల్లప్పుడూ ఉపయోగించబడుతుంది. మేము దానిని కంపైల్ చేసి, అమలు చేసినప్పుడు, అవుట్‌పుట్ కన్సోల్ స్క్రీన్‌పై చూపబడుతుంది, అది కింది వాటిలో జోడించబడింది:
ఇప్పుడు, getch() ఫంక్షన్ ఇక్కడ పని చేస్తుంది. వినియోగదారు ఎంపికలోకి ప్రవేశించినప్పుడు, getch() ఫంక్షన్ ఈ ఇన్‌పుట్‌ను స్విచ్ కేస్‌తో సరిపోల్చుతుంది మరియు స్వయంచాలకంగా మరియు వెంటనే కన్సోల్‌లో అవుట్‌పుట్ లేదా ఎంపికను చూపుతుంది.
మునుపు జోడించిన స్క్రీన్‌షాట్‌లో, వినియోగదారు '2' ఎంపికను నమోదు చేస్తారు మరియు అవుట్‌పుట్ స్క్రీన్‌పై 'మీరు 'బర్గర్'ని ఎంచుకోండి'గా కనిపిస్తుంది. వినియోగదారు ఇన్‌పుట్‌లోకి ప్రవేశించినప్పుడు గెట్చ్() యొక్క పని ఈ ఉదాహరణలో క్లియర్ చేయబడుతుంది మరియు కన్సోల్‌లో చూపబడే వినియోగదారు ఇచ్చిన ఇన్‌పుట్‌కు బదులుగా ఆశించిన అవుట్‌పుట్ కన్సోల్ స్క్రీన్‌పై ప్రదర్శించబడుతుంది.
దృష్టాంతం 2: Getch()ని ఉపయోగించి వినియోగదారు నుండి దాచిన పాస్వర్డ్ను అంగీకరించండి
ఈ దృష్టాంతంలో, వినియోగదారు రహస్యంగా పాస్వర్డ్ను ఎలా ఇన్‌పుట్ చేయవచ్చో మరియు కన్సోల్ స్క్రీన్‌పై ఇన్‌పుట్ పాస్వర్డ్ను ఎలా చూపవచ్చో మేము కాన్సెప్ట్ ద్వారా వెళ్తాము. ఇక్కడ, వినియోగదారు ఇన్‌పుట్‌ను పాస్ చేసే వరకు స్క్రీన్‌ను పట్టుకోవడానికి మేము getch() ఫంక్షన్‌ని ఉపయోగిస్తాము. కన్సోల్ స్క్రీన్‌పై కర్సర్ ఇన్‌పుట్‌ను ప్రదర్శించనందున getch() వినియోగదారు ఇన్‌పుట్‌ను ప్రదర్శించదని గుర్తుంచుకోండి. ఈ దృశ్యం యొక్క కోడ్ స్నిప్పెట్ క్రింది విధంగా పేర్కొనబడింది:
#include#
#
#
#include
int ప్రధాన ( )
{
చార్ పాస్వ్ [ 8 ] ;
int m ;
std :: కోట్ << '8 అంకెల పాస్‌వర్డ్‌ని నమోదు చేయండి:' ;
కోసం ( m = 0 ; m <= 7 ; m ++ ) {
పాస్వ్ [ m ] = పొందండి ( ) ;
std :: కోట్ << '*' ;
}
పాస్వ్ [ m ] = ' \0 ' ;
std :: కోట్ << ' \n ' ;
std :: కోట్ << 'నమోదు చేసిన పాస్వర్డ్ను దాచిపెట్టు:' ;
కోసం ( m = 0 ; పాస్వ్ [ m ] ! = ' \0 ' ; m ++ )
std :: కోట్ << ( '%c' , పాస్వ్ [ m ] ) ;
పొందండి ( ) ;
తిరిగి 0 ;
}
ఇచ్చిన కోడ్‌లో చూసినట్లుగా, getch() ఫంక్షన్ వినియోగానికి మరియు స్క్రీన్‌పై అవుట్‌పుట్‌ను ప్రదర్శించడానికి అవసరమైన ప్రామాణిక లైబ్రరీలను జోడించండి. ఈ ప్రోగ్రామ్ యొక్క ప్రధాన విధి ఏమిటంటే, మేము వినియోగదారు నుండి పాస్వర్డ్ను ఇన్‌పుట్ చేసి, స్క్రీన్‌పై పాస్వర్డ్ను చూపించే వివిధ దశలను కలిగి ఉండటం. మనకు 8 మూలకాల పరిమాణాన్ని కలిగి ఉన్న “చార్” డేటా రకం శ్రేణి వేరియబుల్ అవసరం. ఇది తప్ప, మనకు పునరావృత విలువలను నిల్వ చేసే వేరియబుల్ కూడా అవసరం.
ఇక్కడ, శ్రేణి పరిమాణం '8' అయితే వినియోగదారు యొక్క ప్రతి ఇన్‌పుట్ గణనను చదివే 'ఫర్ లూప్'ని ఉపయోగిస్తాము. అప్పుడు, వినియోగదారు లూప్ సహాయంతో ఇన్‌పుట్ కన్సోల్ విండోలో కీ పాస్వర్డ్ను మాత్రమే నొక్కుతారు. ఈ “ఫర్” లూప్ లోపల, మేము getch() ఫంక్షన్‌ను passw[] శ్రేణికి పాస్ చేస్తాము. వినియోగదారు పాస్‌వర్డ్‌లోని 8 అక్షరాలను ఇన్‌పుట్ చేసే వరకు ఈ ఫంక్షన్ స్క్రీన్‌పై ఉంచబడుతుంది. ప్రతి లూప్ కౌంట్‌లో, ప్రతి వినియోగదారు ఇన్‌పుట్ కౌంట్‌పై “*” అని ముద్రించండి మరియు లూప్ ఇక్కడ మూసివేయబడుతుంది.
ఆ తర్వాత, పాస్‌వూ[] నుండి విలువలను తీసుకోవడం ద్వారా దాచిన పాస్వర్డ్ను చూపే “ఫర్” లూప్‌ని మళ్లీ ఉపయోగిస్తాము. వినియోగదారు ఇన్‌పుట్ శ్రేణిలో సంపూర్ణంగా నిల్వ చేయబడి, స్క్రీన్‌పై పాస్వర్డ్ను ప్రదర్శించే వరకు Getch స్క్రీన్‌ను స్వయంచాలకంగా ఉంచుతుంది.
ప్రోగ్రామ్‌ను అమలు చేయడానికి మరియు స్క్రీన్‌పై అవుట్‌పుట్‌ను చూపించడానికి “కంపైల్ అండ్ రన్” ఎంపికపై క్లిక్ చేయండి.
స్క్రీన్‌పై 8 అంకెల పాస్వర్డ్ను నమోదు చేయండి. 8 అంకెల ఇన్‌పుట్ పూర్తయినప్పుడు, అది స్వయంచాలకంగా కన్సోల్ విండోలో టైప్ చేసిన పాస్వర్డ్ను ప్రదర్శిస్తుంది. కీబోర్డ్ కీలను 8 సార్లు నొక్కండి మరియు పాస్వర్డ్ను టైప్ చేయండి.
కేవలం getch() ఫంక్షన్ కారణంగా అవుట్‌పుట్ స్క్రీన్ స్తంభింపజేస్తుంది. getch() ఫంక్షన్ మునుపు జోడించిన స్క్రీన్‌షాట్‌లో చూపిన విధంగా స్క్రీన్‌పై ఇన్‌పుట్ డేటాను ప్రింట్ చేస్తుంది.
ముగింపు
ముగించడానికి, getch() అనేది C మరియు C++ ప్రోగ్రామింగ్‌ల యొక్క అతి ముఖ్యమైన విధి, ఇది స్క్రీన్‌పై ఇన్‌పుట్‌ను ప్రదర్శించకుండా లేదా కర్సర్ లేకుండానే కీబోర్డ్ నుండి ఇన్‌పుట్‌ను స్తంభింపజేయడానికి వినియోగదారుని సులభతరం చేస్తుంది. దాని ప్రామాణికం కాని లైబ్రరీ కారణంగా, మేము ప్రోగ్రామ్‌లో getch()ని ఉపయోగించకపోతే, ప్రోగ్రామ్ అమలుకు అవసరమైన సమయం మిల్లీసెకన్లలో ఉండే వరకు కన్సోల్ విండో ప్రదర్శించబడుతుంది. ఈ వ్యాసంలో, మేము ఈ పద్ధతిని సరైన కోడ్ ఉదాహరణలతో వివరించాము.