[an error occurred while processing this directive]
HP OpenVMS SystemsC Programming Language |
Compaq C
|
Previous | Contents | Index |
Example 3-1 shows how the character-classification functions are used.
Example 3-1 Character-Classification Functions |
---|
/* CHAP_3_CHARCLASS.C */ /* This example uses the isalpha, isdigit, and isspace */ /* functions to count the number of occurrences of letters, */ /* digits, and white-space characters entered through the */ /* standard input (stdin). */ #include <ctype.h> #include <stdio.h> #include <stdlib.h> main() { char c; int i = 0, j = 0, k = 0; while ((c = getchar()) != EOF) { if (isalpha(c)) i++; if (isdigit(c)) j++; if (isspace(c)) k++; } printf("Number of letters: %d\n", i); printf("Number of digits: %d\n", j); printf("Number of spaces: %d\n", k); } |
The sample input and output from Example 3-1 follows:
$ RUN EXAMPLE1 I saw 35 people riding bicycles on Main Street.[Return] [Ctrl/Z] Number of letters: 36 Number of digits: 2 Number of spaces: 8 $ |
The character-conversion functions convert one type of character to another type. These functions include:
ecvt _tolower fcvt toupper gcvt _toupper mbtowc towctrans mbrtowc wctrans mbsrtowcs wcrtomb toascii wcsrtombs tolower |
For more information on each of these functions, see the Reference Section.
Example 3-2 shows how to use the ecvt function.
Example 3-2 Converting Double Values to an ASCII String |
---|
/* CHAP_3_CHARCONV.C */ /* This program uses the ecvt function to convert a double */ /* value to a string. The program then prints the string. */ #include <stdio.h> #include <stdlib.h> #include <unixlib.h> #include <string.h> main() { double val; /* Value to be converted */ int sign, /* Variables for sign */ point; /* and decimal place */ /* Array for the converted string */ static char string[20]; val = -3.1297830e-10; printf("original value: %e\n", val); if (sign) printf("value is negative\n"); else printf("value is positive\n"); printf("decimal point at %d\n", point); } |
The output from Example 3-2 is as follows:
$ RUN EXAMPLE2 original value: -3.129783e-10 converted string: 31298 value is negative decimal point at -9 $ |
Example 3-3 shows how to use the toupper and tolower functions.
Example 3-3 Changing Characters to and from Uppercase Letters |
---|
/* CHAP_3_CONV_UPPERLOWER.C */ /* This program uses the functions toupper and tolower to */ /* convert uppercase to lowercase and lowercase to uppercase */ /* using input from the standard input (stdin). */ #include <ctype.h> #include <stdio.h> /* To use EOF identifier */ #include <stdlib.h> main() { char c, ch; while ((c = getchar()) != EOF) { if (c >= 'A' && c <= 'Z') ch = tolower(c); else ch = toupper(c); putchar(ch); } } |
Sample input and output from Example 3-3 are as follows:
$ RUN EXAMPLE3 LET'S GO TO THE welcome INN.[Ctrl/Z] let's go to the WELCOME inn. $ |
The Compaq C RTL contains a group of functions that manipulate strings. Some of these functions concatenate strings; others search a string for specific characters or perform some other comparison, such as determining the equality of two strings.
The Compaq C RTL also contains a set of functions that allow you to copy buffers containing binary data.
The set of functions defined and declared in the <varargs.h> and the <stdarg.h> header files provide a method of accessing variable-length argument lists. The <stdarg.h> functions are defined by the ANSI C Standard and are more portable than those defined in <varargs.h> .
The RTL functions such as printf and execl , for example, use variable-length argument lists. User-defined functions with variable-length argument lists that do not use <varargs.h> or <stdarg.h> are not portable due to the different argument-passing conventions of various machines.
The <stdarg.h> header file does not contain va_alist and va_dcl . The following shows a syntax example when using <stdarg.h> :
function_name(int arg1, ...) { va_list ap; |
When using <varargs.h> :
These names and declarations have the following syntax:
function_name(int arg1, ...) { va_list ap;. |
Example 3-4 shows how to use the strcat and strncat functions.
Example 3-4 Concatenating Two Strings |
---|
/* CHAP_3_CONCAT.C */ /* This example uses strcat and strncat to concatenate two */ /* strings. */ #include <stdio.h> #include <string.h> main() { static char string1[80] = "Concatenates "; static char string2[] = "two strings "; static char string3[] = "up to a maximum of characters."; static char string4[] = "imum number of characters"; printf("strcat:\t%s\n", strcat(string1, string2)); printf("strncat ( 0):\t%s\n", strncat(string1, string3, 0)); printf("strncat (11):\t%s\n", strncat(string1, string3, 11)); printf("strncat (40):\t%s\n", strncat(string1, string4, 40)); } |
Example 3-4 produces the following output:
$ RUN EXAMPLE1 strcat: Concatenates two strings strncat ( 0): Concatenates two strings strncat (11): Concatenates two strings up to a max strncat (40): Concatenates two strings up to a maximum number of characters. $ |
Example 3-5 shows how to use the strcspn function.
Example 3-5 Four Arguments to the strcspn Function |
---|
/* CHAP_3_STRCSPN.C */ /* This example shows how strcspn interprets four */ /* different kinds of arguments. */ #include <stdio.h> main() { printf("strcspn with null charset: %d\n", strcspn("abcdef", "")); printf("strcspn with null string: %d\n", strcspn("", "abcdef")); printf("strcspn(\"xabc\", \"abc\"): %d\n", strcspn("xabc", "abc")); printf("strcspn(\"abc\", \"def\"): %d\n", strcspn("abc", "def")); } |
The sample output, to the file strcspn.out, in Example 3-5 is as follows:
$ RUN EXAMPLE2 strcspn with null charset: 6 strcspn with null string: 0 strcspn("xabc","abc"): 1 strcspn("abc","def"): 3 |
Example 3-6 shows how to use the <stdarg.h> functions and definitions.
Example 3-6 Using the <stdarg.h > Functions and Definitions |
---|
/* CHAP_3_STDARG.C */ /* This routine accepts a variable number of string arguments, */ /* preceded by a count of the number of such strings. It */ /* allocates enough space in which to concatenate all of the */ /* strings, concatenates them together, and returns the address */ /* of the new string. It returns NULL if there are no string */ /* arguments, or if they are all null strings. */ #include <stdarg.h> /* Include appropriate header files. */ #include <stdlib.h> #include <string.h> #include <stdio.h> /* For the "example" call in main */ /* NSTRINGS is the maximum number of string arguments accepted */ /* (arbitrary). */ #define NSTRINGS 10 char *concatenate(int n,...) { va_list ap; /* Declare the argument pointer. */ char *list[NSTRINGS], *string; int index = 0, size = 0; /* Check that the number of arguments is within range. */ if (n <= 0) return NULL; if (n > NSTRINGS) n = NSTRINGS; va_start(ap, n); /* Initialize the argument pointer. */ do { /* Extract the next argument and save it. */ list[index] = va_arg(ap, char *); size += strlen(list[index]); } while (++index < n); va_end(ap); /* Terminate use of ap. */ if (size == 0) return NULL; string = malloc(size + 1); string[0] = '\0'; /* Append each argument to the end of the growing result */ /* string. */ for (index = 0; index < n; ++index) strcat(string, list[index]); return string; } /* An example of calling this routine is */ main() { char *ret_string ; ret_string = concatenate(7, "This ", "message ", "is ", "built with ", "a", " variable arg", " list.") ; puts(ret_string) ; } |
The call to Example 3-6 produces the following output:
This message is built with a variable arg list. |
Table 4-1 lists and describes all the error- and signal-handling functions found in the Compaq C Run-Time Library (RTL). For more detailed information on each function, see the Reference Section.
When an error occurs during a call to any of the Compaq C RTL functions, the function returns an unsuccessful status. Many RTL routines also set the external variable errno to a value that indicates the reason for the failure. You should always check the return value for an error situation.
The <errno.h> header file declares errno and symbolically defines the possible error codes. By including the <errno.h> header file in your program, you can check for specific error codes after a Compaq C RTL function call.
At program startup, the value of errno is 0. The value of errno can be set to a nonzero value by many Compaq C RTL functions. It is not reset to 0 by any Compaq C RTL function, so it is only valid to use errno after a Compaq C RTL function call has been made and a failure status returned. Table 4-2 lists the symbolic values that may be assigned to errno by the Compaq C RTL.
Previous | Next | Contents | Index |