空白文字が見つかったら空白以外の文字が見つかるまでスキップして、見つかった空白以外の文字が '\n' ならば下線付きでカラー表示させてスキップ回数分の空白を出力する。
見つかった空白以外の文字は ungetc を使って標準入力に戻す。

#include <stdio.h>

#define CHAR_SPACE ' '

#define COLOR_RED     "\x1b[31m" /* 前景色 赤 */
#define COLOR_DEFAULT "\x1b[39m" /* 前景色 デフォルト */
#define DEC_UNDERLINE "\x1b[4m"  /* 装飾   下線 */
#define DEC_DEFAULT   "\x1b[0m"  /* 装飾   デフォルト */

int main(void)
{
    int c, count;

    while ((c = getchar()) != EOF) {
        if (c == CHAR_SPACE) {
            count = 1;
            while ((c = getchar()) == CHAR_SPACE) {
                count++;
            }
            if (c == '\n') {
                printf(COLOR_RED);
                printf(DEC_UNDERLINE);
            }
            while (count-- > 0) {
                putchar(CHAR_SPACE);
            }
            if (c == '\n') {
                printf(COLOR_DEFAULT);
                printf(DEC_DEFAULT);
            }
            ungetc(c, stdin);
        } else {
            putchar(c);
        }
    }

    return 0;
}

\x1b は ESC の16進表記

サンプルコード

#include <stdio.h>

int main(void)
{
    /* 背景色の指定 */
    printf("\x1b[40m");     /* 背景色を黒に */
    printf("背景が黒\n");
    printf("\x1b[41m");     /* 背景色を赤に */
    printf("背景が赤\n");
    printf("\x1b[42m");     /* 背景色を緑に */
    printf("背景が緑\n");
    printf("\x1b[43m");     /* 背景色を黄色に */
    printf("背景が黄色\n");
    printf("\x1b[44m");     /* 背景色を青に */
    printf("背景が青\n");
    printf("\x1b[45m");     /* 背景色をマゼンタに */
    printf("背景がマゼンタ\n");
    printf("\x1b[46m");     /* 背景色をシアンに */
    printf("背景がシアン\n");
    printf("\x1b[47m");     /* 背景色を灰色に */
    printf("背景が灰色\n");
    printf("\x1b[49m");     /* 背景色をデフォルトに戻す */
    printf("背景色がデフォルト\n");

    printf("\n");

    /* 前景色の指定 */
    printf("\x1b[30m");     /* 前景色を黒に */
    printf("前景色が黒\n");
    printf("\x1b[31m");     /* 前景色を赤に */
    printf("前景色が赤\n");
    printf("\x1b[32m");     /* 前景色を緑に */
    printf("前景色が緑\n");
    printf("\x1b[33m");     /* 前景色を黄色に */
    printf("前景色が黄色\n");
    printf("\x1b[34m");     /* 前景色を青に */
    printf("前景色が青\n");
    printf("\x1b[35m");     /* 前景色をマゼンタに */
    printf("前景色がマゼンタ\n");
    printf("\x1b[36m");     /* 前景色をシアンに */
    printf("前景色がシアン\n");
    printf("\x1b[37m");     /* 前景色を白に */
    printf("前景色が白\n");
    printf("\x1b[39m");     /* 前景色をデフォルトに戻す */
    printf("前景色がデフォルト\n");

    printf("\n");

    printf("\x1b[4m");      /* 下線を付ける */
    printf("下線を付ける\n");
    printf("\x1b[1m");      /* 高輝度 */
    printf("高輝度\n");
    printf("\x1b[7m");      /* 反転（背景色と前景色の入れ替え） */
    printf("反転（背景色と前景色の入れ替え）\n");
    printf("\x1b[0m");      /* デフォルトに戻す */
    printf("デフォルトに戻す\n");

    return 0;
}

上記のコードのスクリーンショット

Mac OSX 付属の Terminal での表示

Mac OSX の iTerm での表示

Ubuntu 9.10 KarmicKoala の Gnome Terminal での表示

malloc, free の簡単な実装を学ぶ。

malloc 時に要求サイズが空きブロックより小さい場合に、後側からブロックを使用していくことに気がつかず、理解するのに時間がかかった。
後側からブロックを使用していくのは、空きリストのポインタを変更しなくてもよいからだろうか。

