సిలో స్ప్రింట్() ఫంక్షన్ యొక్క సింటాక్స్:
sprintf() ఫంక్షన్‌లో, మేము ”int” రకాన్ని ప్రకటించాము. పెద్ద-పరిమాణ బఫర్‌లో క్యారెక్టర్ స్ట్రింగ్‌ను నిల్వ చేయడానికి ఉపయోగించే పాయింటర్ అయిన టైప్ క్యారెక్టర్ యొక్క పారామీటర్ నేమ్ బఫర్ ఉంది. వాదన * ఫార్మాట్ అనేది అవుట్‌పుట్‌ను వివరించడానికి ఉపయోగించే స్ట్రింగ్.
సిలో స్ప్రింట్ఎఫ్() ఫంక్షన్‌లో ఉపయోగించే స్పెసిఫైయర్‌లు
మేము అవుట్‌పుట్ స్క్రీన్‌పై ప్రదర్శించదలిచిన వేరియబుల్ రకాన్ని గుర్తించడానికి C భాషలో ఉపయోగించే విభిన్న ఫార్మాట్ స్పెసిఫైయర్‌లు క్రిందివి:
| ఫార్మాట్ స్పెసిఫైయర్‌లు | వివరణ |
|---|---|
| %d | పూర్ణాంకం సంఖ్యను సూచిస్తుంది. |
| % f | స్థిర దశాంశ ఫ్లోట్ విలువను సూచిస్తుంది. |
| %.1f | దశాంశాలకు ముందు ఉన్న ఒక అంకెతో ఫ్లోటింగ్ పాయింట్‌లో విలువను సూచిస్తుంది |
| % మరియు | శాస్త్రీయ సంజ్ఞామానం (ఘాతాంకం)లో దశాంశ ఫ్లోట్ విలువను సూచిస్తుంది. |
| % గ్రా | విలువ యొక్క పొడవు ఆధారంగా స్టాటిక్ డెసిమల్ లేదా ఎక్స్‌పోనెన్షియల్ ఫార్మాట్‌లో ఫ్లోటింగ్ పాయింట్ విలువను సూచిస్తుంది. |
| %c | అక్షర వేరియబుల్స్‌ను సూచిస్తుంది. |
| %s | అక్షర స్ట్రింగ్‌ను సూచిస్తుంది. |
| % p | పాయింటర్ చిరునామాకు పాయింట్లు. |
| %n | ఏమీ ముద్రించదు. |
స్ప్రింట్ఎఫ్() ఫంక్షన్ విలువ తిరిగి ఇవ్వబడింది
స్ట్రింగ్ ముగింపులో చొప్పించిన ఖాళీ అక్షరం మినహా ముద్రించిన మొత్తం అక్షరాల సంఖ్య విజయవంతంగా కంపైల్ చేయబడితే తిరిగి మార్చబడుతుంది. ప్రత్యామ్నాయంగా, వైఫల్యం సంభవించినప్పుడు ప్రతికూల విలువ తిరిగి ఇవ్వబడుతుంది.
స్ప్రింట్ఎఫ్() ఫంక్షన్ అమలు
యొక్క అమలు కోసం C ఆన్‌లైన్ కంపైలర్ లేదా Dev C++ కంపైలర్‌ని ఉపయోగించండి స్ప్రింట్ఎఫ్() C ప్రోగ్రామింగ్ భాషలో ఫంక్షన్.
ఉదాహరణ 01:
C ప్రోగ్రామింగ్ లాంగ్వేజ్ యొక్క పనితీరును చూపించడానికి క్రింది సరళమైన ఉదాహరణ స్ప్రింట్ఎఫ్() ఫంక్షన్. ఈ సందర్భంలో, “x” మరియు “y”ని గుణించడం ద్వారా మనం “z” విలువను గుర్తించవచ్చు. మా మొదటి ప్రోగ్రామ్‌ను వ్రాయడం ప్రారంభించడానికి, ప్రోగ్రామ్‌ను అమలు చేయడానికి మేము తప్పనిసరిగా హెడర్ ఫైల్‌లను చేర్చాలి. 'stdio.h' వినియోగదారు నుండి ఇన్‌పుట్‌ను పొందడానికి ఉపయోగించబడుతుంది మరియు ప్రోగ్రామ్ సంకలనం తర్వాత అవుట్‌పుట్‌ను ప్రదర్శిస్తుంది. హెడర్ ఫైల్ “stdlib.h” అనేది డేటా నిల్వ, నియంత్రణ కార్యకలాపాలు, లెక్కలు మరియు ఇతర విషయాల కోసం పద్ధతులను కలిగి ఉన్న ప్రామాణిక లైబ్రరీని సూచిస్తుంది.
తరువాత, మేము అమలు చేయడం ప్రారంభించాము ప్రధాన () C. భాషలో ప్రోగ్రామ్ యొక్క కోడ్ అమలుకు నాందిగా పని చేసే పద్ధతి C. భాషలో ప్రధానమైనది ప్రామాణిక కీవర్డ్ లేదా పద్ధతి. ది ప్రధాన () ఫంక్షన్ అనేది కోడ్ యొక్క అమలును ప్రారంభించి, ఆపై ప్రోగ్రామ్‌ను మూసివేయడానికి బాధ్యత వహించే మొదటి పద్ధతి. ది ప్రధాన () పద్ధతి 'int' రిటర్న్ డేటా రకాన్ని కలిగి ఉంటుంది, ఇది ఎల్లప్పుడూ 'ప్రధాన' ఫంక్షన్ నుండి అమలును ప్రారంభిస్తుంది.
అప్పుడు, మేము పూర్ణాంకం అని పిలువబడే డేటా రకం “int”తో “x” అనే వేరియబుల్‌ని ప్రకటించాము. ది 'printf()' కొటేషన్ గుర్తులలో వ్రాయబడిన స్ట్రింగ్‌ను సరిగ్గా ప్రదర్శించడానికి పద్ధతి అంటారు (అనగా x విలువను నమోదు చేయండి :). అప్పుడు, మేము వినియోగదారు నుండి ఇన్‌పుట్ పొందాలి. కాబట్టి, మేము ఉపయోగించాము 'స్కాన్ఫ్ ()' పద్ధతి. లో 'స్కాన్ఫ్ ()' పద్ధతి, స్క్రీన్‌పై ప్రదర్శించడానికి పూర్ణాంక రకం వేరియబుల్ “x” కోసం “%d” స్పెసిఫైయర్ ఉపయోగించబడుతుంది. అదే విధంగా, మేము డేటా రకం “int”తో వేరియబుల్ “y”ని ప్రకటించాము మరియు వినియోగదారు నుండి ఇన్‌పుట్ పొందాము.
##
int ప్రధాన ( )
{
int x ;
printf ( 'x విలువను నమోదు చేయండి:' ) ;
స్కాన్ఎఫ్ ( '%d' , & x ) ;
int వై ;
printf ( 'y విలువను నమోదు చేయండి:' ) ;
స్కాన్ఎఫ్ ( '%d' , & వై ) ;
int తో = x * వై ;
చార్ బఫర్ [ యాభై ] ;
స్ప్రింట్ఎఫ్ ( బఫర్ , '%d మరియు %d యొక్క గుణకారం: %d' , x , వై , తో ) ;
printf ( '%s \n ' , బఫర్ ) ;
తిరిగి 0 ;
}
“x * y” గుణకారం యొక్క సమాధానాన్ని “int” డేటా రకంతో నిల్వ చేయడానికి ఉపయోగించే మరొక వేరియబుల్ “z”ని మేము ప్రకటించాము. అన్ని చెల్లుబాటు అయ్యే వేరియబుల్‌లను ప్రకటించిన తర్వాత, మేము 50 పొడవు గల అక్షర రకాన్ని “బఫర్”గా ప్రకటించాము. ఇంకా, “%d” స్పెసిఫైయర్‌లను ఉపయోగించడం ద్వారా, స్ప్రింట్ఎఫ్() పద్ధతి గుణకారం యొక్క ఫలితాన్ని తక్షణమే ప్రదర్శించకుండా స్ట్రింగ్‌ల నిర్మాణాన్ని అనుమతిస్తుంది. ఆపై, డబుల్ కొటేషన్ మార్కులలో వ్రాసిన అక్షర స్ట్రింగ్‌ను ప్రింట్ చేయండి. ప్రోగ్రామ్ ముగింపులో, 0కి తిరిగి ఇవ్వండి ప్రధాన () ప్రోగ్రామ్ అమలు యొక్క ముగింపును చూపే ఫంక్షన్
పై దృష్టాంతం యొక్క అవుట్‌పుట్ ఇక్కడ ఉంది. ముందుగా, మీరు 'x' విలువను మరియు 'y' విలువను నమోదు చేయాలి. ది స్ప్రింట్ఎఫ్() రెండు విలువలను గుణించడం యొక్క ఫలితాన్ని చూపడానికి అనువాదకుడు పద్ధతిని ఉపయోగిస్తారు.
ఉదాహరణ 02:
మా కథనం నుండి ఈ రెండవ ఉదాహరణలో, మేము వృత్తం యొక్క చుట్టుకొలత మరియు వ్యాసాన్ని ఇన్‌పుట్ చేయడం ద్వారా PI విలువను లెక్కించాము. PI విలువను లెక్కించే ప్రోగ్రామ్‌ను వ్రాయడం ప్రారంభిద్దాం.
ప్రోగ్రామ్‌ను వ్రాయడం ప్రారంభించడానికి, మేము ముందుగా హెడర్ ఫైల్‌ను చేర్చాలి. C భాషలో, హెడర్ ఫైల్ “.h” పొడిగింపును కలిగి ఉంటుంది. మా అప్లికేషన్ రన్ కావడానికి “stdio.h”, “stdlib” మరియు “math.h” హెడర్ ఫైల్‌లు అవసరం. '#include' అనే ప్రీప్రాసెసర్ డైరెక్టివ్‌తో ప్రోగ్రామ్ యొక్క ఇన్‌పుట్ మరియు అవుట్‌పుట్‌ను ప్రదర్శించడానికి హెడర్ ఫైల్ “stdio.h” ఉపయోగించబడుతుంది. మా ప్రోగ్రామ్‌కు సంబంధించిన ప్రాథమిక కోడ్, మేము సముచితమైన అవుట్‌పుట్‌ను అమలు చేయడానికి మరియు ఉత్పత్తి చేయడానికి ఉద్దేశించాము, ఇది ప్రధాన() బాడీలో వ్రాయబడింది.
ప్రధాన() ఫంక్షన్ బాడీలో, సర్కిల్ యొక్క ఉపరితల వైశాల్యాన్ని గుర్తించడానికి మేము రెండు “పూర్ణాంక” వేరియబుల్స్, “చుట్టుకొలత” మరియు “వ్యాసార్థం” అలాగే “వ్యాసం” అయిన “ఫ్లోట్” వేరియబుల్‌ని ప్రకటించాము. 'pi' యొక్క ఫ్లోట్ విలువ 'pi' అని పిలువబడే అదనపు వేరియబుల్‌లో సేవ్ చేయబడింది. చివరగా, టైప్ క్యారెక్టర్ యొక్క “బఫర్” 50 పొడవును ఉపయోగించి స్ట్రింగ్‌ను కలిగి ఉంటుంది. వనరులను కేటాయించేటప్పుడు, బఫర్ వ్రాసిన అక్షరాలను తిరిగి పొందడం మరియు అన్ని వేరియబుల్స్ పొందిన తర్వాత వాటిని స్ట్రింగ్‌కు జోడించడం. ది ప్రధాన () పద్ధతి ప్రతి వేరియబుల్‌ను అర్థం చేసుకోవడానికి ప్రయత్నిస్తుంది. అమలు సరిగ్గా జరిగితే, అది 0కి తిరిగి వస్తుంది ప్రధాన () పద్ధతి.
##
#include
int ప్రధాన ( ) {
int చుట్టుకొలత = 44 ;
printf ( 'చుట్టుకొలత విలువ: %d \n ' , చుట్టుకొలత ) ;
int వ్యాసార్థం = 7 ;
printf ( 'పై విలువను కనుగొనడానికి. ముందుగా, వ్యాసం విలువను కనుగొనండి. \n ' ) ;
తేలుతుంది వ్యాసం = ( తేలుతుంది ) 7 * రెండు ;
printf ( 'వ్యాసం విలువను పొందడానికి వ్యాసార్థం విలువను 2తో గుణించడం. \n \n '
'వ్యాసం విలువ: %f \n ' , వ్యాసం ) ;
తేలుతుంది పై = చుట్టుకొలత / వ్యాసం ;
చార్ బఫర్ [ యాభై ] ;
స్ప్రింట్ఎఫ్ ( బఫర్ , '%f' , పై ) ;
printf ( 'పై విలువ %sగా నిల్వ చేయబడుతుంది \n ' , బఫర్ ) ;
తిరిగి 0 ;
}
పైన పేర్కొన్న కోడ్ స్నిప్పెట్ అమలు చేయబడిన తర్వాత, మేము సర్కిల్ చుట్టుకొలత మరియు వ్యాసాన్ని ఉపయోగించి 'పై' విలువను గుర్తించగలిగాము.
ముగింపు
ఈ Linux హింట్ ట్యుటోరియల్‌లో ప్రోగ్రామింగ్ లాంగ్వేజ్ C యొక్క స్ప్రింట్ఎఫ్() ఫంక్షన్ ప్రస్తావించబడింది. మేము స్ప్రింట్ఎఫ్() ఫంక్షన్ యొక్క సింటాక్స్ మరియు పరామితిని ప్రకటించడానికి సిలో కోడింగ్ చేస్తున్నప్పుడు ఉపయోగించబడిన ఫార్మాట్ స్పెసిఫైయర్‌ల గురించి మాట్లాడాము. అప్పుడు, వినియోగదారు ఎలా అర్థం చేసుకోవడంలో సహాయపడటానికి స్ప్రింట్ఎఫ్() పద్ధతి పనిచేస్తుంది, మేము రెండు ప్రత్యేక ఉదాహరణలను అమలు చేసాము.