Strängjämförelse C-programmering

En sträng i C-språket är en uppsättning tecken som avslutas med ett noll tecken (\ 0). Med hjälp av denna egenskap strängar jämförs.

Två strängar kan jämföras på olika sätt. I den här guiden kommer vi först att se en användardefinierad funktion för att jämföra två strängar, och sedan kommer vi att se några inbyggda biblioteksfunktioner som kan användas för att jämföra två strängar mycket enkelt. Så, låt oss komma igång.

Strängjämförelse med en användardefinierad funktion:

Vi skriver en funktion stringCompare () att jämföra strängar. Vi korsar strängarna och jämför varje karaktär i strängen tills vi når slutet av någon eller båda eller en felaktig matchning hittas. Om korsningen nås till slutet av båda strängarna, matchas strängarna; annars är strängarna inte matchade.

01. / * userDefinedFunction.c * /
02.
03. #omfatta
04.
05. int stringCompare (char str1 [], char str2 [])
06.
07. int i = 0;
08.
09. medan (str1 [i] == str2 [i])
10.
11. om (str1 [i] == '\ 0' || str2 [i] == '\ 0')
12. ha sönder;
13. i ++;
14.
15.
16. if (str1 [i] == '\ 0' && str2 [i] == '\ 0')
17. returnera 0;
18. annan
19. retur -1;
20.
21.
22.
23.
24. int main ()
25.
26. char str1 [30], str2 [30];
27.
28. printf ("Ange den första strängen:");
29. scanf ("% [^ \ n]% * c", str1);
30. printf ("Ange den andra strängen:");
31. scanf ("% [^ \ n]% * c", str2);
32.
33. if (stringCompare (str1, str2) == 0)
34. printf ("Strängarna är lika \ n");
35. annan
36. printf ("Strängarna är inte lika \ n");
37.
38. returnera 0; 39.

Här korsar vi strängarna med hjälp av en loop och en variabel i. När tecken är lika i samma position för båda strängarna, är värdet på i ökas med 1 (rad 13). Om tecken inte är lika (rad 09) eller när vi når slutet av strängen (rad 11), är while-slingan en paus. Efter stundslingan kontrollerar vi att båda strängkorsningarna nås till slutet eller inte (rad 16). Om korsningen nås till slutet av båda strängarna, så är strängarna lika annars.

Strängjämförelse med hjälp av inbyggda biblioteksfunktioner:

Följande biblioteksfunktioner kan användas för strängjämförelse. Alla funktioner deklareras i sträng.h rubrikfil.

strcmp () -funktion:

Denna funktion jämför två strängar som skickats till funktionen.

Syntax:

int strcmp (const char * str1, const char * str2)

Returvärde: Returnera 0 om strängarna är lika. Returnera ett negativt heltal om ASCII-värdet för den första oöverträffade karaktären i den första strängen är mindre än den andra strängen. Returnera ett positivt heltal om ASCII-värdet för den första oöverträffade karaktären i den första strängen är större än den andra strängen. Vissa system returnerar skillnad för ASCII-värdet för första felaktiga karaktär och vissa system returnerar -1 om ASCII-värdet för det första omatchade tecknet för den första strängen är mindre än den andra strängen och returnerar 1 om ASCII-värdet för den första omatchade karaktären den första strängen är större än den andra strängen.

Exempel	Returvärde	Förklaring
strcmp ( "Hello World", "Hello World" )	0	Två strängar är desamma.
strcmp ( “Hej”, ”Hej \ 0 Världen” )	0	Strängar jämförs till karaktären '\ 0'. Den första strängen slutar som standard med '\ 0' och den andra strängen innehåller tecknet '\ 0' efter 'Hej'.
strcmp ( “Hej \ 0 \ 0 \ 0", ”Hej \ 0 Världen" )	0	Strängar jämförs till karaktären '\ 0'.
strcmp ( "Hello World", "Hello World" )	Negativt heltal	ASCII-värdet för den första oöverträffade karaktären i den första strängen ('H') är mindre än den andra strängen ('h')
strcmp (“Hej värld”, “hej värld” )	Positivt heltal	ASCII-värdet för den första oöverträffade karaktären i den första strängen ('h') är större än den andra strängen ('H')