演習8-7

malloc での妥当なサイズの条件がいまいちわからない。
負の値が渡された場合、unsigned に変換されて大きなサイズが要求されるので、そのチェックを入れてみた。

free での正しいサイズ・フィールドというのもわからない。
解放ブロックのヘッダ位置と次のポインタの差が解放ブロックのサイズの場合が正しいサイズということだろうか。

#include <stdio.h>
#include <stdlib.h>

typedef long Align;     /* long の境界に整合させる */

union header {          /* ブロックのヘッダ */
    struct {
        union header *ptr;  /* 空きリストの上なら次のブロック */
        unsigned size;      /* このブロックの大きさ */
    } s;
    Align x;            /* ブロックの整合を強制 */
};

typedef union header Header;

void *my_malloc(unsigned);
static Header *morecore(unsigned);
void my_free(void *);

int main(void)
{
    char *s, *p;

    if ((s = my_malloc(10)) == NULL) {
        fprintf(stderr, "can't allocate memory\n");
        exit(EXIT_FAILURE);
    }
    if ((p = my_malloc(10)) == NULL) {
        fprintf(stderr, "can't allocate memory\n");
        exit(EXIT_FAILURE);
    }

    s[0] = 'h';
    s[1] = 'e';
    s[2] = 'l';
    s[3] = 'l';
    s[4] = 'o';
    s[5] = '!';
    s[6] = '\0';

    p[0] = 'H';
    p[1] = 'E';
    p[2] = 'L';
    p[3] = 'L';
    p[4] = 'O';
    p[5] = '!';
    p[6] = '\0';

    printf("%s\n", s);
    printf("%s\n", p);
    my_free(s);
    my_free(p);

    return 0;
}

static Header base;     /* 開始時の空きリスト */
static Header *freep = NULL;    /* 空きリストの先頭 */

/* my_malloc : 汎用の記憶割当てプログラム */
void *my_malloc(unsigned nbytes)
{
    Header *p, *prevp;
    Header *morecore(unsigned);
    unsigned nunits;

    if ((long) nbytes <= 0) { /* 引数が正の整数かをチェック */
        fprintf(stderr, "my_malloc : wrong memory size %d\n", nbytes);
        exit(EXIT_FAILURE);
    }

    nunits = (nbytes + sizeof(Header) - 1) / sizeof(Header) + 1;
    if ((prevp = freep) == NULL) {  /* 空きリストはまだない */
        base.s.ptr = freep = prevp = &base;
        base.s.size = 0;
    }
    for (p = prevp->s.ptr; ; prevp = p, p = p->s.ptr) {
        if (p->s.size >= nunits) {  /* 十分大きい */
            if (p->s.size == nunits) {  /* 正確に */
                prevp->s.ptr = p->s.ptr;
            } else {    /* 後尾の部分を割り当て */
                p->s.size -= nunits;
                p += p->s.size;
                p->s.size = nunits;
            }
            freep = prevp;
            return (void *)(p+1);
        }
        if (p == freep) {   /* 空きリストをリング状につなぐ */
            if ((p = morecore(nunits)) == NULL) {
                return NULL;    /* 残りなし */
            }
        }
    }
}

#define NALLOC 1024     /* 要求する最小の単位数 */

/* morecore : システムにもっとメモリを要求する */
static Header *morecore(unsigned nu)
{
    char *cp, *sbrk(int);
    Header *up;

    if (nu < NALLOC) {
        nu = NALLOC;
    }
    cp = sbrk(nu * sizeof(Header));
    if (cp == (char *) - 1) {   /* スペースが全然ない */
        return NULL;
    }
    up = (Header *) cp;
    up->s.size = nu;
    my_free((void *) (up + 1));
    return freep;
}

/* my_free :  ブロック ap を空きリストに入れる */
void my_free(void *ap)
{
    Header *bp, *p;

    bp = (Header *) ap - 1;     /* ブロック・ヘッダを指す */
    for (p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr) {
        if (p >= p->s.ptr && (bp > p || bp < p->s.ptr)) {
            break;  /* 領域の始めあるいは終りの解放ブロック */
        }
    }
    if ((bp < p->s.ptr) &&  /* 次の領域が後方にある場合 */
            ((p->s.ptr - bp - bp->s.size) != 0)) { /* ブロックサイズのチェック */
        fprintf(stderr, "my_free : wrong block size %d\n", bp->s.size);
    }
    if (bp + bp->s.size == p->s.ptr) {  /* 上の nbr へ結合 */
        bp->s.size += p->s.ptr->s.size;
        bp->s.ptr = p->s.ptr->s.ptr;
    } else {
        bp->s.ptr = p->s.ptr;
    }
    if (p + p->s.size == bp) {  /* 下の nbr へ結合 */
        p->s.size += bp->s.size;
        p->s.ptr = bp->s.ptr;
    } else {
        p->s.ptr = bp;
    }
    freep = p;
}

