Embed Size (px)
DESCRIPTION
C FUNCTION
Citation preview
Standard C
assert.h
complex.h
ctype.h
fenv.h
float.h
locale.h
math.h
setjmp.h
signal.h
stdarg.h
stddef.h
stdio.h
stdlib.h
string.h
time.h
Standard C++
IOstream
new
Win32
gc.h
DOS, DOS32, Win16
bios.h
cerror.h
disp.h
dos.h
dos.h part 2
emm.h
handle.h
int.h
msmouse.h
sound.h
swap.h
tsr.h
winio.h
Other C
bitops.h
conio.h
controlc.h
direct.h
fltpnt.h
io.h
page.h
process.h
search.h
sys\stat.h
tabsize.h
trace.h
utime.h
unmangle.h
util.h
Other C++
regexp.h
class complex
Gadgets powered by Google
string.h
memchr, _fmemchr
memcmp, _fmemcmp
_memccpy, _fmemccpy
memcpy, _fmemcpy
_memicmp, _fmemicmp
memmove, _fmemmove
memset, _fmemset, setmem
_movedata
movmem
_strdup, _fstrdup
_stricmp, _fstricmp
_strlwr, _fstrlwr
strncmpi, strncmpl, _strnicmp, _fstrnicmp
_strnset _fstrnset
_strrev, _fstrrev
_strset, _fstrset
_strtime
_strupr, _fstrupr
_swab
stpcpy
strcat, _fstrcat
strchr, _fstrchr
strcmp Functions
strcoll
strcpy, _fstrcpy
strcspn, _fstrcspn
strerror
strlen, _fstrlen
strncat, _fstrncat
strncmp, _fstrncmp
strncmpi, strncmpl, _strnicmp, _fstrnicmp
strncpy, _fstrncpy
strpbrk, _fstrpbrk
strrchr, _fstrrchr
strspn, _fstrspn
strstr, _fstrstr
strtok, _fstrtok
strxfrm
_sys_errlist
_sys_nerr
memchr, _fmemchr
Header string.h
memory.h
Prototype void *memchr(const void *buf1, int c, size_t count);
void __far *__far _fmemchr(const void __far *buf1, int c, size_t
count);
Description
memchr searches in the buffer, buf, for a byte with the value of c. The search continues
for count bytes or until a value of c is encountered. _fmemchr is a model-independent
(large-model) form of the memchr function.
Synonym
Function: fmemchr
Return Value
memchr and _fmemchr return a pointer (or a far pointer) to the first location of c in buf.
Otherwise, these functions return NULL.
Compatibility memchr: DOS, Windows 3.x, Phar Lap/ DOSX, Win32
_fmemchr: DOS, Windows 3.x, Phar Lap/ DOSX, Win32
See Also memcpy
memcmp
memset
strcmp Functions
strcat
_strset
strrchr
Example /* Example for memchr */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char test[] = "Test String";
void main ()
{
char search = 'S', *result;
printf (" The test string is \"% s\"\n", test);
printf (" memchr() looking for 'S'\n");
result = memchr(test, search, 12);
if (result != NULL)
printf (" Character 'S' found at (% d)\n",
result -test + 1);
else
printf (" Character 'S' was not found in
search string\n");
}
Output The test string is "Test String"
memchr() looking for 'S'
Character 'S' found at (6)
memcmp, _fmemcmp
Header string.h
memory.h
Prototype int memcmp(const void *buf1, const void *buf2, size_t count); int __far
_fmemcmp(const void __far *buf1, const void __far *buf2, size_t count);
Description memcmp compares each successive byte pointed to by pointer buf1 with the
corresponding byte pointed to by buf2 until they do not have the same value or until the
number of bytes specified in count have been compared. memcmp returns an integer less
than, equal to, or greater than zero, depending on whether the last byte compared in the
buffer pointed to by buf1 is less than, equal to, or greater than the corresponding byte
pointed to by buf2.
_fmemcmp is a model-independent (large-model) form of the memcmp function.
Synonym
Function: fmemcmp
Return Value
Both functions return the following types of values: less than 0 (if buf1 is less than buf2),
0 (if buf1 equals buf2), or greater than 0 (if buf1 is greater than buf2.)
Compatibility memcmp: DOS, Windows 3. x, Phar Lap/ DOSX, Win32
_fmemcmp: DOS, Windows 3.x, Phar Lap/ DOSX, Win32
See Also
memset
_memicmp
memchr
strcat
strrchr
strcmp Functions
Example /* Example for memcmp */
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
char test1[] = "This is test string 1";
char test2[] = "This is test string 2";
void main ()
{
int result;
printf (" Test string 1 is \"% s\"\n", test1);
printf (" Test string 2 is \"% s\"\n", test2);
printf ("\nComparing 1 and 2 for 20 bytes\n");
result = memcmp(test1, test2, 20);
if (! result)
printf (" 1 and 2 are");
else
printf (" 1 and 2 are not");
printf (" the same for 20 bytes\n");
printf ("\nComparing 1 and 2 for 21 bytes\n");
result = memcmp(test1, test2, 21);
if (! result)
printf (" 1 and 2 are");
else
printf (" 1 and 2 are not");
printf (" the same for 21 bytes\n");
}
Output Test string 1 is "This is test string 1"
Test string 2 is "This is test string 2"
Comparing 1 and 2 for 20 bytes
1 and 2 are the same for 20 bytes
Comparing 1 and 2 for 21 bytes
1 and 2 are not the same for 21 bytes
_memccpy, _fmemccpy
Header string.h
memory.h
Prototype void *_memccpy(void *dest, void *src, int c, unsigned int count);
void __far *__far _fmemccpy(void __far *dest, void __far *src, int c,
unsigned int count);
Description
These functions copy a block of memory from src to dest. The copy operation stops when
either the character c has been copied, or count bytes have been copied.
The _fmemccpy function is a model-independent (large-model) form of the _memccpy y
function.
Synonym
Functions: memccpy, fmemccpy
Return Value
If the character c is copied, these functions return a pointer to the byte in dest
immediately following the byte that contains c. If c is not copied, these functions return
NULL.
Compatibility
_memccpy: DOS, Windows 3.x, Phar Lap/ DOSX, Win32
_fmemccpy: DOS, Windows 3.x, Phar Lap/ DOSX, Win32
See Also memchr
memcpy
memset
Example /* Example of _memccpy */
#include <stdio.h>
#include <string.h>
char string[60] = "Now is the time for all good
men";
void main ()
{
char buf[61];
char *dest;
dest = _memccpy (buf, string, 'l', 60);
if (dest != NULL)
*dest = '\0';
printf (" Should have copied to the first
\" l\" or until the end, ");
printf (" which evercame first.
Result is:\n% s\n", buf);
}
Output Should have copied to the first "l" or until the end, which evercame
first. Result is:
Now is the time for al
memcpy, _fmemcpy
Header string.h
memory.h
Prototype void *memcpy(void *buf1, const void *buf2, size_t count);
void __far *__far _fmemcpy(void __far *buf1, const void __far *buf2,
size_t count);
Description
memcpy copies the number of characters specified in count from buf2 to buf1. buf1 is
returned. Although memcpy is faster than memmove, memcpy does not ensure that the
source bytes in the overlapping region are copied before being overwritten. In this
situation, use memmove.
Synonym Function: fmemcpy
Return Value Both functions return buf1.
Compatibility _memcpy: DOS, Windows 3. x, Phar Lap/ DOSX, Win32
_fmemcpy: DOS, Windows 3. x, Phar Lap/ DOSX, Win32
See Also
memcmp
memset
memcmp
memmove
strcmp Functions
strcat
_strset
strrchr
Example /* Example for memcpy */
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
char test1[] = "Sample String.";
char test2[15];
void main ()
{
printf (" Copying test1 to test2\n");
memcpy (test2, test1, 15);
printf (" Result is \"% s\"\n", test2);
}
Output Copying test1 to test2
Result is "Sample String."
_memicmp, _fmemicmp
Header
string.h
memory.h
Prototype int _memicmp(const void *buf1, const void *buf2, size_t count);
int __far _fmemicmp(const void __far *buf1, const void __far *buf2,
size_t count);
Description These functions compare the first count characters from buf1 with those in buf2 on a byte
for byte basis, without reference to the case of the letters being compared. Uppercase and
lowercase letters are considered to be equivalent. All uppercase (capital) letters in both
buf1 and buf2 are converted to lowercase before the comparison is done. This function is
identical to memcmp except it ignores case.
Function _fmemicmp is a model-independent (large-model) form of the _memicmp
function.
Synonym
Function: fmemicmp
Return Value
These functions return an integer value which depends on the relationship of buf1 to
buf2, as follows:
Returns a value. . ./if. . .
<0
buf1 less than buf2
=0
buf1 identical to buf2
>0
buf1 greater than buf2
Compatibility _memicmp: DOS, Windows 3. x, Phar Lap/ DOSX, Win32
_fmemicmp: DOS, Windows 3. x, Phar Lap/ DOSX, Win32
See Also
memchr
memcpy
memcmp
memset
Example /* Example of _memicmp */
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
char test1[] = "this is test string 1";
char test2[] = "THIS IS TEST STRING 2";
void main ()
{
int result;
printf (" Test string 1 is \"% s\"\n", test1);
printf (" Test string 2 is \"% s\"\n", test2);
printf ("\nComparing 1 and 2 for 20 bytes\n");
result = _memicmp(test1, test2, 20);
if (! result)
printf (" 1 and 2 are");
else
printf (" 1 and 2 are not");
printf (" the same for 20 bytes\n");
printf ("\nComparing 1 and 2 for 21 bytes\n");
result = _memicmp(test1, test2, 21);
if (! result)
printf (" 1 and 2 are");
else
printf (" 1 and 2 are not");
printf (" the same for 21 bytes\n");
}
Output Test string 1 is "this is test string 1"
Test string 2 is "THIS IS TEST STRING 2"
Comparing 1 and 2 for 20 bytes
1 and 2 are the same for 20 bytes
Comparing 1 and 2 for 21 bytes
1 and 2 are not the same for 21 bytes
memmove, _fmemmove
Header string.h
Prototype void *memmove(void *buf1, const void *buf2, size_t count);
void __far *__far _fmemmove(void __far *buf1, const void __far *buf2,
size_t count);
Description memmove copies the number of characters specified in count from buf2 to buf1.
memmove, slower than memcpy, can handle overlapping moves.
_fmemmove is a model-independent (large-model) form memmove.
Synonym
Function: fmemmove
Return Value
buf1 is returned.
Compatibility
memmove: DOS, Windows 3. x, Phar Lap/ DOSX, Win32
_fmemmove: DOS, Windows 3.x, Phar Lap/ DOSX, Win32
See Also memcpy
Example /* Example for memmove */
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
char test1[] = "Sample String.";
char test2[15];
void main ()
{
printf (" Copying test1 to test2\n");
memmove (test2, test1, 15);
printf (" Result is \"% s\"\n", test2); }
Output Copying test1 to test2
Result is "Sample String."
memset, _fmemset, setmem
Header string.h
memory.h
Prototype void *memset(void *buf, int val, size_t count);
void __far *__far _fmemset(void __far *buf, int val, size_t count);
void setmem(void *buf, size_t count, int val);
Description
memset sets the first count characters pointed to by buf to the value specified by val. It
returns buf. Function_fmemset is a model-independent (large-model) form memset.
setmem is just a macro for memset, reversing the second and third parameters.
Synonym
Function: fmemset
Return Value
Both functions return buf.
Compatibility
memset: DOS, Windows 3. x, Phar Lap/ DOSX, Win32
_fmemset: DOS, Windows 3. x, Phar Lap/ DOSX, Win32
See Also strcat
_strset
strrchr
strcmp Functions
Example /* Example for memset */
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
char buffer[20];
void main ()
{
printf (" buffer before memset: \"% s\"\n", buffer);
memset (buffer, 'x', 6);
printf (" buffer after memset: \"% s\"\n",
buffer);
}
Output buffer before memset:
"" buffer after memset: "xxxxxx"
_movedata
Header
string.h
Prototype void _movedata(unsigned srcseg, unsigned srcoff, unsigned dstseg,
unsigned dstoff, size_t numbytes);
Description
The _movedata function moves numbytes bytes from the source address specified by
segment srcseg and offsets srcoff to the destination address specified by segment dstseg
and offset dstoff.
Use _movedata to move data between segments. For normal intra-segment movement of
data, use memcpy or memmove instead. _movedata does not handle overlapping moves
correctly.
Synonym
Function: movedata
Return Value
None
Compatibility
DOS Windows 3.x Phar Lap DOSX Win32
See Also
_FP Functions
memcpy
memmove
Example /* Example of _movedat */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dos.h>
void main ()
{
char __far *src = "this is a test";
char __far *dest;
if ((dest = malloc (80)) != NULL)
{
_movedata (_FP_SEG(src), _FP_OFF(src),
_FP_SEG(dest), _FP_OFF(dest),
strlen(src) + 1);
printf (" The source is %p and contains
\"% s\"\n", src, src);
printf (" The destination is %p and contains
\"% s\"\n", dest, dest);
free(dest);
}
}
Output The source is 207B: 0042 and contains "this is a test"
The destination is 307C: 01CA and contains "this is a test"
movmem
Header memory.h
Prototype void movmem(const void *src, void *dest, size_t length);
Description
The movmem function moves a block of data from src to dest. The length argument
indicates the number of bytes to copy. This function moves the data correctly, even if the
blocks overlap.
Return Value
None
Compatibility
DOS Windows 3.x Phar Lap DOSX Win32
See Also
_movedata
Example /* Example for movmem */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mem.h>
void main ()
{
char *src = "This is a test";
char *dest;
int len;
len = strlen (src) + 1;
dest = malloc (len);
movmem(src, dest, len);
printf(" The source string is \"% s\".\nThe
destination string is \"% s\"\n", src, dest);
}
Output The source string is "This is a test".
The destination string is "This is a test"
_strdup, _fstrdup
Header string.h
Prototype char *_strdup(const char *string);
char __far *__far _fstrdup(
const char __far *string);
Description The _strdup and _fstrdup functions allocate memory with a call to malloc, copy the string
into this memory, and return a pointer to the memory containing the string. The functions
return NULL if memory cannot be allocated.
The _fstrdup function provides additional control over the heap used for string
duplication. The function returns a far pointer to a copy of the string allocated from the
far heap.
Synonym Functions: strdup, fstrdup
Return Value All functions return a pointer to the allocated memory containing the string. NULL is
returned if memory cannot be allocated.
Compatibility
strdup: DOS Windows 3.x Phar Lap/ DOSX Win32
_fstrdup: DOS Windows 3.x Phar Lap/ DOSX Win32
Example /* Example of _strdup */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void main ()
{
char *str1 = "This is a test string";
char *str2;
printf ("The original string: \"% s\"\n", str1);
str2 = _strdup (str1);
printf ("The string from _strdup(): \"% s\"\n", str2);
}
Output The original string: "This is a test string"
The string from _strdup(): "This is a test string"
_stricmp, _fstricmp
Header string.h
Prototype int _stricmp(const char *string1, const char *string2);
int __far _fstricmp(const char __far *string1, const char __far
*string2);
Description The _stricmp function compares the lowercase versions of the strings specified in string1
and string 2. The comparison begins with the first character of each string and continues
until corresponding characters differ or until the ends of the strings are reached.
The _fstricmp function is a model-independent (large model) form of _stricmp. The
functions are identical, except that the _fstricmp arguments are far pointers.
Synonym
Function: stricmp, fstricmp
Return Value
Returns... if...
< 0 string1 is less than string2
= 0 string1 is equal to string2
> 0 string1 is greater than string2
Compatibility
stricmp: DOS, Windows 3.x, Phar Lap/ DOSX, Win32
_fstricmp: DOS, Windows 3.x, Phar Lap/ DOSX, Win32
See Also strcat
strcpy
strncat
strncmp
strncpy
strncmpi
strncmpl
_strnicmp
Example See strcmp
_strlwr, _fstrlwr
Header string.h
Prototype char *_strlwr(char *string);
char __far *__far _fstrlwr(char __far *string);
Description The _strlwr function converts upper case characters in the string argument to lower case.
The _fstrlwr function is a model-independent (large model) form of _strlwr. They are
identical, except that the _fstrlwr argument and return values are far pointers.
Synonym Function: strlwr, fstrlwr
Return Value Return a pointer to the converted string.
Compatibility strlwr: DOS Windows 3.x Phar Lap/ DOSX Win32
_fstrlwr: DOS Windows 3.x Phar Lap/ DOSX Win32
Example /* Example of _strlwr */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void main ()
{
char *str = "Mixed Case String";
printf (" The original string: \"% s\"\n", str);
_strlwr (str);
printf (" The string after _strlwr:
\"% s\"\n", str);
}
Output The original string: "Mixed Case String"
The string after _strlwr: "mixed case string"
strncmpi, strncmpl, _strnicmp, _fstrnicmp
Header string.h
Prototype int strncmpi(const char *str1, const char *str2, size_t n);
int strncmpl(char *str1, char *str2, int n);
int _strnicmp(const char *str1, const char *str2, size_t n);
int __far _fstrnicmp(const char __far *str1, const char __far *str2,
size_t n);
Description These functions are case-insensitive versions of strncmp. The first n characters of each
string are compared. If either is less than n characters long, the comparison terminates;
the return value is the result of the comparison up until the termination. The returned
value is zero for a successful match; a positive or negative number represents the
difference in the mismatched characters.
The _fstrnicmp function is a model-independent (large model) form of _strnicmp. They
are identical, except that the _fstrnicmp arguments and return values are far.
Synonym Function: strnicmp
Return Value
Returns... /if...
< 0
string1 is less than string2
= 0
string1 is equal to string2
> 0
string1 is greater than string2
Compatibility _strn*/ strn*: DOS, Windows 3.x, Phar Lap/ DOSX, Win32
_fstrnicmp: DOS, Windows 3.x, Phar Lap/ DOSX, Win32
See Also
strncmp
strcmp Functions
_strnset _fstrnset
Header string.h
Prototype char *_strnset(char *string, int ch, size_t n);
char __far *__far _fstrnset(char __far *string, int ch, size_t n);
Description These functions set, at most, n characters of string to ch (converted to char) and return a
pointer to the altered string. If n is greater than the length of string, the length of string is
used in place of n. The _fstrnset function is a model-independent (large model) form of
_strnset. They are identical, except that the _fstrnset arguments and return values are far.
Synonym
Functions: strnset, fstrnset
Return Value
These functions return a pointer to a string.
Compatibility
_strnset: DOS Windows 3.x Phar Lap/ DOSX Win32
_fstrnset: DOS Windows 3.x Phar Lap/ DOSX Win32
See Also _strset
Example /* Example for _strnset */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void main ()
{
char *str = "_strnset Example string";
printf (" This is the string: \"% s\"\n", str);
printf (" After _strnset(str, 'x', 10):
\"% s\"\n", _strnset(str, 'x', 10));
printf (" After _strnset(str, 'x', 100):
\"% s\"\n", _strnset(str, 'x', 100));
}
Output This is the string: "_strnset Example string"
After _strnset(str, 'x', 10)
: "xxxxxxxxxxxample
string"
After _strnset(str, 'x', 100):
"xxxxxxxxxxxxxxxxxxxxxxx"
_strrev, _fstrrev
Header
string.h
Prototype char *_strrev(char *string);
char __far *__far _fstrrev(char __far* string);
Description
These functions reverse the order of characters in string, leaving a terminating '\0' at the
end.
The _fstrrev function is a model-independent (large model) form of strrev. These
functions are identical, except that the _fstrrev argument and return value are far pointers.
Synonym
Function: strrev, fstrrev
Return Value
Both functions return a pointer to the altered string.
Compatibility
_strrev: DOS Windows 3.x Phar Lap/ DOSX Win32 _fstrrev: DOS Windows 3.x Phar
Lap/ DOSX Win32
Example /* Example for _strrev */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void main()
{
char str[80];
printf (" Enter a string: ");
gets(str);
printf ("\nThe results of _strrev are:\n
\"% s\"\n", _strrev(str));
}
Output Enter a string: So much time, so little to do
The results of _strrev are:
"od ot elttil os ,emit hcum oS"
_strset, _fstrset
Header string.h
Prototype char *_strset(char *string, int ch);
char __far *__far _fstrset(char __far *string, int ch);
Description These functions set all the characters in string to ch except the terminating null character.
The _fstrset function is a model-independent (large model) form of _strset. These
functions are identical, except that the _fstrset pointer arguments and return value are far
pointers.
Synonym Function: strset, fstrset
Return Value These functions return a pointer to the altered string.
Compatibility _strset: DOS Windows 3.x Phar Lap/ DOSX Win32 _fstrset: DOS Windows 3.x Phar
Lap/ DOSX Win32
Example /*
Example for _strset
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void main ()
{
char *str = "_strset Example string";
printf (" This is the string: \"% s\"\n", str);
printf (" After _strset(str, 'x'): \"% s\"\n",
_strset(str, 'x'));
}
Output This is the string: "_strset Example string"
After _strset(str, 'x'): "xxxxxxxxxxxxxxxxxxxxxx"
_strtime
Header time.h
Prototype char *_strtime(char *timestr);
Description
The _strtime function copies the current time to the buffer pointed to by the timestr
argument.
The time string has the following format:
hh: mm: ss
where hh represents the hour in 24-hour notation, mm represents the minutes past the
hour, and ss represents the seconds.
The buffer must be at least 9 bytes long.
Return Value A pointer to the text string.
Compatibility DOS Windows 3.x Phar Lap DOSX Win32
See Also asctime
ctime
localtime
Example See _strdate
_strupr, _fstrupr
Header
string.h
Prototype char *_strupr(char *string);
char __far *__far _fstrupr(char *string);
Description
These functions convert lowercase characters in string to uppercase.
The _fstrupr function is a model-independent (large model) form of _strupr. They are
identical, except that the _fstrupr argument and the return value are far pointers.
Synonym Functions: strupr, fstrupr
Return Value Returns string.
Compatibility strupr: DOS Windows 3.x Phar Lap/ DOSX Win32 _fstrupr: DOS Windows 3.x Phar
Lap/ DOSX Win32
See Also
_strlwr
_tolower
_toupper
Example /* Example of _strupr */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void main ()
{
char *str = "Mixed Case String";
printf (" The original string: \"% s\"\n", str);
_strupr (str);
printf (" The string after _strupr:
\"% s\"\n", str);
}
Output The original string: "Mixed Case String"
The string after _strupr: "MIXED CASE STRING"
_swab
Header stdlib.h
Prototype void _swab(char *source, char *destination, int n);
Description
The _swab function copies n bytes from source, swapping each pair of adjacent bytes.
destination stores the converted string. The integer n should be even as pairs of characters
are swapped.
Synonym
Function: swab
Return Value
None
Compatibility
DOS Windows 3.x Phar Lap DOSX Win32
Example /* Example for _swab */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void main()
{
char str[80];
char dst[80];
int len;
printf (" Enter a string: ");
gets (str);
strcpy (dst, str);
len = (strlen (str));
len -= len % 2;
_swab (str, dst, len);
printf ("\nThe results of _swab are:\n
\"% s\"\n", dst);
}
Output Enter a string: It's a Push-me-pull-you
The results of _swab are:
"tIs'a P su-hemp-lu-loyu"
stpcpy
Header
string.h
Prototype char *stpcpy(char *s1, const char *s2);
Description The stpcpy function copies the string pointed to by s2 into the buffer pointed to by s1. It
is similar to the normal library strcpy function except that it returns a pointer to the end of
the copied string. This is useful when concatenating strings.
Return Value A pointer to the end of the copied string.
Compatibility DOS Windows 3.x Phar Lap DOSX Win32
See Also strcpy
Example /* Example for stpcpy */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void main ()
{
char s1[8], *s2 = "Eu", *s3 = "re",
*s4 = "ka";
stpcpy (stpcpy (stpcpy (stpcpy (s1, s2),
s3), s4), "!");
printf ("This is the string from stpcpy
\"% s\"\n", s1);
}
Output This is the string from stpcopy "Eureka!"
strcat, _fstrcat
Header
string.h
Prototype char *strcat(char *string1, const char *string2);
char __far *__far _fstrcat(char __far *string1, const char __far
*string2);
Description The strcat function appends a copy of string2 onto the end of string1 and terminates the
resulting string with a null character. The application code is responsible for ensuring that
there is enough space in the string to hold the result.
The _fstrcat function is a model-independent (large model) form of strcat. These
functions are identical, except that the _fstrcat arguments and return values are far
pointers.
Synonym Function: fstrcat
Return Value Both functions return a pointer to string1.
Compatibility strcat: DOS Windows 3.x Phar Lap/ DOSX Win32 _fstrcat: DOS Windows 3.x Phar Lap/
DOSX Win32
Example /* Example of strcat */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void main ()
{
char str1[50] = "This is string 1...";
char str2[50] = "And this is string 2.";
printf (" String 1: \"% s\"\nString 2:
\"% s\"\n", str1, str2);
printf (" Result of strcat: \"% s\"\n",
strcat(str1, str2));
}
Output String 1: "This is string 1..."
String 2: "And this is string 2."
Result of strcat: "This is string 1... And this is string 2."
strchr, _fstrchr
Header string.h
Prototype char *strchr(const char *string, int ch);
char __far *__far _fstrchr(const char __far *string, int ch);
Description The strchr function finds the first occurrence of the character ch in string and returns a
pointer to this character. strchr is identical to the function index (which is no longer in
this library).
The _fstrchr function is a model-independent (large model) form of strchr. These
functions are identical, except that the _fstrchr arguments and return values are far.
Synonym Function: fstrchr
Return Value Pointer to character ch. A NULL pointer is returned if not found.
Compatibility strchr: DOS Windows 3.x Phar Lap/ DOSX Win32
_fstrch: DOS Windows 3.x Phar Lap/ DOSX Win32
See Also memchr
Example /* Example of strchr */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void main ()
{
char *str = "string example";
char *res;
printf (" Looking for 'x' in
string \"% s\"\n", str);
res = strchr(str, 'x');
if (! res)
printf (" 'x' was not found in
the search string\n");
else
printf (" 'x' was found in the search
string at offset %d\n", res -str);
}
Output Looking for 'x' in string "string example"
'x' was found in the search string at offset 8
strcmp Functions
Header
string.h
Prototype int strcmp(const char *string1, const char *string2);
int __far _fstrcmp(const char __far *string1, const char __far
*string2);
int _strcmpi(const char *string1, const char *string2);
int strcmpl(const char *string1, const char *string2);
int __far _fstrcmpl(const char __far *string1, const char __far
*string2);
Description
strcmp, _strcmpi, and strcmpl compare two strings, character by character. strcmp is case
sensitive whereas strcmpi and strcmpl are not.
The _fstrcmp and _fstrcmpl functions are model-independent (large model) form of
strcmp and strcmpl. These functions are identical, except that the _fstrcmp and _fstrcmpl
arguments are far pointers.
Synonym
Functions: fstrcmp, strcmpi
Return Value
Return.../if ... <0
stiring1 is less than string2
=0
string1 is equal to string2
>0
string1 greater than string2
Compatibility strcmp*: DOS, Windows 3.x, Phar Lap/ DOSX, Win32
_fstrcmp*: DOS, Windows 3.x, Phar Lap/ DOSX, Win32
See Also
memcmp
Example /* Example of strcmp
Also demonstrates _stricmp
*/
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
char test1[] = "this is a test string";
char test2[] = "THIS IS A TEST STRING";
void main ()
{
int result;
printf (" Test string 1 is \"% s\"\n", test1);
printf (" Test string 2 is \"% s\"\n", test2);
printf ("\nComparing 1 and 2 using strcmp\n");
result = strcmp(test1, test2);
if (! result)
printf (" string 1 is equal to string 2\n");
else if (result < 0)
printf (" string 1 is less than
string 2\n");
else
printf (" string 1 is greater than
string 2\n");
printf ("\nComparing 1 and 2 using
_stricmp\n");
result = _stricmp(test1, test2);
if (! result)
printf (" string 1 is equal to string 2\n");
else if (result < 0)
printf (" string 1 is less than string 2\n");
else
printf (" string 1 is greater than
string 2\n");
}
Output Test string 1 is "this is a test string"
Test string 2 is "THIS IS A TEST STRING"
Comparing 1 and 2 using strcmp
string 1 is greater than string 2
Comparing 1 and 2 using _stricmp
string 1 is equal to string 2
strcoll
Header string.h
Prototype
int strcoll(const char *string1, const char *string2);
Description
The strcoll function compares the two strings specified in the string1 and string2
arguments, using the collating sequence specified by the setlocale function. Then, the
function returns a value indicating the relationship between the strings.
Return Value
The following values are returned:
Returns.../if ...
<0
string1 is less than string2
0
string1 is equal to string2
>0
string1 is greater than string2
Compatibility DOS Windows 3.x Phar Lap DOSX Win32
See Also setlocale
strcmp Functions
strcpy, _fstrcpy
Header string.h
Prototype char *strcpy(char *string1, const char *string2);
char __far *__far _fstrcpy(char __far *string1, const __far char
*string2);
Description strcpy copies string2, including the terminating null character, into the object pointed to
by string1. The _fstrcpy function is a model-independent (large model) form of strcpy.
Synonym
Function: fstrcpy
Return Value
Returns the new string pointed to by string1.
Compatibility
strcpy: DOS Windows 3.x Phar Lap/ DOSX Win32
_fstrcpy: DOS Windows 3.x Phar Lap/ DOSX Win32
See Also stpcpy
Example /* Example of strcpy */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void main ()
{
char str1[50] = "This is the first string";
char str2[50] = "This is the second string";
printf (" str1 = \"% s\"\n", str1);
printf (" str2 = \"% s\"\n", str2);
strcpy (str1, str2);
printf ("\nAfter strcpy(str1, str2)...\n\n");
printf (" str1 = \"% s\"\n", str1);
printf (" str2 = \"% s\"\n", str2);
{
Output str1 = "This is the first string"
str2 = "This is the second string"
After strcpy(str1, str2)...
str1 = "This is the second string"
str2 = "This is the second string"
strcspn, _fstrcspn
Header string.h
Prototype size_t strcspn(const char *string1, const char string2);
size_t __far _fstrscpn(const char __far *string1, const char __far
*string2);
Description strcspn searches string1 for the first occurrence of a character belonging to the set of
characters in string2 and returns the index of this character. This value is equivalent to the
length of the initial substring of string1 consisting entirely of charcters not in string2.
The _fstrcspn function is a model-independent (large model) form of strcspn. These
functions are identical, except that the _fstrcspn arguments and return values are far.
Synonym Function: fstrcspn
Return Value Both functions return the length of the initial segment of string1 that consists of
characters not found in string2. If string1 begins with a character from string2, strcspn
returns 0. If no character in string2 appears in string1, then the total length of string1, not
counting the null character terminator, is returned.
Compatibility
strcspn: DOS, Windows 3.x, Phar Lap/ DOSX, Win32
_fstrcspn: DOS, Windows 3.x, Phar Lap/ DOSX, Win32
Example /* Example of strcspn */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void main ()
{
char *str = "The quick brown fox jumped
over the lazy dog";
char srch[80];
unsigned res;
printf (" The search string is:
\n \"% s\"\n\n", str);
printf (" Enter the set of characters
for strcspn(): ");
gets (srch);
res = strcspn (str, srch);
if (res == strlen (str))
printf ("\nSorry but none of those
characters where found.\n");
else
printf ("\nMatching character found
at offset %d\n", res);
}
Output The search string is:
"The quick brown fox jumped over the lazy dog"
Enter the set of characters for strcspn(): qzy
Matching character found at offset 4
strerror
Header string.h
Prototype char *strerror(int errornum);
Description The strerror function gets a system error message asociated with an error number. It maps
errornum to an error message string and returns a pointer to that string.
strerror does not print the error message. To print the message returned to stderr, use a
print statement such as fprintf:
if ((_access("datafile", 2 )) == -1)
fprintf(stderr, _strerror(NULL));
Return Value
Returns a pointer to the error message string.
Compatibility
DOS Windows 3.x Phar Lap DOSX Win32
See Also
_strerror
clearerr
ferror
perror
Example /* Example of strerror */
#include <stdlib.h>
#include <stdio.h>
#include <io.h>
#include <string.h>
#include <fcntl.h>
void main ()
{
int f;
if ((f = _open (" nofile. xxx", _O_RDONLY)) < 0)
printf (" Error opening file
\" nofile. xxx\": %s\n", strerror (errno));
else
{
printf (" The file is open");
_close (f);
}
}
Output Error opening file "nofile. xxx": No such file or directory
strlen, _fstrlen
Header
string.h
Prototype size_t strlen(const char *string);
size_t __far _fstrlen(const char __far *string);
Description The strlen function returns the length of the string in the string argument, excluding the
terminating '\0'.
The _fstrlen function is a model-independent (large model) form of strlen. These
functions are identical, except that the _fstrlen argument is a far pointer.
Synonym
Function: fstrlen
Return Value
Both functions return the length of the string.
Compatibility
strlen: DOS Windows 3.x Phar Lap/ DOSX Win32 _fstrlen: DOS Windows 3.x Phar
Lap/ DOSX Win32
Example /* Example of strlen */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void main ()
{
char str[80];
printf (" Enter a string: ");
gets (str);
printf (" There are %d characters in the
string \"% s\"\n", strlen (str), str);
}
Output Enter a string: The quick brown fox...
There are 22 characters in the string "The quick
brown fox..."
strncat, _fstrncat
Header string.h
Prototype char *strncat(char *string1, const char *string2, size_t n);
char __far *__far _fstrncat(char __far *string1, const char __far
*string2, size_t n);
Description This function appends the lesser of n or strlen(string2) characters of string2 onto the end
of string1 and adds a terminating NULL character. It is the user's responsibility to ensure
there is enough space in string1 to hold the result.
The _fstrncat function is a model-independent (large model) form of strncat. These
functions are identical, except that the _fstrncat pointer arguments and return values are
far pointers.
Synonym Function: fstrncat
Return Value Both functions return a pointer to the concatenated string.
Compatibility strncat: DOS Windows 3.x Phar Lap/ DOSX Win32
_fstrncat: DOS Windows 3.x Phar Lap/ DOSX Win32
See Also
strcat
Example /* Example of strncat */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void main ()
{
char str1[25] = "This is string 1...";
char str2[25] = "And this is string 2.";
int len;
len = 25 -strlen (str1);
printf (" String 1: \"% s\"\nString 2:
\"% s\"\n", str1, str2);
printf (" Result of strncat(str1, str2, %d):
\"% s\"\n", len, strncat(str1, str2, len));
}
Output String 1: "This is string 1..."
String 2: "And this is string 2."
Result of strncat(str1, str2, 6): "This is
string 1... And th"
strncmp, _fstrncmp
Header string.h
Prototype int strncmp(const char *string1, const char *string2, size_t n);
int __far _fstrncmp(const char __far *string1, const char __far
*string2, size_t n);
Description Compares n characters of string2 to string1. The comparison stops after n characters or
the end of string1. The _fstrncmp function is a model-independent (large model) form of
strncmp. These functions are identical, except that the _fstrncmp arguments and return
values are far.
Synonym
Function: fstrncmp
Return Value
Return... /if... < 0
string1 is less than string2
= 0
string1 is equal to string2
> 0
string1 is greater than string2
Compatibility
strncmp: DOS, Windows 3.x, Phar Lap/ DOSX, Win32
_fstrncmp: DOS, Windows 3.x, Phar Lap/ DOSX, Win32
See Also strcmp Functions
Example /* Example of strncmp
Also demonstrates _strnicmp
*/
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
char test1[] = "this is a test string XXXXX";
char test2[] = "THIS IS A TEST STRING zzzzz";
void main ()
{
int result;
printf (" Test string 1 is \"% s\"\n", test1);
printf (" Test string 2 is \"% s\"\n", test2);
printf ("\nComparing 1 and 2 using
strncmp(str1, str2, 21)\n");
result = strncmp (test1, test2, 21);
if (! result)
printf (" string 1 is equal to string 2\n");
else if (result < 0)
printf (" string 1 is less than string 2\n");
else
printf (" string 1 is greater than string
2\n");
printf ("\nComparing 1 and 2 using
_strnicmp(str1, str2, 21)\n");
result = _strnicmp (test1, test2, 21);
if (! result)
printf (" string 1 is equal to string 2\n");
else if (result < 0)
printf (" string 1 is less than string
2\n");
else
printf (" string 1 is greater than string
2\n");
printf ("\nComparing 1 and 2 using _strnicmp(str1, str2, 100)\n");
result = _strnicmp (test1, test2, 100);
if (! result)
printf (" string 1 is equal to string 2\n");
else if (result < 0)
printf (" string 1 is less than string 2\n");
else
printf (" string 1 is greater than string 2\n");
}
Output Test string 1 is "this is a test string XXXXX"
Test string 2 is "THIS IS A TEST STRING zzzzz"
Comparing 1 and 2 using strncmp(str1, str2, 21)
string 1 is greater than string 2
Comparing 1 and 2 using _strnicmp(str1, str2, 21)
string 1 is equal to string 2
Comparing 1 and 2 using _strnicmp(str1, str2, 100)
string 1 is less than string 2
strncmpi, strncmpl, _strnicmp, _fstrnicmp
Header string.h
Prototype int strncmpi(const char *str1, const char *str2, size_t n);
int strncmpl(char *str1, char *str2, int n);
int _strnicmp(const char *str1, const char *str2, size_t n);
int __far _fstrnicmp(const char __far *str1, const char __far *str2,
size_t n);
Description
These functions are case-insensitive versions of strncmp. The first n characters of each
string are compared. If either is less than n characters long, the comparison terminates;
the return value is the result of the comparison up until the termination. The returned
value is zero for a successful match; a positive or negative number represents the
difference in the mismatched characters.
The _fstrnicmp function is a model-independent (large model) form of _strnicmp. They
are identical, except that the _fstrnicmp arguments and return values are far.
Synonym Function: strnicmp
Return Value
Returns... /if...
< 0
string1 is less than string2
= 0
string1 is equal to string2
> 0
string1 is greater than string2
Compatibility _strn*/ strn*: DOS, Windows 3.x, Phar Lap/ DOSX, Win32
_fstrnicmp: DOS, Windows 3.x, Phar Lap/ DOSX, Win32
See Also
strncmp
strcmp Functions
strncpy, _fstrncpy
Header string.h
Prototype char *strncpy(char *string1, const char *string2, size_t n);
char __far *__far _fstrncpy(char __far *string1, const char __far
*string2, size_t n);
Description The strncpy function copies the first n characters of string2 into string1. If string2 is
longer than string1 or longer than n, the result will not be null terminated. If string2 is
less than n characters, string1 will be padded to n with null characters.
The _fstrncpy function is a model-independent (large model) form of strncpy. These
functions are identical, except that the _fstrncpy arguments and return values are far.
Synonym
Function: fstrncpy
Return Value
Returns string1.
Compatibility
strncpy: DOS, Windows 3.x, Phar Lap/ DOSX, Win32
_fstrncpy: DOS, Windows 3.x, Phar Lap/ DOSX, Win32
See Also strcpy
stpcpy
Example /* Example of strncpy */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void main ()
{
char str1[50] = "This is the first string";
char str2[50] = "The second string is this";
printf (" str1 = \"% s\"\n", str1);
printf (" str2 = \"% s\"\n", str2);
strncpy (str1, str2, 10);
printf ("\nAfter strncpy(str1, str2,
10)...\n\n");
printf (" str1 = \"% s\"\n", str1);
printf (" str2 = \"% s\"\n", str2);
}
Output str1 = "This is the first string"
str2 = "The second string is this"
After strncpy(str1, str2, 10)...
str1 = "The seconde first string"
str2 = "The second string is this"
strpbrk, _fstrpbrk
Header string.h
Prototype char *strpbrk(const char *string1, const char *string2);
char __far *__far _fstrpbrk(const char __far *string1, const char __far
*string2);
Description The strpbrk function finds the first occurrence in string1 of any character from string2.
The terminating null character is not included in the search.
The _fstrpbrk function is a model-independent (large model) form of strpbrk. These
functions are identical, except that the _fstrpbrk arguments and return values are far.
Synonym
Function: fstrpbrk
Return Value
Returns a pointer to the first occurrence in string1 of any character from string2, or
NULL if no character from string2 exists in string1.
Compatibility strpbrk: DOS, Windows 3.x, Phar Lap/ DOSX, Win32
_fstrpbrk: DOS, Windows 3.x, Phar Lap/ DOSX, Win32
Example /* Example of strpbrk */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void main ()
{
char *str = "The quick brown fox jumped
over the lazy dog";
char srch[80];
char *res;
printf (" The search string is:\n
\"% s\"\n\n", str);
printf (" Enter the set of characters
for strpbrk(): ");
gets (srch);
res = strpbrk (str, srch);
if (res == NULL)
printf ("\nSorry but none of those
characters where found.\n");
else
{
printf ("\nMatching character found at
offset %d\n", res -str);
printf (" The result points to
\"% s\"\n", res);
}
}
Output The search sting is:
"The quick brown fox jumped over the lazy dog"
Enter the set of characters for strpbrk(): qrt
Matching character found at offset 4
The result points to "quick brown fox jumped
over the lazy dog"
strrchr, _fstrrchr
Header string.h
Prototype char *strrchr(const char *string, int ch);
char __far *__far _fstrrchr(const char __far *string, int ch);
Description The strrchr function finds the last occurrence of character ch (converted to char) in string.
The string's terminating null character is included in the search.
The _fstrrchr function is a model-independent (large model) form of strrchr. These
functions are identical, except that the _fstrrchr arguments and return values are far
pointers.
Synonym Function: fstrrchr
Return Value Both functions return a pointer to the last occurrence of ch in string. They return a NULL
pointer if ch is not found.
Compatibility strrchr: DOS Windows 3.x Phar Lap/ DOSX Win32
_fstrrchr: DOS Windows 3.x Phar Lap/ DOSX Win32
Example /* Example of strrchr */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void main ()
{
char *str = "Peter piper picked a peck of
pickled peppers";
char *res;
printf (" Using strrchr to look for 'p' in string:\n \"% s\"\n\n",
str);
res = strrchr(str, 'p'); if (! res)
printf (" 'p' was not found in the search string\n");
else
printf (" The last occurance of 'p' was found in the search
string at "
"offset %d\n", res -str);
}
Output Using strrchr to look for 'p' in string:
"Peter piper picked a peck of pickled peppers"
The last occurance of 'p' was found in the
search string at offset 40
strspn, _fstrspn
Header string.h
Prototype size_t strspn(const char *string1, const char *string2);
size_t __far _fstrspn(const char __far *string1, const char __far
*string2);
Description The strspn function returns the length of the initial segment of string1 which consists
entirely of characters found in string2. The null character terminating string2 is not
considered in the matching process. If string1 begins with a character not in string2,
strspn returns 0.
The _fstrspn function is a model-independent (large model) form of strspn. These
functions are identical, except that the _fstrspn arguments are far pointers.
Synonym Function: fstrspn
Return Value Both functions return the length of the initial segment of string1 which consists entirely
of characters found in string2.
Compatibility
strspn: DOS Windows 3.x Phar Lap/ DOSX Win32 _fstrspn: DOS Windows 3.x Phar
Lap/ DOSX Win32
Example /* Example of strspn */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void main ()
{
char *str = "The quick brown fox jumped
over the lazy dog";
char srch[80];
unsigned res;
printf (" The search string is:\n
\"% s\"\n\n", str);
printf (" Enter the set of characters
for strspn(): ");
gets (srch);
res = strspn (str, srch);
if (res == 0)
printf ("\nSorry, but not all of those
characters where found.\n");
else
printf ("\nCharacters match until offset
%d\n", res);
}
Output The search string is:
"The quick brown fox jumped over the lazy dog"
Enter the set of characters for strspn(): ehT
kciqu z
Characters match until offset 10
strstr, _fstrstr
Header
string.h
Prototype char *strstr(const char *string1, const char *string2);
char __far *__far _fstrstr(const char __far *string1, const char __far
*string2);
Description
The strstr function returns a pointer to the first occurrence of string2 within string1.
The _fstrstr function is a model-independent (large model) form of strstr. These functions
are identical, except that the _fstrstr arguments and return value are far pointers.
Synonym Function: fstrstr
Return Value These functions return a pointer to the first occurence of string2 within string1, or they
return NULL if no occurrence was found. If string2 is of 0 length, the functions return
string1.
Compatibility strstr: DOS Windows 3.x Phar Lap/ DOSX Win32
_fstrstr: DOS Windows 3.x Phar Lap/ DOSX Win32
Example /* Example of strstr */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void main ()
{
char *str = "The quick brown fox jumped
over the lazy dog";
char srch[80];
char *res;
printf ("The source string is:\n
\"% s\"\n\n", str);
printf ("Enter the search string for
strstr(): ");
gets (srch);
res = strstr (str, srch);
if (res == NULL)
printf ("\nSorry, that string was not
found.\n");
else
{
printf ("\nMatching string found at offset
%d\n", res -str);
printf (" Result points to the string:
\n \"% s\"\n", res);
}
}
Output The source string is:
"The quick brown fox jumped over the lazy dog"
Enter the search string for strstr(): lazy
Matching string found at offset 36
Result points to the string:
"lazy dog"
strtok, _fstrtok
Header string.h
Prototype char * strtok(char * string1, const char * string2);
char __far *__far _fstrtok(char __far *string1, const char __far
*string2);
Description
strtok parses string1 into tokens delimited by characters in string2. It returns a pointer to
the first character in string1, which is not one of the delimiting characters, and writes a
'\0' at the position of the next delimiter. Because an internal record is stored of the current
position within the string, a subsequent strtok call with a NULL value for string1
continues parsing from the position reached in the previous call. string2 may change
between calls.
The _fstrtok function is a model-independent (large model) form of strtok. These
functions are identical, except that the _fstrtok arguments and return value are far
pointers.
Synonym Function: fstrtok
Return Value The first time these functions are called, they return a pointer to the first token in string1.
In later calls with the same token string, a pointer to the next token is returned. When
there are no more tokens, a NULL pointer is returned.
Compatibility strtok: DOS Windows 3.x Phar Lap/ DOSX Win32
_fstrtok: DOS Windows 3.x Phar Lap/ DOSX Win32
Example /* Example for strtok */
#include <stdio.hgt
#include <stdlib.h>
#include <string.h>
#define delim "\n\r\t\v "
char * gettoken (FILE *fp)
{
static char linebuf[128];
static char *res = NULL;
do
{
if (res == NULL)
{
fgets (linebuf, 128, fp);
res = strtok (linebuf, delim);
}
else
res = strtok (NULL, delim);
} while (! feof (fp) && !res);
return res;
}
void main ()
{
char fname[_MAX_PATH];
char *token;
FILE *fp;
printf (" Enter filename: ");
gets (fname);
if ((fp = fopen (fname, "r")) == NULL)
{
perror (" Unable to open file");
exit (EXIT_FAILURE);
}
do
{
token = gettoken (fp);
printf ("% s\n", token);
} while (! feof(fp));
}
Output Enter filename: strtok. c
/*
Example
for
strtok
*/
#include
<stdio.h>
#include
<stdlib.h>
.
.
.
=
gettoken
(fp);
printf
("% s\n",
token);
}
while
(! feof(fp));
}
strxfrm
Header
string.h
Prototype size_t strxfrm(char *string1, const char *string2, size_t count);
Description
The strxfrm function transforms string2 to a differently collated form and stores it in
string1. The count argument is the maximum number of characters placed in string1. The
transformation uses the collating sequence for the locale, as set by the setlocale function.
The size of the array needed to hold the transformation of the source string can be
expressed as:
1 + strxfrm(NULL, string, 0)
Return Value The length of the transformed string, not counting the terminating null character. The
contents of string1 are unpredictable if the return value is greater than or equal to count.
Compatibility
DOS Windows 3.x Phar Lap DOSX Win32
See Also
localeconv
setlocale
strcmp Functions
strcoll
_sys_errlist
Header string.h
Prototype extern char *_sys_errlist[];
Description This variable is an array of error messages indexed by errno values. Error messages
printed by perror and returned by strerror and _strerror are retrieved from this array. It is
better to use those functions rather than access the array directly because the functions
handle out-of-range errno values correctly.
Synonym
Variable: sys-errlist
Compatibility
DOS Windows 3.x Phar Lap DOSX Win32
See Also
errno
_sys_nerr
perror
strerror
_sys_nerr
Header
string.h
Prototype extern int _sys_nerr;
Description
This variable tells how many elements the _sys_errlist variable contains.
Synonym
Variable: sys_nerr
Compatibility
DOS Windows 3.x Phar Lap DOSX Win32
See Also
errno
_sys_errlist
Home | Compiler & Tools | IDDE Reference | STL | Search | Download | Forums
Copyright © 1999-2010 by Digital Mars ®, All Rights Reserved | Page generated by Ddoc.
