రెండు తీగలను వివిధ మార్గాల్లో పోల్చవచ్చు. ఈ ట్యుటోరియల్‌లో, ముందుగా, రెండు స్ట్రింగ్‌లను పోల్చడానికి వినియోగదారు నిర్వచించిన ఫంక్షన్‌ను చూస్తాము, ఆపై రెండు స్ట్రింగ్‌లను చాలా సులభంగా సరిపోల్చడానికి ఉపయోగించే కొన్ని అంతర్నిర్మిత లైబ్రరీ ఫంక్షన్లను చూస్తాము. కాబట్టి, ప్రారంభిద్దాం.
వినియోగదారు నిర్వచించిన ఫంక్షన్ ఉపయోగించి స్ట్రింగ్ పోలిక:
మేము ఒక ఫంక్షన్ వ్రాస్తాము stringCompare () తీగలను పోల్చడానికి. మేము తీగలను దాటుతాము మరియు స్ట్రింగ్ యొక్క ప్రతి అక్షరాన్ని ఏదైనా ఒకటి లేదా రెండూ లేదా సరిపోలని ఒకటి కనుగొనబడే వరకు సరిపోల్చాము. ట్రావెర్సల్ రెండు తీగల చివరకి చేరుకున్నట్లయితే, అప్పుడు తీగలు సరిపోతాయి; లేకపోతే, తీగలు సరిపోలడం లేదు.
01./*userDefinedFunction.c*/
02.
03.#చేర్చండి
04.
05.intstringCompare( చార్str1[ ], చార్str2[ ] )
06.{
07.inti=0;
08.
09. అయితే(str1[i] ==str2[i] )
10.
పదిహేను.
16.ఉంటే(str1[i] == ' 0' &&str2[i] == ' 0' )
17.తిరిగి 0;
18.లేకపోతే
19.తిరిగి -1;
ఇరవై.
ఇరవై ఒకటి.}
22.
2. 3.
24.intప్రధాన()
25.{
26.చార్str1[30],str2[30];
27.
28. printf ('మొదటి స్ట్రింగ్‌ని నమోదు చేయండి:');
29. scanf ('% [^ n]% * c ',str1);
30. printf ('రెండవ స్ట్రింగ్‌ని నమోదు చేయండి:');
31. scanf ('% [^ n]% * c ',str2);
32.
33.ఉంటే(stringCompare(str1,str2) == 0)
3. 4. printf ('తీగలు సమానం n');
35.లేకపోతే
36. printf ('తీగలు సమానంగా లేవు n');
37.
38.తిరిగి 0; 39.}
ఇక్కడ మేము తీగలను అయితే లూప్ మరియు వేరియబుల్ ఉపయోగించి ఉపయోగిస్తాము i . రెండు స్ట్రింగ్‌ల యొక్క ఒకే స్థితిలో అక్షరాలు సమానంగా ఉన్నప్పుడు, విలువ i 1 (లైన్ 13) ద్వారా పెంచబడింది. అక్షరాలు సమానంగా లేకపోతే (లైన్ 09) లేదా మేము స్ట్రింగ్ ముగింపు (లైన్ 11) కి చేరుకున్నట్లయితే, అప్పుడు లూప్ బ్రేక్. అయితే లూప్ తర్వాత, రెండు స్ట్రింగ్ ట్రావెర్సల్స్ చివరికి చేరుకున్నాయో లేదో మేము తనిఖీ చేస్తాము (లైన్ 16). ట్రావెర్సల్ రెండు స్ట్రింగ్‌ల చివరకి చేరుకున్నట్లయితే, స్ట్రింగ్‌లు సమానంగా ఉంటాయి, లేకపోతే కాదు.
అంతర్నిర్మిత లైబ్రరీ ఫంక్షన్లను ఉపయోగించి స్ట్రింగ్ పోలిక:
స్ట్రింగ్ పోలిక కోసం క్రింది లైబ్రరీ ఫంక్షన్లను ఉపయోగించవచ్చు. అన్ని విధులు లో ప్రకటించబడ్డాయి string.h శీర్షిక ఫైల్.
strcmp () ఫంక్షన్:
ఈ ఫంక్షన్ ఫంక్షన్‌కు పంపిన రెండు తీగలను సరిపోల్చింది.
వాక్యనిర్మాణం :
int strcmp (కానిస్టేట్ చార్ *str1, కానిస్టేట్ చార్ *str2)రిటర్న్ విలువ: తీగలు సమానంగా ఉంటే 0 ని తిరిగి ఇవ్వండి. మొదటి స్ట్రింగ్ యొక్క మొదటి సరిపోలని అక్షరం యొక్క ASCII విలువ రెండవ స్ట్రింగ్ కంటే తక్కువగా ఉంటే నెగటివ్ పూర్ణాంకాన్ని తిరిగి ఇవ్వండి. మొదటి స్ట్రింగ్ యొక్క మొదటి సరిపోలని అక్షరం యొక్క ASCII విలువ రెండవ స్ట్రింగ్ కంటే ఎక్కువగా ఉంటే పాజిటివ్ పూర్ణాంకాన్ని తిరిగి ఇవ్వండి. కొన్ని సిస్టమ్‌లు మొదటి సరిపోలని అక్షరం యొక్క ASCII విలువ యొక్క వ్యత్యాసాన్ని తిరిగి ఇస్తాయి మరియు కొన్ని సిస్టమ్‌లు తిరిగి వస్తాయి -1 మొదటి స్ట్రింగ్ యొక్క మొదటి సరిపోలని అక్షరం యొక్క ASCII విలువ రెండవ స్ట్రింగ్ కంటే తక్కువగా ఉంటే మరియు మొదటి సరిపోలని అక్షరం యొక్క ASCII విలువ ఉంటే 1 మొదటి స్ట్రింగ్ రెండవ స్ట్రింగ్ కంటే ఎక్కువ.
| ఉదాహరణ | రిటర్న్ వాల్యూ | వివరణ |
| strcmp ( హలో వరల్డ్, హలో వరల్డ్ ) | 0 | రెండు తీగలు ఒకటే. |
| strcmp ( హలో, హలో 0 వరల్డ్ ) | 0 | స్ట్రింగ్స్ ' 0' అక్షరం వరకు సరిపోల్చబడతాయి. డిఫాల్ట్‌గా మొదటి స్ట్రింగ్ ‘ 0’ తో ముగుస్తుంది మరియు రెండవ స్ట్రింగ్‌లో ‘హలో’ తర్వాత ‘ 0’ అక్షరం ఉంటుంది. |
| strcmp ( హలో 0 0 0 ″, హలో 0 వరల్డ్ ) | 0 | స్ట్రింగ్స్ ' 0' అక్షరం వరకు సరిపోల్చబడతాయి. |
| strcmp ( హలో వరల్డ్, హలో వరల్డ్ ) | ప్రతికూల పూర్ణాంకం | మొదటి స్ట్రింగ్ ('H') యొక్క మొదటి సరిపోలని అక్షరం యొక్క ASCII విలువ రెండవ స్ట్రింగ్ ('h') కంటే తక్కువగా ఉంటుంది |
| strcmp ( హలో వరల్డ్, హలో వరల్డ్ ) | పాజిటివ్ పూర్ణాంకం | మొదటి స్ట్రింగ్ ('h') యొక్క మొదటి సరిపోలని అక్షరం యొక్క ASCII విలువ రెండవ స్ట్రింగ్ ('H') కంటే ఎక్కువగా ఉంటుంది |
strncmp () ఫంక్షన్:
ఈ ఫంక్షన్ ఫంక్షన్‌ని పోలి ఉంటుంది strcmp () , కానీ ఇక్కడ మనం ఫంక్షన్‌కు అదనపు ఆర్గ్యుమెంట్ పాస్ చేయడం ద్వారా ఎన్ని బైట్‌లను పోల్చాలో పేర్కొనాలి.
వాక్యనిర్మాణం:
int strncmp (కానిస్టేట్ చార్ *str1, కానిస్టేట్ చార్ *str2, పరిమాణం_టిఎన్)రిటర్న్ విలువ: ఫంక్షన్ తిరిగి వస్తుంది 0 మొదటిది అయితే ఎన్ రెండు తీగల అక్షరాలు సమానంగా ఉంటాయి; లేకపోతే, మొదటి సరిపోలని అక్షరం యొక్క ASCII విలువ మధ్య వ్యత్యాసాల సంకేతాన్ని బట్టి ఇది ప్రతికూల లేదా పాజిటివ్ పూర్ణాంకాన్ని అందిస్తుంది.
| ఉదాహరణ | రిటర్న్ వాల్యూ | వివరణ |
| strncmp ( హలో వరల్డ్, హలో వరల్డ్, 5 ) | 0 | మొదటి 5 అక్షరాలు ఒకేలా ఉంటాయి. |
| strncmp ( హలో, హలో 0 వరల్డ్, 5 ) | 0 | మొదటి 5 అక్షరాలు ఒకేలా ఉంటాయి. |
| strncmp ( హలో 0 0 0 He, హలో 0 వరల్డ్, 8 ) | 0 | రెండు స్ట్రింగ్‌లలో మొదటి 5 అక్షరాల తర్వాత ' 0'. కాబట్టి, పోలిక 5 కాదు 8 తర్వాత నిలిపివేయబడుతుంది. |
| strncmp ( హలో వరల్డ్, హలో వరల్డ్, 5 ) | ప్రతికూల పూర్ణాంకం | మొదటి స్ట్రింగ్ ('H') యొక్క మొదటి సరిపోలని అక్షరం యొక్క ASCII విలువ రెండవ స్ట్రింగ్ ('h') కంటే తక్కువగా ఉంటుంది |
strcasecmp () ఫంక్షన్:
ఈ ఫంక్షన్ ఫంక్షన్‌ని పోలి ఉంటుంది strcmp () , కానీ ఇక్కడ స్ట్రింగ్స్ కేస్ సెన్సిటివ్ కాదు.
వాక్యనిర్మాణం:
intstrcasecmp(కానిస్టేట్ చార్ *str1, కానిస్టేట్ చార్ *str2)రిటర్న్ విలువ: అదే విధంగా strcmp () , కానీ తీగలను ఇలా పరిగణిస్తారు కేస్-ఇన్-సెన్సిటివ్ .
| ఉదాహరణ | రిటర్న్ వాల్యూ | వివరణ |
| strcasecmp ( హలో వరల్డ్, హలో వరల్డ్ ) | 0 | రెండు తీగలు ఒకటే. |
| strcasecmp ( హలో, హలో 0 వరల్డ్ ) | 0 | స్ట్రింగ్స్ ' 0' అక్షరం వరకు సరిపోల్చబడతాయి. డిఫాల్ట్‌గా మొదటి స్ట్రింగ్ ' 0' తో ముగుస్తుంది మరియు రెండవ స్ట్రింగ్‌లో 'హలో' తర్వాత ' 0' అక్షరం ఉంటుంది. |
| strcasecmp ( హలో వరల్డ్, హలో వరల్డ్ ) | 0 | తీగలు ఉన్నాయి కేస్-ఇన్-సెన్సిటివ్. కాబట్టి, హలో వరల్డ్ మరియు హలో వరల్డ్ ఒకటే. |
strncasecmp () ఫంక్షన్:
ఈ ఫంక్షన్ ఫంక్షన్‌ని పోలి ఉంటుంది strncmp () , కానీ ఇక్కడ స్ట్రింగ్స్ కేస్ సెన్సిటివ్ కాదు.
వాక్యనిర్మాణం:
intstrncasecmp(కానిస్టేట్ చార్ *str1, కానిస్టేట్ చార్ *str2)రిటర్న్ విలువ: అదే విధంగా strncmp () , స్ట్రింగ్‌లను కేస్-ఇన్-సెన్సిటివ్‌గా పరిగణించినప్పుడు.
| ఉదాహరణ | రిటర్న్ వాల్యూ | వివరణ |
| strncasecmp ( హలో వరల్డ్, హలో వరల్డ్, 5 ) | 0 | మొదటి 5 అక్షరాలు ఒకేలా ఉంటాయి. |
| strncasecmp ( హలో, హలో 0 వరల్డ్, 5 ) | 0 | మొదటి 5 అక్షరాలు ఒకేలా ఉంటాయి. |
| strncasecmp ( హలో 0 0 0 He, హలో 0 వరల్డ్, 8 ) | 0 | రెండు స్ట్రింగ్‌లలో మొదటి 5 అక్షరాల తర్వాత ' 0'. కాబట్టి, పోలిక 5 కాదు 8 తర్వాత నిలిపివేయబడుతుంది. |
| strncasecmp ( హలో వరల్డ్, హలో వరల్డ్, 5 ) | 0 | తీగలు ఉన్నాయి కేస్-ఇన్-సెన్సిటివ్. కాబట్టి, హలో మరియు హలో ఒకటే. |
emcmp () ఫంక్షన్:
ఈ ఫంక్షన్ బైట్ ద్వారా రెండు మెమరీ బ్లాక్స్ బైట్‌ను పోల్చి చూస్తుంది. మేము మెమరీ బ్లాక్‌ల యొక్క రెండు పాయింటర్‌లను మరియు పోల్చడానికి బైట్‌ల సంఖ్యను పాస్ చేయాలి.
వాక్యనిర్మాణం:
int emcmp (కానిస్టేట్ శూన్యం *str1, కానిస్టేట్ శూన్యం *str2, పరిమాణం_టిఎన్)రిటర్న్ విలువ: రెండు మెమరీ బ్లాక్ అయితే ఫంక్షన్ 0 ని అందిస్తుంది ( ఎన్ బైట్లు) సమానంగా ఉంటాయి; లేకపోతే, ఇది మొదటి సరిపోలని జత బైట్‌ల మధ్య వ్యత్యాసాలను అందిస్తుంది (బైట్లు సంతకం చేయని చార్ ఆబ్జెక్ట్‌లుగా వ్యాఖ్యానించబడతాయి, ఆపై int కి ప్రమోట్ చేయబడతాయి).
| ఉదాహరణ | రిటర్న్ వాల్యూ | వివరణ |
| ఎంఎంసిఎంపి ( హలో వరల్డ్, హలో వరల్డ్, 5 ) | 0 | మొదటి 5 అక్షరాలు ఒకేలా ఉంటాయి. |
| ఎంఎంసిఎంపి ( హలో 0 0 0 He, హలో 0 వరల్డ్, 8 ) | ప్రతికూల పూర్ణాంకం | మొదటి 6 అక్షరాలు ఒకే విధంగా ఉంటాయి, కానీ 7 వ అక్షరం భిన్నంగా ఉంటుంది. ఇక్కడ పోలిక ఇలా ఆగలేదు strncmp () ' 0' అక్షరాన్ని పొందుతున్నప్పుడు. |
| ఎంఎంసిఎంపి ( హలో వరల్డ్, హలో వరల్డ్, 11 ) | ప్రతికూల పూర్ణాంకం | మొదటి స్ట్రింగ్ ('H') యొక్క మొదటి సరిపోలని అక్షరం యొక్క ASCII విలువ రెండవ స్ట్రింగ్ ('h') కంటే తక్కువగా ఉంటుంది |
ఉదాహరణ:
చర్చించిన అన్ని ఫంక్షన్ల యొక్క సి కోడ్ ఉదాహరణ క్రిందిది.
01./*stringCompare.c*/02.
03.#చేర్చండి
04.#చేర్చండి
05.
06.intప్రధాన()
07.{
08. printf ('strcmp ('హలో వరల్డ్','హలో వరల్డ్') => %d n', strcmp ( 'హలో వరల్డ్','హలో వరల్డ్' ));
09. printf ('strcmp ('హలో','హలో\0ప్రపంచ') => %d n', strcmp ( 'హలో','హలో 0ప్రపంచం ' ));
10. printf ('strcmp ('హలో వరల్డ్','హలో వరల్డ్') => %d n', strcmp ( 'హలో వరల్డ్','హలో వరల్డ్' ) );
పదకొండు. printf ('strcmp ('హలో\0\0\0','హలో\0ప్రపంచ') => %d n', strcmp ( 'హలో 0 0 0','హలో 0ప్రపంచం ' ));
12.
13. printf (' n--------------- n');
14.
పదిహేను. printf ('strncmp ('హలో వరల్డ్','హలో వరల్డ్', 5) => %d n', strncmp ( 'హలో వరల్డ్','హలో వరల్డ్',5 ));
16. printf ('strncmp ('హలో','హలో\0ప్రపంచ', 5) => %d n', strncmp ( 'హలో','హలో 0ప్రపంచం ',5 ));
17. printf ('strncmp ('హలో\0\0\0','హలో\0ప్రపంచ', 8) => %d n', strncmp ( 'హలో 0 0 0','హలో 0ప్రపంచం ',8 ));
18. printf ('strncmp ('హలో వరల్డ్','హలో వరల్డ్', 5) => %d n', strncmp ( 'హలో వరల్డ్','హలో వరల్డ్',5 ));
19.
ఇరవై. printf (' n--------------- n');
ఇరవై ఒకటి.
22. printf ('strcasecmp ('హలో వరల్డ్','హలో వరల్డ్') => %d n',strcasecmp( 'హలో వరల్డ్','హలో వరల్డ్' ));
2. 3. printf ('strcasecmp ('హలో','హలో\0ప్రపంచ') => %d n',strcasecmp( 'హలో','హలో 0ప్రపంచం ' ));
24. printf ('strcasecmp ('హలో వరల్డ్','హలో వరల్డ్') => %d n',strcasecmp( 'హలో వరల్డ్','హలో వరల్డ్' ));
25.
26. printf (' n--------------- n');
27.
28. printf ('strncasecmp ('హలో వరల్డ్','హలో వరల్డ్', 5) => %d n',strncasecmp( 'హలో వరల్డ్','హలో వరల్డ్',5 ) );
29. printf ('strncasecmp ('హలో','హలో\0ప్రపంచ', 5) => %d n',strncasecmp( 'హలో','హలో 0ప్రపంచం ',5 ));
30. printf ('strncasecmp ('హలో\0\0\0','హలో\0ప్రపంచ', 8) => %d n',strncasecmp( 'హలో 0 0 0','హలో 0ప్రపంచం ',8 ));
31. printf ('strncasecmp ('హలో వరల్డ్','హలో వరల్డ్', 5) => %d n',strncasecmp( 'హలో వరల్డ్','హలో వరల్డ్',5 ));
32.
33. printf (' n--------------- n');
3. 4.
35. printf ('మెమ్‌సిఎమ్‌పి ('హలో వరల్డ్','హలో వరల్డ్', 5) => %d n', emcmp ( 'హలో వరల్డ్','హలో వరల్డ్',5 ) );
36. printf ('మెమ్‌సిఎమ్‌పి ('హలో\0\0\0','హలో\0ప్రపంచ', 8) => %d n', emcmp ( 'హలో 0 0 0','హలో 0ప్రపంచం ',8 ));
37. printf ('మెమ్‌సిఎమ్‌పి ('హలో వరల్డ్','హలో వరల్డ్', 11) => %d n', emcmp ( 'హలో వరల్డ్','హలో వరల్డ్',పదకొండు ));
38.
39.తిరిగి 0; 40.}
ముగింపు:
కాబట్టి, ఈ ట్యుటోరియల్‌లో, తీగలను వివిధ మార్గాల్లో ఎలా పోల్చవచ్చో చూశాము. మేము చూసినట్లుగా, stringCompare () ఫంక్షన్ అసమాన స్ట్రింగ్‌ల కోసం -1 ని అందిస్తుంది, అయితే ఇది సరిదిద్దబడవచ్చు, తద్వారా ఇది సరిపోలని అక్షరం యొక్క ASCII విలువను అందిస్తుంది. మీరు మీ కోడ్‌లో ఉపయోగించవచ్చు, ఇది మీకు బాగా సరిపోతుంది.