strtok() ఫంక్షన్ ఎలా పని చేస్తుంది?
ఉపయోగించి స్ట్రింగ్‌ను విభజించడానికి స్ట్రోక్ () , ఇది ఎలా పని చేస్తుందో మీరు మొదట అర్థం చేసుకోవాలి. ది స్ట్రోక్ () ఇన్పుట్ స్ట్రింగ్ క్యారెక్టర్‌ని డీలిమిటర్‌లో వచ్చే వరకు క్యారెక్టర్ వారీగా చదువుతుంది. డీలిమిటర్ కనుగొనబడిన తర్వాత, స్ట్రోక్ () దానిని '\0' అనే శూన్య అక్షరంతో భర్తీ చేస్తుంది, అసలైన స్ట్రింగ్‌ను సమర్థవంతంగా రెండు భాగాలుగా విభజిస్తుంది. స్ట్రింగ్ యొక్క మొదటి అక్షరానికి పాయింటర్ ఫంక్షన్ ద్వారా తిరిగి ఇవ్వబడుతుంది. ది స్ట్రోక్ () ఫంక్షన్ యొక్క వాక్యనిర్మాణం:
స్ట్రోక్ ( చార్ * str , స్థిరంగా చార్ * నేను పంచుకుంటాను ) ;ది స్ట్రోక్ () ఫంక్షన్ రెండు ఆర్గ్యుమెంట్‌లను తీసుకుంటుంది- టోకెన్‌ల సెట్‌లోని మొదటి టోకెన్‌కు పాయింటర్ మరియు డీలిమిటర్ అక్షరాలను కలిగి ఉండే స్ట్రింగ్. ఇది చివరి టోకెన్‌ను విభజించిన డీలిమిటర్ తర్వాత వెంటనే ప్రారంభమయ్యే తదుపరి టోకెన్‌కు పాయింటర్‌ను అందిస్తుంది. ఎక్కువ టోకెన్‌లు లేకుంటే అది NULLని అందిస్తుంది.
C ప్రోగ్రామింగ్‌లో Strtok()తో స్ట్రింగ్‌లను ఎలా విభజించాలి?
ఎలా ఉపయోగించాలో ఇక్కడ ఒక ఉదాహరణ ఉంది స్ట్రోక్ () స్ట్రింగ్‌ను విభజించడానికి:
#
#include
int ప్రధాన ( ) {
చార్ ఇన్పుట్ [ ] = 'Linux, సూచన' ;
చార్ * టోకెన్ ;
టోకెన్ = స్ట్రోక్ ( ఇన్పుట్ , ',' ) ;
అయితే ( టోకెన్ != శూన్య ) {
printf ( '%s \n ' , టోకెన్ ) ;
టోకెన్ = స్ట్రోక్ ( శూన్య , ',' ) ;
}
తిరిగి 0 ;
}
పై ఉదాహరణలో, మేము మొదట చార్‌కి పాయింటర్‌ని డిక్లేర్ చేస్తాము. మేము అప్పుడు ఉపయోగిస్తాము స్ట్రోక్ () ఇన్పుట్ స్ట్రింగ్‌ను టోకెన్‌లుగా విభజించడానికి. యొక్క మొదటి కాల్ స్ట్రోక్ () రెండు ఆర్గ్యుమెంట్‌లను తీసుకుంటుంది: ఇన్పుట్ స్ట్రింగ్ మరియు డీలిమిటర్ స్ట్రింగ్ “,”. మొదటి టోకెన్, 'Linux,' అది ఒకటి స్ట్రోక్ () పాయింటర్‌గా తిరిగి వస్తుంది . మేము ఇన్పుట్ స్ట్రింగ్ ద్వారా మళ్ళించడానికి కాసేపు లూప్‌ని ఉపయోగిస్తాము స్ట్రోక్ () మిగిలిన టోకెన్‌లను విభజించడాన్ని కొనసాగించడానికి NULL పాయింటర్‌తో. డీలిమిటర్ స్ట్రింగ్ మళ్లీ ఆర్గ్యుమెంట్‌గా పాస్ చేయబడింది స్ట్రోక్ () డీలిమిటర్ అక్షరాలను సూచించడానికి.
అవుట్‌పుట్
స్ట్రోక్() ఫంక్షన్ యొక్క పరిమితులు
1: ఒరిజినల్ స్ట్రింగ్‌ను సవరిస్తుంది
ది స్ట్రోక్ () ఫంక్షన్ స్ట్రింగ్ కాపీని తిరిగి ఇవ్వదు; బదులుగా, ఇది అసలు స్ట్రింగ్‌ను సవరించింది. అందువల్ల, మీరు స్ట్రింగ్‌ను విభజించిన తర్వాత దాని యొక్క మార్పులేని సంస్కరణను కలిగి ఉండాలంటే, మీరు ప్రారంభించే ముందు అసలు స్ట్రింగ్ కాపీని తయారు చేయాలి స్ట్రోక్ () .
2: అసమకాలిక
యొక్క ఒక ముఖ్యమైన పరిమితి స్ట్రోక్ () ఇది ఒక సమయంలో ఒకే స్ట్రింగ్‌లో మాత్రమే ఉపయోగించబడుతుంది. మరో మాటలో చెప్పాలంటే, మీరు ఏకకాలంలో బహుళ స్ట్రింగ్‌లను టోకనైజ్ చేయడానికి దీన్ని ఉపయోగించలేరు.
3: పరిమిత సామర్థ్యం
మరొక సంభావ్య పరిమితి అది స్ట్రోక్ () పునరావృత డీలిమిటర్‌లను నిర్వహించడానికి పరిమిత సామర్థ్యాన్ని కలిగి ఉంది. ఉదాహరణకు, మీ స్ట్రింగ్‌లో పదాల మధ్య వరుస ఖాళీలు ఉంటే, స్ట్రోక్ () దానిని సింగిల్ డీలిమిటర్‌గా పరిగణిస్తుంది. అటువంటి కేసులను నిర్వహించడానికి, మీరు వేరే విధానాన్ని ఉపయోగించాలి.
ముగింపు
ది స్ట్రోక్ () C ప్రోగ్రామింగ్‌లో స్ట్రింగ్‌లను విభజించడానికి ఫంక్షన్ చాలా ఉపయోగకరమైన ఫంక్షన్. ఇది ఇన్పుట్ స్ట్రింగ్ మరియు డీలిమిటర్ స్ట్రింగ్‌ను తీసుకుంటుంది మరియు ఇన్పుట్ స్ట్రింగ్‌లో కనిపించే మొదటి టోకెన్‌కు పాయింటర్‌ను అందిస్తుంది. స్ట్రోక్ () విధ్వంసకరం, కాబట్టి మీరు ఒరిజినల్ స్ట్రింగ్ యొక్క సమగ్రతను కాపాడుకోవాల్సిన అవసరం ఉన్నట్లయితే, బదులుగా దాని నకిలీని సృష్టించమని సలహా ఇస్తారు. దీన్ని ఎలా చేయాలో ఇప్పుడు మీకు తెలుసు, ప్రాసెసింగ్ కోసం మీరు ఏదైనా స్ట్రింగ్‌ను చిన్న ముక్కలుగా కట్ చేయవచ్చు.