Changes a wide-character string such that the changed string can
be passed to the wcscmp function and produce the same result as
passing the unchanged string to the wcscoll function.
Format
#include <wchar.h>
size_t wcsxfrm (wchar_t *ws1, const wchar_t *ws2, size_t
maxchar);
1 – Arguments
ws1, ws2
Pointers to wide-character strings.
maxchar
The maximum number of wide characters, including the null wide-
character terminator, allowed to be stored in s1.
2 – Description
The wcsxfrm function transforms the string pointed to by ws2
and stores the resulting string in the array pointed to by ws1.
No more than maxchar wide characters, including the null wide
terminator, are placed into the array pointed to by ws1.
If the value of maxchar is less than the required size to store
the transformed string (including the terminating null), the
contents of the array pointed to by ws1 is indeterminate. In such
a case, the function returns the size of the transformed string.
If maxchar is 0, then, ws1 is allowed to be a NULL pointer, and
the function returns the required size of the ws1 array before
making the transformation.
The wide-character string comparison functions, wcscoll and
wcscmp, can produce different results given the same two wide-
character strings to compare. This is because wcscmp does a
straightforward comparison of the code point values of the
characters in the strings, whereas wcscoll uses the locale
information to do the comparison. Depending on the locale, the
wcscoll comparison can be a multipass operation, which is slower
than wcscmp.
The wcsxfrm function transforms wide-character strings in such
a way that if you pass two transformed strings to the wcscmp
function, the result is the same as passing the two original
strings to the wcscoll function. The wcsxfrm function is useful
in applications that need to do a large number of comparisons on
the same wide-character strings using wcscoll. In this case, it
may be more efficient (depending on the locale) to transform the
strings once using wcsxfrm and then use the wcscmp function to do
comparisons.
3 – Return Values
x Length of the resulting string pointed to
by ws1, not including the terminating null
character.
(size_t) -1 Indicates that an error occurred. The function
sets errno to EINVAL - The string pointed to
by ws2 contains characters outside the domain
of the collating sequence.
4 – Example
#include <wchar.h>
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
/* This program verifies that two transformed strings, */
/* when passed through wcsxfrm and then compared, provide */
/* the same result as if passed through wcscoll without */
/* any transformation. */
#define BUFF_SIZE 20
main()
{
wchar_t w_string1[BUFF_SIZE];
wchar_t w_string2[BUFF_SIZE];
wchar_t w_string3[BUFF_SIZE];
wchar_t w_string4[BUFF_SIZE];
int errno;
int coll_result;
int wcscmp_result;
size_t wcsxfrm_result1;
size_t wcsxfrm_result2;
/* setlocale to French locale */
if (setlocale(LC_ALL, "fr_FR.ISO8859-1") == NULL) {
perror("setlocale");
exit(EXIT_FAILURE);
}
/* Convert each of the strings into wide-character format. */
if (mbstowcs(w_string1, "<a`>bcd", BUFF_SIZE) == (size_t)-1) {
perror("mbstowcs");
exit(EXIT_FAILURE);
}
if (mbstowcs(w_string2, "abcz", BUFF_SIZE) == (size_t)-1) {
perror("mbstowcs");
exit(EXIT_FAILURE);
}
/* Collate string 1 and string 2 and store the result. */
errno = 0;
coll_result = wcscoll(w_string1, w_string2);
if (errno) {
perror("wcscoll");
exit(EXIT_FAILURE);
}
else {
/* Transform the strings (using wcsxfrm) into */
/* w_string3 and w_string4. */
wcsxfrm_result1 = wcsxfrm(w_string3, w_string1, BUFF_SIZE);
if (wcsxfrm_result1 == ((size_t) - 1))
perror("wcsxfrm");
else if (wcsxfrm_result1 > BUFF_SIZE) {
perror("\n** String is too long **\n");
exit(EXIT_FAILURE);
}
else {
wcsxfrm_result2 = wcsxfrm(w_string4, w_string2, BUFF_SIZE);
if (wcsxfrm_result2 == ((size_t) - 1)) {
perror("wcsxfrm");
exit(EXIT_FAILURE);
}
else if (wcsxfrm_result2 > BUFF_SIZE) {
perror("\n** String is too long **\n");
exit(EXIT_FAILURE);
}
/* Compare the two transformed strings and verify that */
/* the result is the same as the result from wcscoll on */
/* the original strings. */
else {
wcscmp_result = wcscmp(w_string3, w_string4);
if (wcscmp_result == 0 && (coll_result == 0)) {
printf("\nReturn value from wcscoll() and return value"
" from wcscmp() are both zero.");
printf("\nThe program was successful\n\n");
}
else if ((wcscmp_result < 0) && (coll_result < 0)) {
printf("\nReturn value from wcscoll() and return value"
" from wcscmp() are less than zero.");
printf("\nThe program was successful\n\n");
}
else if ((wcscmp_result > 0) && (coll_result > 0)) {
printf("\nReturn value from wcscoll() and return value"
" from wcscmp() are greater than zero.");
printf("\nThe program was successful\n\n");
}
else {
printf("** Error **\n");
printf("\nReturn values are not of the same type");
}
}
}
}
}
Running the example program produces the following result:
Return value from wcscoll() and return value
from wcscmp() are less than zero.
The program was successful