プログラミング言語C 第2版 ANSI規格準拠

posted with amazlet at 09.11.27

B.W. カーニハン D.M. リッチー
共立出版
売り上げランキング: 9726

Amazon.co.jp で詳細を見る

void *my_calloc(unsigned n, unsigned size)
{
    void *p;

    if ((p = my_malloc(size * n)) == NULL) {
        fprintf(stderr, "can't allocate memory\n");
        exit(EXIT_FAILURE);
    }
    memset(p, 0, size * n);

    return p;
}

プログラミング言語C 第2版 ANSI規格準拠

posted with amazlet at 09.11.27

B.W. カーニハン D.M. リッチー
共立出版
売り上げランキング: 9726

Amazon.co.jp で詳細を見る

リンク数 (st_nlink) と最後に inode が変更された時間 (st_ctime) を表示させてみる。

#include <time.h>

#define MAX_TIME_STR 100

void parseTm(const struct tm *tp, char *str)
{
    strftime(str, MAX_TIME_STR, "%b %d %Y %H:%M:%S", tp);
}

/* fsize : ファイル "name" のサイズを印字する */
void fsize(char *name)
{
    struct stat stbuf;
    char timestr[MAX_TIME_STR];

    if (stat(name, &stbuf) == -1) {
        fprintf(stderr, "fsize : can't access %s\n", name);
        return;
    }
    if ((stbuf.st_mode & S_IFMT) == S_IFDIR) {
        dirwalk(name, fsize);
    }
    parseTm(localtime(&stbuf.st_ctime), timestr);
    printf("%4d %8ld %s %s\n", stbuf.st_nlink, stbuf.st_size, timestr, name);
}

実行結果

$ ./fsize *
   1      155 Mar 16 2010 12:00:36 Makefile
   1    10560 Mar 16 2010 12:39:46 fsize
   1     3763 Mar 16 2010 12:39:44 main.c
   1    10244 Mar 16 2010 12:39:46 main.o
   1      840 Mar 16 2010 12:02:18 my_dirent.h

プログラミング言語C 第2版 ANSI規格準拠

posted with amazlet at 09.11.27

B.W. カーニハン D.M. リッチー
共立出版
売り上げランキング: 9726

Amazon.co.jp で詳細を見る

/* fp に対してファイルの位置を指定する
 * バイナリ・ファイルに対しては、origin から offset 文字だけ離れたところにセットする
 * origin には MY_SEEK_SET (始め), MY_SEEK_CUR (現在位置), MY_SEEK_END (ファイルの終り) が指定可能
 * テキスト・ファイルに対しては、offset はゼロ、または ftell (この場合は origin は MY_SEEK_SET) で返される値でなければならない
 * エラーの場合は fseek からはゼロ以外の値が返される
 */
int my_fseek(MY_FILE *fp, long offset, int origin)
{
    int result = 0;

    if (fp == MY_NULL) {
        return -1;
    }
    if (fp->flag & _WRITE) {
        if (my_fflush(fp) == MY_EOF) {
            return MY_EOF;
        }
        result = lseek(fp->fd, offset, origin);
    } else if (fp->flag & _READ) {
        if (origin == MY_SEEK_CUR) { /* 現在位置からの場合 */
            offset -= fp->cnt;
        }
        result = lseek(fp->fd, offset, origin);
    }
    return (result == -1) ? -1 : 0;
}

プログラミング言語C 第2版 ANSI規格準拠

posted with amazlet at 09.11.27

B.W. カーニハン D.M. リッチー
共立出版
売り上げランキング: 9726

Amazon.co.jp で詳細を見る

この _flushbuf と my_putc だと、fp->cnt が 0 未満にならずに終了してしまう場合に、どうしてもデータがバッファに残ったまま書き出されない状態になってしまう。

