You can use the functions in this section to perform comparisons on the contents of strings and arrays. As well as checking for equality, these functions can also be used as the ordering functions for sorting operations. See section Searching and Sorting, for an example of this.
Unlike most comparison operations in C, the string comparison functions return a nonzero value if the strings are not equivalent rather than if they are. The sign of the value indicates the relative ordering of the first characters in the strings that are not equivalent: a negative value indicates that the first string is "less" than the second, while a positive value indicates that the first string is "greater".
The most common use of these functions is to check only for equality. This is canonically done with an expression like `! strcmp (s1, s2)'.
All of these functions are declared in the header file `string.h'.
memcmp
compares the size bytes of memory
beginning at a1 against the size bytes of memory beginning
at a2. The value returned has the same sign as the difference
between the first differing pair of bytes (interpreted as unsigned
char
objects, then promoted to int
).
If the contents of the two blocks are equal, memcmp
returns
0
.
wmemcmp
compares the size wide characters
beginning at a1 against the size wide characters beginning
at a2. The value returned is smaller than or larger than zero
depending on whether the first differing wide character is a1 is
smaller or larger than the corresponding character in a2.
If the contents of the two blocks are equal, wmemcmp
returns
0
.
On arbitrary arrays, the memcmp
function is mostly useful for
testing equality. It usually isn't meaningful to do byte-wise ordering
comparisons on arrays of things other than bytes. For example, a
byte-wise comparison on the bytes that make up floating-point numbers
isn't likely to tell you anything about the relationship between the
values of the floating-point numbers.
wmemcmp
is really only useful to compare arrays of type
wchar_t
since the function looks at sizeof (wchar_t)
bytes
at a time and this number of bytes is system dependent.
You should also be careful about using memcmp
to compare objects
that can contain "holes", such as the padding inserted into structure
objects to enforce alignment requirements, extra space at the end of
unions, and extra characters at the ends of strings whose length is less
than their allocated size. The contents of these "holes" are
indeterminate and may cause strange behavior when performing byte-wise
comparisons. For more predictable results, perform an explicit
component-wise comparison.
For example, given a structure type definition like:
struct foo { unsigned char tag; union { double f; long i; char *p; } value; };
you are better off writing a specialized comparison function to compare
struct foo
objects instead of comparing them with memcmp
.
strcmp
function compares the string s1 against
s2, returning a value that has the same sign as the difference
between the first differing pair of characters (interpreted as
unsigned char
objects, then promoted to int
).
If the two strings are equal, strcmp
returns 0
.
A consequence of the ordering used by strcmp
is that if s1
is an initial substring of s2, then s1 is considered to be
"less than" s2.
strcmp
does not take sorting conventions of the language the
strings are written in into account. To get that one has to use
strcoll
.
The wcscmp
function compares the wide character string ws1
against ws2. The value returned is smaller than or larger than zero
depending on whether the first differing wide character is ws1 is
smaller or larger than the corresponding character in ws2.
If the two strings are equal, wcscmp
returns 0
.
A consequence of the ordering used by wcscmp
is that if ws1
is an initial substring of ws2, then ws1 is considered to be
"less than" ws2.
wcscmp
does not take sorting conventions of the language the
strings are written in into account. To get that one has to use
wcscoll
.
strcmp
, except that differences in case are
ignored. How uppercase and lowercase characters are related is
determined by the currently selected locale. In the standard "C"
locale the characters @"A and @"a do not match but in a locale which
regards these characters as parts of the alphabet they do match.
strcasecmp
is derived from BSD.
wcscmp
, except that differences in case are
ignored. How uppercase and lowercase characters are related is
determined by the currently selected locale. In the standard "C"
locale the characters @"A and @"a do not match but in a locale which
regards these characters as parts of the alphabet they do match.
wcscasecmp
is a GNU extension.
strcmp
, except that no more than
size wide characters are compared. In other words, if the two
strings are the same in their first size wide characters, the
return value is zero.
wcscmp
, except that no more than
size wide characters are compared. In other words, if the two
strings are the same in their first size wide characters, the
return value is zero.
strncmp
, except that differences in case
are ignored. Like strcasecmp
, it is locale dependent how
uppercase and lowercase characters are related.
strncasecmp
is a GNU extension.
wcsncmp
, except that differences in case
are ignored. Like wcscasecmp
, it is locale dependent how
uppercase and lowercase characters are related.
wcsncasecmp
is a GNU extension.
Here are some examples showing the use of strcmp
and
strncmp
(equivalent examples can be constructed for the wide
character functions). These examples assume the use of the ASCII
character set. (If some other character set--say, EBCDIC--is used
instead, then the glyphs are associated with different numeric codes,
and the return values and ordering may differ.)
strcmp ("hello", "hello") => 0 /* These two strings are the same. */ strcmp ("hello", "Hello") => 32 /* Comparisons are case-sensitive. */ strcmp ("hello", "world") => -15 /* The character'h'
comes before'w'
. */ strcmp ("hello", "hello, world") => -44 /* Comparing a null character against a comma. */ strncmp ("hello", "hello, world", 5) => 0 /* The initial 5 characters are the same. */ strncmp ("hello, world", "hello, stupid world!!!", 5) => 0 /* The initial 5 characters are the same. */
strverscmp
function compares the string s1 against
s2, considering them as holding indices/version numbers. Return
value follows the same conventions as found in the strverscmp
function. In fact, if s1 and s2 contain no digits,
strverscmp
behaves like strcmp
.
Basically, we compare strings normally (character by character), until we find a digit in each string - then we enter a special comparison mode, where each sequence of digits is taken as a whole. If we reach the end of these two parts without noticing a difference, we return to the standard comparison mode. There are two types of numeric parts: "integral" and "fractional" (those begin with a '0'). The types of the numeric parts affect the way we sort them:
strverscmp ("no digit", "no digit") => 0 /* same behaviour as strcmp. */ strverscmp ("item#99", "item#100") => <0 /* same prefix, but 99 < 100. */ strverscmp ("alpha1", "alpha001") => >0 /* fractional part inferior to integral one. */ strverscmp ("part1_f012", "part1_f01") => >0 /* two fractional parts. */ strverscmp ("foo.009", "foo.0") => <0 /* idem, but with leading zeroes only. */
This function is especially useful when dealing with filename sorting, because filenames frequently hold indices/version numbers.
strverscmp
is a GNU extension.
memcmp
, derived from BSD.
Go to the first, previous, next, last section, table of contents.