strncmp () -funktion:

Denna funktion liknar funktionen strcmp (), men här måste vi ange hur många byte som jämförs genom att skicka ett extra argument till funktionen.

Syntax:

int strncmp (const char * str1, const char * str2, size_t n)

Returvärde: Funktionen återgår 0 om den första n karaktärerna i de två strängarna är lika; annars returnerar det negativt eller positivt heltal beroende på tecknet på skillnaderna mellan det första felaktiga teckenets ASCII-värde.

Exempel	Returvärde	Förklaring
strncmp ( "Hello World", "Hello World", 5 )	0	De första 5 tecknen är desamma.
strncmp ( ”Hej”, ”Hej \ 0 Världen”, 5 )	0	De första 5 tecknen är desamma.
strncmp ( “Hej \ 0 \ 0 \ 0", ”Hej \ 0 Världen", 8 )	0	'\ 0' är efter de fem första tecknen i båda strängarna. Så jämförelsen stoppas efter 5 och inte 8.
strncmp ( "Hello World", "Hello World", 5 )	Negativt heltal	ASCII-värdet för den första oöverträffade karaktären i den första strängen ('H') är mindre än den andra strängen ('h')

strcasecmp () -funktion:

Denna funktion liknar funktionen strcmp (), men här är strängarna inte skiftlägeskänsliga.

Syntax:

int strcasecmp (const char * str1, const char * str2)

Returvärde: Samma som strcmp (), men strängar behandlas som fallet okänslig.

Exempel	Returvärde	Förklaring
strcasecmp ( "Hello World", "Hello World" )	0	Två strängar är desamma.
strcasecmp ( “Hej”, ”Hej \ 0 Världen” )	0	Strängar jämförs till karaktären '\ 0'. Den första strängen slutar som standard med '\ 0' och den andra strängen innehåller tecknet '\ 0' efter 'Hej'.
strcasecmp ( "Hello World", "Hello World" )	0	Strängar är *fallet okänslig.* Så "Hello World" och "Hello World" är desamma.

strncasecmp () -funktion:

Denna funktion liknar funktionen strncmp (), men här är strängarna inte skiftlägeskänsliga.

Syntax:

int strncasecmp (const char * str1, const char * str2)

Returvärde: Samma som strncmp (), när strängar behandlas som skiftlägeskänsliga.

Exempel	Returvärde	Förklaring
strncasecmp ( "Hello World", "Hello World", 5 )	0	De första 5 tecknen är desamma.
strncasecmp ( ”Hej”, ”Hej \ 0 Världen”, 5 )	0	De första 5 tecknen är desamma.
strncasecmp ( “Hej \ 0 \ 0 \ 0", ”Hej \ 0 Världen", 8 )	0	'\ 0' är efter de fem första tecknen i båda strängarna. Så jämförelsen stoppas efter 5 och inte 8.
strncasecmp ( "Hello World", "Hello World", 5 )	0	Strängar är *fallet okänslig.* Så "Hej" och "hej" är desamma.

memcmp () -funktion:

Denna funktion jämför två minnesblock byte för byte. Vi måste skicka två pekare av minnesblocken och antalet byte att jämföra.

Syntax:

int memcmp (const void * str1, const void * str2, size_t n)

Returvärde: Funktionen returnerar 0 om de två minnesblocken (n byte) är lika; annars returnerar den skillnaderna mellan det första felaktiga byteparet (byte tolkas som osignerade char-objekt och sedan främjas till int).

Exempel	Returvärde	Förklaring
memcmp ( "Hello World", "Hello World", 5 )	0	De första 5 tecknen är desamma.
memcmp ( “Hej \ 0 \ 0 \ 0", ”Hej \ 0 Världen", 8 )	Negativt heltal	De första 6 tecknen är desamma, men det sjunde tecknet är annorlunda. Här jämförelse slutade inte som *strncmp ()* när du får '\ 0' karaktär.
memcmp ( “Hello World”, “Hello World”, 11 )	Negativt heltal	ASCII-värdet för den första oöverträffade karaktären i den första strängen ('H') är mindre än den andra strängen ('h')