/* _flushbuf : 出力バッファを書き出す
 * ファイルが書き込み用にオープンされていなければ即座に MY_EOF を返す
 */
int _flushbuf(int c, MY_FILE *fp)
{
    int bufsize, n_write;
    unsigned char uc = c;

    if ((fp->flag&(_WRITE|_EOF|_ERR)) != _WRITE) {
        return MY_EOF;
    }

    if (fp->flag &_UNBUF) { /* バッファを使わない場合 */
        n_write = write(fp->fd, &uc, 1);
        bufsize = 1;
    } else {
        if (fp->base == MY_NULL) { /* バッファがまだ未割り当ての場合 */
            if ((fp->base = (char *) malloc(MY_BUFSIZ)) == MY_NULL) {
                return MY_EOF;
            }
            fp->ptr = fp->base;
            *fp->ptr++ = uc;
            fp->cnt = MY_BUFSIZ - 2; /* 最初の文字分を引く (MY_BUFSIZ - 1 - 1)*/
            return 0;
        }
        if (fp->ptr) {
          if (c != MY_EOF) { /* バッファの最後に c を追加する */
            *fp->ptr++ = uc;
          }
          bufsize = MY_BUFSIZ - fp->cnt - 1;
          fp->ptr = fp->base;
          fp->cnt = MY_BUFSIZ - 1;
          n_write = write(fp->fd, fp->base, bufsize); /* バッファを書き出す */
        }
    }

    if (n_write != bufsize) {
        fp->flag |= _ERR;
        return MY_EOF;
    }

    return uc;
}

/* バッファに残っているデータを書き出す
 * 書き込みエラーがあると MY_EOF を返し、それ以外では 0 を返す
 * my_fflush(MY_NULL) で全てのストリームをはき出す
 */
int my_fflush(MY_FILE *fp)
{
    int i;

    if (fp == MY_NULL) {
        for (i = 0; i< MY_OPEN_MAX; i++) {
            my_fflush(&_iob[i]);
        }
    } else {
        if ((fp->flag&(_WRITE)) == 0) {
            return MY_EOF;
        }
        _flushbuf(MY_EOF, fp);
        if (fp->flag & _ERR) {
            return MY_EOF;
        }
    }
    return 0;
}

/* まだ書き出されていないデータを my_fflush で書き出し
 * まだ読み込まれていないデータを破棄して、バッファを解放する
 * エラーがあると MY_EOF を返し、それ以外では 0 を返す
 */
int my_fclose(MY_FILE *fp)
{
    if (fp == MY_NULL) {
        return MY_EOF;
    }
    my_fflush(fp);
    fp->cnt = 0;
    fp->ptr = MY_NULL;
    if (fp->base) {
        free(fp->base);
    }
    fp->base = MY_NULL;
    fp->flag = 0;
    fp->fd = -1;
    return 0;
}

プログラミング言語C 第2版 ANSI規格準拠

posted with amazlet at 09.11.27

B.W. カーニハン D.M. リッチー
共立出版
売り上げランキング: 9726

Amazon.co.jp で詳細を見る

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

#define MY_NULL 0
#define MY_EOF (-1)
#define MY_BUFSIZ 1024
#define MY_OPEN_MAX 20 /* 一時に開けるファイルの最大数 */

/* フラグのビットフィールド */
struct flags {
    unsigned int is_read    : 1;
    unsigned int is_write   : 1;
    unsigned int is_unbuf   : 1;
    unsigned int is_eof     : 1;
    unsigned int is_err     : 1;
};

typedef struct _iobuf {
    int cnt;            /* 残っている文字数 */
    char *ptr;          /* 次の文字位置 */
    char *base;         /* バッファの位置 */
    struct flags flag;  /* ファイル・アクセスのモード */
    int fd;             /* ファイル記述子 */
} MY_FILE;
extern MY_FILE _iob[MY_OPEN_MAX];

#define my_stdin   (&_iob[0])
#define my_stdout  (&_iob[1])
#define my_stderr  (&_iob[2])

int _fillbuf(MY_FILE *);
int _flushbuf(int, MY_FILE *);

#define feof(p)     ((p)->flag.is_eof == 1)
#define ferror(p)   ((p)->flag.is_err == 1)
#define fileno(p)   ((p)->fd)

