C言語の型キャスト：暗黙の変換と明示的なキャスト

C言語は絶えず型のあいだで値を変換します。その一部はキャストとして自分で書くものですが、大半はあなたが選んだわけではないルールに従ってコンパイラが静かに行うものです。どちらがどちらかを知っていることが、「なぜ平均がいつも3になるんだ？」と、書いたとおりに動くコードとの分かれ目になります。

暗黙の変換

ある型の値が別の型を期待する文脈に現れると、そのたびにC言語は変換を行います。

#include <stdio.h>

int main(void) {
    int    i = 5;
    double d = i;        /* int -> double: 5.0、正確 */
    char   c = 'A';
    int    code = c;     /* char -> int: 65 */
    double pi = 3.9;
    int    truncated = pi;   /* double -> int: 3、.9 は消える */

    printf("d         = %f\n", d);
    printf("code      = %d\n", code);
    printf("truncated = %d\n", truncated);
    return 0;
}

情報を失いえない変換（int から double、char から int、short から long）は拡大変換であり、常に安全です。逆向きの変換は縮小変換でデータを失う可能性があります - 上の 3.9 は 3 になりましたが、-Wconversion で頼まないかぎり警告は出ません。

通常の算術変換

2項演算子のオペランドの型が異なるとき、C言語は処理の前に共通の型へ変換します。そのはしごを下から順に見ていきましょう。

1. int より小さいもの（char、short、_Bool）はすべて int に昇格されます。これが整数昇格で、常に最初に行われます。
2. どちらかが long double なら、もう一方も long double になります。
3. そうでなくどちらかが double なら、もう一方も double になります。
4. そうでなくどちらかが float なら、もう一方も float になります。
5. そうでなければ、整数型のなかでランクの高いほうが勝ち、ランクが並んだ場合は符号なしが勝ちます。

実際のバグを引き起こすのは最後のルールです。残りは直感どおりです。

#include <stdio.h>

int main(void) {
    char a = 100, b = 100;

    /* a と b はまず int に昇格されるので、10000 も問題なく収まる。 */
    printf("a * b as int = %d\n", a * b);

    /* しかし char に戻して格納すると、再び縮小される。 */
    char product = a * b;
    printf("stored in char = %d\n", product);
    return 0;
}

整数昇格があるからこそ char の算術は思ったようにはオーバーフローせず - そして結果を char に戻して格納したときにオーバーフローするのです。

明示的なキャスト

キャストは丸かっこに入れた変換先の型です。

(double)x
(int)3.9
(char)65
(unsigned int)n

直後の式にかかり、結合はとても強く - *、/、+ よりも強く結びつきます。

#include <stdio.h>

int main(void) {
    int total = 7, count = 2;

    printf("no cast:        %f\n", (double)(total / count));  /* 3.0 */
    printf("cast first:     %f\n", (double)total / count);    /* 3.5 */
    printf("cast both:      %f\n", (double)total / (double)count);
    return 0;
}

1行目は整数として割り（3 になります）、それから 3 を 3.0 に変換します - 手遅れです。2行目は割り算の前に total を変換するので、/ 演算子は double と int を見て int を昇格させ、浮動小数点の除算を行います。

片方のオペランドをキャストすれば十分です。もう片方は通常の算術変換が面倒を見てくれます。

整数除算を直す

これが、C言語でキャストを書く最も一般的な理由です。

#include <stdio.h>

int main(void) {
    int scores[] = {88, 92, 75, 61, 90};
    int n = 5;
    int sum = 0;

    for (int i = 0; i < n; i++) {
        sum += scores[i];
    }

    printf("sum = %d\n", sum);
    printf("wrong average: %f\n", (double)(sum / n));    /* 81.000000 - 整数として割ってから変換している */
    printf("right average: %f\n", (double)sum / n);      /* 81.200000 */

    /* パーセントにも同じ罠がある。 */
    int passed = 3;
    printf("wrong pct: %d%%\n", passed / n * 100);            /* 0 パーセント */
    printf("right pct: %.1f%%\n", 100.0 * passed / n);        /* 60.0 パーセント */
    return 0;
}

パーセントの行は教訓的です。passed / n は 3 / 5 で、整数としては 0、そして 0 * 100 は 0 です。割る前に掛ける（100 * passed / n）とキャストなしでも直りますが、それは 300 / 5 が割り切れるからにすぎず、数値が都合よく協力してくれるときにしか通用しません。確実な修正はキャストです。

四捨五入ではなく切り捨て

浮動小数点の値を整数にキャストすると小数部分は捨てられます。ゼロ方向への切り捨てであり、丸めではありません。

#include <stdio.h>
#include <math.h>

int main(void) {
    printf("(int) 3.2  = %d\n", (int) 3.2);
    printf("(int) 3.9  = %d\n", (int) 3.9);    /* 4 ではなく 3 */
    printf("(int)-3.9  = %d\n", (int)-3.9);    /* -4 ではなく -3 */

    /* math.h による本物の丸め： */
    printf("round(3.9)  = %d\n", (int)round(3.9));    /* 4  */
    printf("round(-3.9) = %d\n", (int)round(-3.9));   /* -4 */
    printf("floor(3.9)  = %d\n", (int)floor(3.9));    /* 3  */
    printf("ceil(3.2)   = %d\n", (int)ceil(3.2));     /* 4  */
    return 0;
}

これを自分のマシンでビルドするなら、Linux では math.h のリンク時に -lm が必要なことを忘れずに。

もう1つの危険：整数型に対して大きすぎる浮動小数点の値を変換するのは、巻き戻しではなく未定義動作です。(int)1e20 は何を返してもおかしくありません。値が自分の管理下にないときは、キャストの前に範囲を確認しましょう。

