|
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 |