#define my_getc(p)     (--(p)->cnt >= 0 \
        ? (unsigned char) *(p)->ptr++ : _fillbuf(p))
#define my_putc(x, p)  (--(p)->cnt >= 0 \
        ? *(p)->ptr++ = (x) : _flushbuf((x), p))

#define my_getchar()   my_getc(my_stdin)
#define my_putchar(x)  my_putc((x), my_stdout)

MY_FILE _iob[MY_OPEN_MAX] = { /* my_stdin, my_stdout, my_stderr: */
    { 0, (char *) 0, (char *) 0, {1, 0, 0, 0, 0}, 0 },
    { 0, (char *) 0, (char *) 0, {0, 1, 0, 0, 0}, 1 },
    { 0, (char *) 0, (char *) 0, {0, 1, 1, 0, 0}, 2 }
};

MY_FILE *my_fopen(char*, char*);

int main(int argc, char *argv[])
{
    int c;
    char mode = 'r';
    MY_FILE *fp;

    if (argc == 2) {
        if ((fp = my_fopen(argv[1], &mode)) == MY_NULL) {
            fprintf(stderr, "can't open %s\n", argv[1]);
            exit(EXIT_FAILURE);
        }
        while ((c = my_getc(fp)) != MY_EOF) {
            printf("%c", c);
        }
    }

    return 0;
}

#define PERMS 0666 /* 所有者、グループ、他人に対して RW */

/* my_fopen : ファイルを開いて、ファイル・ポインタを返す */
MY_FILE *my_fopen(char *name, char *mode)
{
    int fd;
    MY_FILE *fp;

    if (*mode != 'r' && *mode != 'w' && *mode != 'a') {
        return MY_NULL;
    }
    for (fp = _iob; fp < _iob + MY_OPEN_MAX; fp++) {
        if ((fp->flag.is_read == 0 && fp->flag.is_write == 0)) {
            break; /* found free slot */
        }
    }
    if (fp >= _iob + MY_OPEN_MAX) { /* 空きスロットなし */
        return MY_NULL;
    }

    if (*mode == 'w') {
        fd = creat(name, PERMS);
    } else if (*mode == 'a') {
        if ((fd = open(name, O_WRONLY, 0)) == -1) {
            fd = creat(name, PERMS);
        }
        lseek(fd, 0L, 2);
    } else {
        fd = open(name, O_RDONLY, 0);
    }
    if (fd == -1) { /* 名前がアクセス不能 */
        return MY_NULL;
    }
    fp->fd = fd;
    fp->cnt = 0;
    fp->base = MY_NULL;
    if (*mode == 'r') {
        fp->flag.is_read = 1;
        fp->flag.is_write = 0;
    } else {
        fp->flag.is_read = 0;
        fp->flag.is_write = 1;
    }
    return fp;
}

/* _fillbuf : 入力バッファを割り当てて、詰める */
int _fillbuf(MY_FILE *fp)
{
    int bufsize;

    if (!fp->flag.is_read && fp->flag.is_eof && fp->flag.is_err) {
        return MY_EOF;
    }
    bufsize = fp->flag.is_unbuf ? 1 : MY_BUFSIZ;
    if (fp->base == MY_NULL) { /* バッファがまだない */
        if ((fp->base = (char *) malloc(bufsize)) == MY_NULL) {
            return MY_EOF; /* バッファがとれない */
        }
    }
    fp->ptr = fp->base;
    fp->cnt = read(fp->fd, fp->ptr, bufsize);
    if (--fp->cnt < 0) {
        if (fp->cnt == -1) {
            fp->flag.is_eof = 1;
        } else {
            fp->flag.is_err = 1;
        }
        fp->cnt = 0;
        return MY_EOF;
    }
    return (unsigned char) *fp->ptr++;
}

実行結果

ビット演算を使っている版のプログラム fopen と、ビットフィールドを使った版のプログラム fopen2 とで比較してみる。

$ time ./fopen /var/log/system.log >/dev/null

real    0m0.332s
user    0m0.292s
sys     0m0.039s
$ time ./fopen2 /var/log/system.log >/dev/null

real    0m0.330s
user    0m0.290s
sys     0m0.039s

プログラミング言語C 第2版 ANSI規格準拠

posted with amazlet at 09.11.27

