ఈ వ్యాసంలో, మేము సింటాక్స్, పారామితులు, రిటర్న్ విలువలు మరియు పనిని వివరిస్తాము snprintf() C++లో ఫంక్షన్. అనే పూర్తి అవగాహనను పొందవచ్చు snprintf() ఈ గైడ్‌లో.
C++లో snprintf() అంటే ఏమిటి
C++లో, snprintf() బఫర్‌కు వ్రాసిన అక్షరాలు మరియు స్ట్రింగ్ విలువల శ్రేణిని ఫార్మాట్ చేయడానికి లేదా నిల్వ చేయడానికి ఉపయోగించే ఫంక్షన్. ఇది అదేవిధంగా పనిచేస్తుంది స్ప్రింట్ఎఫ్() ఫంక్షన్ అయితే ఇది బఫర్ ఓవర్‌ఫ్లోలను అధిగమించే సామర్థ్యాన్ని కలిగి ఉంటుంది. ది
క్రింద ఇవ్వబడినది ఉపయోగించడానికి వాక్యనిర్మాణం snprintf() C++లో ఫంక్షన్:
snprintf ( చార్ * బఫర్, పరిమాణం_t buf_size, స్థిరంగా చార్ * ఫార్మాట్,... ) ;
అక్షరాలు వ్రాసిన తర్వాత, ముగింపు శూన్య అక్షరం చొప్పించబడుతుంది. MAX_BUFSIZE సున్నా అయితే, ఏదీ నిల్వ చేయబడదు మరియు బఫర్ శూన్య పాయింటర్‌గా పని చేస్తుంది.
snprintf() యొక్క పారామితులు
కింది పారామితులు ఉపయోగించబడ్డాయి snprintf() ఫంక్షన్.
- బఫర్ : అవుట్‌పుట్ వ్రాయబడే స్ట్రింగ్ బఫర్‌కు పాయింటర్.
- buf_size : MAX_BUFSIZE-1 అనేది బఫర్‌కు వ్రాయగల అక్షరాల గరిష్ట గణన.
- ఫార్మాట్ : శూన్య-ముగింపు స్ట్రింగ్ పాయింటర్‌గా ఫైల్ స్ట్రీమ్‌కు వ్రాయబడింది. ఇది %తో ప్రారంభమయ్యే అక్షరాలు మరియు సాధ్యమైన ఫార్మాట్ స్పెసిఫైయర్‌లతో రూపొందించబడింది. ఫార్మాట్ స్ట్రింగ్‌ను అనుసరించే వేరియబుల్స్ విలువలు ఫార్మాట్ స్పెసిఫైయర్‌లను భర్తీ చేస్తాయి.
- (అదనపు వాదనలు) : ఫార్మాట్ స్ట్రింగ్ రకాన్ని బట్టి, ఫంక్షన్ అదనపు ఆర్గ్యుమెంట్‌ల జాబితాను ఆశించవచ్చు, అన్నీ స్ట్రింగ్ ఫార్మాట్‌లో ఫార్మాట్ స్పెసిఫైయర్‌ను భర్తీ చేయడానికి ఉపయోగించే విలువను కలిగి ఉంటాయి (లేదా, MAX_BUFSIZE కోసం, నిల్వ స్థానానికి పాయింటర్) .
ఫార్మాట్ నిర్దేశిత విలువలు ఉన్నందున అటువంటి పరామితులు కనిష్టంగా ఉండాలి. ఫంక్షన్ ఏదైనా అదనపు వాదనను విస్మరిస్తుంది.
ఏమి చేస్తుంది snprintf() తిరిగి
ఫంక్షన్ విజయవంతమైతే, అంతిమ శూన్య అక్షరాన్ని మినహాయించి, సముచితంగా పెద్ద బఫర్ కోసం వ్రాసినట్లు పరిగణించబడే అక్షరాల సంఖ్యను ఇది అందిస్తుంది. అది విఫలమైనప్పుడు, అది ప్రతికూల విలువను ఇస్తుంది. అవుట్‌పుట్ పూర్తిగా వ్రాతపూర్వకంగా పరిగణించబడుతుంది, ఒకవేళ తిరిగి వచ్చిన విలువ ప్రతికూలమైనది మరియు MAX_BUFSIZE కంటే తక్కువగా ఉంటే మాత్రమే.
C++లో snprintf()ని ఎలా ఉపయోగించాలి
ఇక్కడ సి++లో snprintf()ని ఉపయోగించే ఉదాహరణ:
ఉదాహరణ
##
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
చార్ buff_size [ 60 ] ;
int తిరిగి_విలువ, MAX_BUFSIZE = 60 ;
చార్ str [ ] = 'linux' ;
int వ్యాసాలు = నాలుగు ఐదు ;
తిరిగి_విలువ = snprintf ( బఫ్_సైజ్, MAX_BUFSIZE, 'హలో %s యూజర్లు, బాష్ గురించి %d కథనాలను చదువుదాం' ,str, వ్యాసాలు ) ;
ఉంటే ( తిరిగి_విలువ > 0 && తిరిగి_విలువ < MAX_BUFSIZE )
{
కోట్ << buff_size << endl ;
కోట్ << 'వ్రాసిన అక్షరాల సంఖ్య =' << తిరిగి_విలువ << endl ;
}
లేకపోతే
కోట్ << 'బఫర్‌కి వ్రాయడంలో లోపం' << endl ;
తిరిగి 0 ;
}
పై కోడ్‌లో, మేము బఫర్ యొక్క గరిష్ట పరిమాణాన్ని 60కి సెట్ చేసాము. అంటే కోడ్ 60కి మించని అక్షరాలను అంగీకరిస్తుంది. మేము ఉపయోగించాము snprintf() 56 అక్షరాలను కలిగి ఉన్న స్ట్రింగ్‌ను అవుట్‌పుట్ చేయడానికి ఫంక్షన్ చేస్తుంది మరియు అది అవుట్‌పుట్ టెర్మినల్‌లో ప్రదర్శించబడుతుంది. మీరు నమోదు చేసిన అక్షరాలు 60 కంటే ఎక్కువ ఉంటే, ప్రోగ్రామ్ ఎర్రర్ ద్వారా అవుతుంది.
ముగింపు
మేము C++ యొక్క ప్రోటోటైప్, పారామితులు, రిటర్న్ విలువలు మరియు పనిని ప్రదర్శించాము snprintf() క్యారెక్టర్ స్ట్రింగ్ బఫర్‌కి ఫార్మాట్ చేసిన స్ట్రింగ్‌ను వ్రాసే ఫంక్షన్. మేము పూర్తి అవగాహనతో ఒక ఉదాహరణను వివరించాము snprintf() ఈ గైడ్‌లో.