Exempel:

Följande är C-kodsexempel på alla funktioner som diskuterats.

01. / * stringCompare.c * /
02.
03. #omfatta
04. #omfatta
05.
06. int main ()
07.
08. printf ("strcmp (" Hello World "," Hello World ") =>% d \ n", strcmp ("Hello World", "Hello World"));
09. printf ("strcmp (" Hello "," Hello \\ 0 World ") =>% d \ n", strcmp ("Hello", "Hello \ 0 World"));
10. printf ("strcmp (" Hello World "," Hello World ") =>% d \ n", strcmp ("Hello World", "Hello World"));
11. printf ("strcmp (" Hello \\ 0 \\ 0 \\ 0 "," Hello \\ 0 World ") =>% d \ n", strcmp ("Hello \ 0 \ 0 \ 0", "Hello \ 0 Värld "));
12.
13. printf ("\ n --------------- \ n");
14.
15. printf ("strncmp (" Hello World "," Hello World ", 5) =>% d \ n", strncmp ("Hello World", "Hello World", 5));
16. printf ("strncmp (" Hello "," Hello \\ 0 World ", 5) =>% d \ n", strncmp ("Hello", "Hello \ 0 World", 5));
17. printf ("strncmp (" Hello \\ 0 \\ 0 \\ 0 "," Hello \\ 0 World ", 8) =>% d \ n", strncmp ("Hello \ 0 \ 0 \ 0", "Hello \ 0 World ", 8));
18. printf ("strncmp (" Hello World "," Hello World ", 5) =>% d \ n", strncmp ("Hello World", "Hello World", 5));
19.
20. printf ("\ n --------------- \ n");
21.
22. printf ("strcasecmp (" Hello World "," Hello World ") =>% d \ n", strcasecmp ("Hello World", "Hello World"));
23. printf ("strcasecmp (" Hello "," Hello \\ 0 World ") =>% d \ n", strcasecmp ("Hello", "Hello \ 0 World"));
24. printf ("strcasecmp (" Hello World "," Hello World ") =>% d \ n", strcasecmp ("Hello World", "Hello World"));
25.
26. printf ("\ n --------------- \ n");
27.
28. printf ("strncasecmp (" Hello World "," Hello World ", 5) =>% d \ n", strncasecmp ("Hello World", "Hello World", 5));
29. printf ("strncasecmp (" Hello "," Hello \\ 0 World ", 5) =>% d \ n", strncasecmp ("Hello", "Hello \ 0 World", 5));
30. printf ("strncasecmp (" Hello \\ 0 \\ 0 \\ 0 "," Hello \\ 0 World ", 8) =>% d \ n", strncasecmp ("Hello \ 0 \ 0 \ 0", "Hello \ 0 World ", 8));
31. printf ("strncasecmp (" Hello World "," hej värld ", 5) =>% d \ n", strncasecmp ("Hello World", "hej värld", 5));
32.
33. printf ("\ n --------------- \ n");
34.
35. printf ("memcmp (" Hello World "," Hello World ", 5) =>% d \ n", memcmp ("Hello World", "Hello World", 5));
36. printf ("memcmp (" Hello \\ 0 \\ 0 \\ 0 "," Hello \\ 0 World ", 8) =>% d \ n", memcmp ("Hello \ 0 \ 0 \ 0", "Hello \ 0 World ", 8));
37. printf ("memcmp (" Hello World "," Hello World ", 11) =>% d \ n", memcmp ("Hello World", "Hello World", 11));
38.
39. returnera 0; 40.

Slutsats:

Så i denna handledning har vi sett hur strängar kan jämföras på olika sätt. Som vi har sett returnerar stringCompare () -funktionen -1 för ojämna strängar, men detta kan modifieras så att den returnerar ASCII-värdet för felaktigt tecken. Du kan använda den i din kod, som passar dig bäst.