char と int

C言語の char は、文字コードを保持する小さな整数そのものです。両者を行き来する変換は日常業務です。

#include <stdio.h>

int main(void) {
    char letter = 'A';
    int code = letter;

    printf("'%c' has code %d\n", letter, code);
    printf("code + 1 is '%c'\n", (char)(code + 1));   /* 'B' */

    /* 数字文字をその数値へ： */
    char digit = '7';
    int value = digit - '0';
    printf("the character '%c' as a number is %d\n", digit, value);

    /* ASCII の固定された 32 の差を使って、大文字から小文字へ： */
    for (char ch = 'A'; ch <= 'E'; ch++) {
        printf("%c -> %c\n", ch, (char)(ch + 32));
    }
    return 0;
}

digit - '0' は数字文字をその値に変える定番の慣用句で、10個の数字文字が連続していることが保証されているために成り立ちます。英字については + 32 の算術より ctype.h の toupper() や tolower() を選びましょう - あの差は ASCII の事実であって、C言語の保証ではありません。

関連する罠：isdigit や toupper といった ctype.h の関数は、EOF か unsigned char として表現できる値でなければならない int を受け取ります。負の値を持つ素の char を渡すのは（素の char は符号ありでありうるので、これは起こります）未定義です。isdigit((unsigned char)c) とキャストしましょう。

符号あり・符号なしの罠

変換のはしごのステップ5 - 並んだら符号なしが勝つ - が、C言語で最も驚かされる比較を生みます。

#include <stdio.h>

int main(void) {
    int          signed_val = -1;
    unsigned int unsigned_val = 1;

    if (signed_val < unsigned_val) {
        printf("-1 is less than 1  (what you expect)\n");
    } else {
        printf("-1 is NOT less than 1  (what C actually says)\n");
    }

    printf("(unsigned)-1 = %u\n", (unsigned int)signed_val);
    return 0;
}

-1 は unsigned int に変換され、そのビットパターンが 4,294,967,295 として解釈し直されます。これは 1 より大きいので、比較は偽になります。

同じ変換がループを永遠に回らせます。

/* BUG: i は符号なしなので i >= 0 は常に真。i が 0 のとき i-- は巻き戻る。 */
for (size_t i = n - 1; i >= 0; i--) { ... }

そして長さのチェックも失敗させます。

/* BUG: strlen は size_t（符号なし）を返す。文字列が 5 より短ければ
   len - 5 は巨大な数に巻き戻り、テストは通ってしまう。 */
if (strlen(s) - 5 > 0) { ... }

if (strlen(s) > 5) と書き直せば、引き算はそもそも起こりません。

防御策：個数と添字は全体を通して符号の種類をそろえる、-Wsign-compare（-Wextra に含まれます）でコンパイルする、そして混ぜざるをえないときは値が負にならないことを確かめてから明示的にキャストする、です。

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

int main(void) {
    const char *s = "hi";
    size_t len = strlen(s);

    /* 安全：引き算せずに比較する。 */
    if (len > 5) {
        printf("long\n");
    } else {
        printf("short: %zu characters\n", len);
    }

    /* 安全：値が小さいと分かってから符号付きの型へキャストする。 */
    int signed_len = (int)len;
    printf("len - 5 = %d\n", signed_len - 5);
    return 0;
}

ポインタのキャスト

キャストはポインタ型どうしの変換も行い、こちらは本物の危険を伴います。バイトそのものではなく、メモリの解釈のしかたを変えるからです。

#include <stdio.h>

int main(void) {
    int value = 1;
    /* char ポインタを通して int のバイトを覗く。 */
    unsigned char *bytes = (unsigned char *)&value;

    printf("int 1 is stored as bytes:");
    for (size_t i = 0; i < sizeof(int); i++) {
        printf(" %02x", bytes[i]);
    }
    printf("\n");
    return 0;
}

リトルエンディアンのマシンでは 01 00 00 00 と表示されます。unsigned char * を通してオブジェクト表現を調べるのは、規格が明示的に認めている数少ないポインタキャストの1つです。

ほかの大半のポインタキャストは認められていません。float * を通して int を読むのは厳密なエイリアシング規則に違反し、コンパイルは通っても未定義動作です。バイトを解釈し直したいなら代わりに memcpy を使いましょう。

知っておく価値のある慣習が2つあります。C言語では void * は任意のオブジェクトポインタ型とキャストなしで相互変換されます。だからこそ malloc の結果をキャストすべきではないのです。

int *arr = malloc(n * sizeof *arr);        /* 正しいC */
int *arr = (int *)malloc(n * sizeof *arr); /* 不要；ヘッダの書き忘れを隠す */

このキャストは C++ では必須で、だからこれほど多くのコードに付いています。C言語では <stdlib.h> を忘れたという誤りを覆い隠しかねません。

そして printf("%p", ...) は void * を期待するので、そこでのポインタ引数には本当にキャストが必要です：printf("%p", (void *)p)。

キャストが答えではないとき

キャストはコンパイラを黙らせます。コンパイラのほうが正しいこともあります。

long big = 5000000000L;
int  small = (int)big;    /* このキャストは本物のデータ損失を隠す */

値が本当に収まるなら、キャストは「確認済みである」ことを示す記録になります。収まらないかもしれないなら、キャストは警告を静かな誤答へ変えてしまったことになります。書く前に、代わりに変数の型を変えるのが正しい修正ではないか考えましょう - int ではなく double、int ではなく size_t、long ではなく long long。キャストが正しい道具なのは、(double)sum / count のように、1つの演算のために2つの正しい型が出会わなければならないときが主です。