OpenVMS マニュアル

/*       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); 
} 

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

ecvt         _tolower 
fcvt         toupper 
gcvt         _toupper 
mbtowc       towctrans 
mbrtowc      wctrans 
mbsrtowcs    wcrtomb 
toascii      wcsrtombs 
tolower 

/*     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); 
} 

$ RUN  EXAMPLE2
original value: -3.129783e-10
converted string: 31298
value is negative
decimal point at -9
$ 

/*     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); 
    } 
} 

$ RUN  EXAMPLE3
LET'S GO TO THE welcome INN.[Ctrl/Z]
let's go to the WELCOME inn.
$ 

function_name(int arg1, ...) 
{ 
va_list  ap; 
   .
   .
   .

function_name(int arg1, ...) 
{ 
va_list  ap; 
. 
. 
. 

/*        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)); 
} 

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

/*        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")); 
} 

$ RUN  EXAMPLE2 
 
strcspn with null charset:  6 
strcspn with null string:  0 
strcspn("xabc","abc"):  1 
strcspn("abc","def"):  3 

/*        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>       /* for the "example" call in main.    */ 
#include <string.h> 
#include <stdio.h>      
 
/* 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) ; 
} 

This message is built with a variable arg list.