B.W. カーニハン D.M. リッチー
共立出版
売り上げランキング: 9726

Amazon.co.jp で詳細を見る

p208 の syscalls.h のインクルードの代わりに unistd.h をインクルードする。
参考：ふつうの Linux プログラミング p80

ふつうのLinuxプログラミング Linuxの仕組みから学べるgccプログラミングの王道

posted with amazlet at 10.03.11

青木 峰郎
ソフトバンククリエイティブ
売り上げランキング: 26006

Amazon.co.jp で詳細を見る

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>

int main(int argc, char *argv[])
{
    int fd;
    /* ファイルポインタの代わりにファイルディスクリプタを引数にとる filecopy */
    void filecopy(int, int);

    if (argc == 1) { /* 引数なし、標準入力をコピー */
        filecopy(0, 1);
    } else {
        while (--argc > 0) {
            if ((fd = open(*++argv, O_RDONLY, 0)) == -1) {
                fprintf(stderr, "cat: can't open %s\n", *argv);
                return 1;
            } else {
                filecopy(fd, 1);
                close(fd);
            }
        }
    }

    return 0;
}

/* filecopy : ファイル ifd をファイル ofd にコピー */
void filecopy(int ifd, int ofd)
{
    int n;
    char buf[BUFSIZ];

    while ((n = read(ifd, buf, BUFSIZ)) > 0) {
        write(ofd, buf, n);
    }
}

実行結果

上のコード(ex8-1)と7章(p197)の cat 第1版 (my_cat1)とシステムインストール済みの cat (OSX Snow Leopard版) とで比較してみる。

$ time ./ex8-1 /var/log/system.log >/dev/null

real    0m0.063s
user    0m0.012s
sys     0m0.050s

$ time ./my_cat1 /var/log/system.log >/dev/null

real    0m0.295s
user    0m0.273s
sys     0m0.019s

$ time cat /var/log/system.log >/dev/null

real    0m0.012s
user    0m0.001s
sys     0m0.011s

システムコールを使った方が標準ライブラリを使ったものよりも速かった。
当然ながら OSX 付属の cat が最速。

filecopy でのバッファリングを使わないバージョンでも試してみる。

/* filecopy : ファイル ifd をファイル ofd にコピー (バッファリングなし) */
void filecopy(int ifd, int ofd)
{
    int n;
    char c;

    while ((n = read(ifd, &c, 1)) > 0) {
        write(ofd, &c, n);
    }
}

実行結果

$ time ./ex8-1 /var/log/system.log >/dev/null

real    0m49.766s
user    0m11.336s
sys     0m38.255s

遅っ

プログラミング言語C 第2版 ANSI規格準拠

posted with amazlet at 09.11.27

B.W. カーニハン D.M. リッチー
共立出版
売り上げランキング: 9726

Amazon.co.jp で詳細を見る

スペースを節約する isupper

#include <stdio.h>

int my_isupper(unsigned char);

int main(void)
{
    char c1 = 'd';
    char c2 = 'D';

    printf("%c isupper? => %d\n", c1, my_isupper(c1));
    printf("%c isupper? => %d\n", c2, my_isupper(c2));

    return 0;
}

/* スペースを節約する isupper */
int my_isupper(unsigned char c)
{
    if (c >= 'A' && c <= 'Z') {
        return c;
    } else {
        return 0;
    }
}

実行結果

$ ./ex7-9a
d isupper? => 0
D isupper? => 68

実行時間を短かくする isupper

#include <stdio.h>
#include <string.h>

int my_isupper(unsigned char);

int main(void)
{
    char c1 = 'd';
    char c2 = 'D';

    printf("%c isupper? => %d\n", c1, my_isupper(c1));
    printf("%c isupper? => %d\n", c2, my_isupper(c2));

    return 0;
}

/* 実行時間を短かくする isupper */
int my_isupper(unsigned char c)
{
    if (strchr("ABCDEFGHIJKLMNOPQRSTUVWXYZ", c)) {
        return c;
    } else {
        return 0;
    }
}

実行結果

$ ./ex7-9b
d isupper? => 0
D isupper? => 68

プログラミング言語C 第2版 ANSI規格準拠

posted with amazlet at 09.11.27

B.W. カーニハン D.M. リッチー
共立出版
売り上げランキング: 9726

Amazon.co.jp で詳細を見る