未定義動作を避けるC++のreinterpret_castの使い方

2025年9月5日

reinterpret_castはC++で最も強力かつ危険なキャストです。

見た目は簡単でも、strict aliasingやアライメント、オブジェクトの生存期間などの規則を破ると未定義動作になります。

本記事では、初心者でも段階的に理解できるよう、避けるべき使い方と安全に使うためのルール、代替手段まで丁寧に解説します。

reinterpret_castとは
未定義動作を避けるルール
安全なreinterpret_castの使い方
避けるべき使い方と代替手段
まとめ

reinterpret_castとは

reinterpret_castの意味と役割

reinterpret_castは、値のビット列を変えずに型だけを付け替えるためのキャストです。

特にポインタや整数、関数ポインタ間など、他のキャストでは許されない低レベルの変換を行います。

ただし「値の解釈」は変わらないため、変換後の型でメモリにアクセスしてよいかは別問題です。

コンパイルは通っても、実行時に未定義動作となるケースが多いため、用途と制約を正しく理解する必要があります。

できる変換の範囲

reinterpret_castがコンパイル上許すことと、実際に安全に使ってよいことを分けて考えることが重要です。

以下に代表例をまとめます。

変換例	コンパイル	元に戻る保証	逆参照・利用の安全性
T* → U*(無関係な型)	ほぼ常に可	不定	原則不可(TがUの実オブジェクトでない限り未定義)
T& → U&(無関係な型)	可	N/A	原則不可(参照もポインタ同様に危険)
オブジェクトポインタ ↔ 整数(std::uintptr_t)	可	条件付きで可(往復なら可)	整数の任意値からの生成は危険
関数ポインタ ↔ 関数ポインタ(異なる型)	可	不定	原則不可(呼び出しは未定義)
関数ポインタ ↔ オブジェクトポインタ(void*)	可	不定	原則不可(実行環境依存で危険)

注意点:

キャストが「通る」ことは「アクセスが安全」なことを意味しません。
void* とオブジェクトポインタの相互変換は static_cast の方が適切です。
constを外すには reinterpret_cast ではなく const_cast を使います。

未定義動作が起きる理由

未定義動作は主に次の3要因から発生します。

strict aliasing(ストリクトエイリアシング)違反: 異なる型のオブジェクトを同じメモリに重ねて参照すると、コンパイラ最適化の前提が壊れて未定義動作になります。例外は char系(‘char’/‘signed char’/‘unsigned char’)です。
アライメント不一致: ある型Tのポインタは alignof(T) で求まる整列境界に揃っていなければなりません。ずれていると未定義です。
オブジェクトの生存期間の外でアクセス: まだ構築されていない/既に破棄されたオブジェクトのメモリをTとして触ると未定義です。placement newなどで生存期間開始を明示する必要があります。

これらに加えて、関数ポインタ変換や異なるABIの領域に跨る解釈なども危険です。

未定義動作を避けるルール

strict aliasingを守る

異なる型のオブジェクトを直接別の型で参照してはいけません。

char系でのバイト列アクセスのみが例外です。

NG例(コンパイルは通るが実行してはいけない例、出力なし):

C++

// 実行してはいけない(未定義動作の例)
#include <iostream>

int main() {
    int x = 0x3f800000;              // IEEE 754で 1.0f のビット列に相当する整数
    float* pf = reinterpret_cast<float*>(&x);  // 異なる型でのエイリアシング
    std::cout << *pf << '\n';        // UB: strict aliasing 違反
}

安全な代替(値のビット表現を別型として取得するなら std::bit_cast か std::memcpy を使います)。

C++

// C++20以降: std::bit_cast を使う例(安全)
#include <bit>
#include <cstdint>
#include <iostream>

int main() {
    std::uint32_t bits = 0x3f800000u;   // IEEE 754 の float 1.0f を想定
    float f = std::bit_cast<float>(bits); // ビット列コピーとして安全
    std::cout << f << '\n';
}

出力例(環境により異なる可能性がありますが、一般的なIEEE 754環境では):

実行結果

C++

// C++17以前: std::memcpy による代替(安全)
#include <cstdint>
#include <cstring>
#include <iostream>

int main() {
    std::uint32_t bits = 0x3f800000u;
    float f = 0.0f;
    std::memcpy(&f, &bits, sizeof(f));  // オブジェクト表現をコピー
    std::cout << f << '\n';
}

実行結果

ポイント

char/unsigned char でオブジェクト表現の読み取りは許可されています。
std::byte を使う場合は reinterpret_cast で直接別オブジェクトを参照せず、std::bit_cast や std::memcpy と組み合わせてバイト列として扱います。

アライメントを満たす

T* でアクセスするには、ポインタ値が alignof(T) の境界に揃っている必要があります。

ずれている場合、ハードウェアがアクセス可能でもC++として未定義です。

C++

// アライメントが満たされていない例(アクセスはしないで判定のみ)
#include <cstdint>
#include <iostream>

template <class T>
bool is_aligned(const void* p) {
    return reinterpret_cast<std::uintptr_t>(p) % alignof(T) == 0;
}

int main() {
    // 先頭 + 1 バイトの位置は多くの環境で int の整列境界を外れる
    unsigned char buf[sizeof(int) + 1] = {};
    int* p = reinterpret_cast<int*>(buf + 1);  // ここでの逆参照は未定義になる可能性が高い
    std::cout << std::boolalpha << is_aligned<int>(p) << '\n';
}

実行結果

true

C++

// アライメントを満たす例
#include <cstddef>
#include <cstdint>
#include <iostream>

template <class T>
bool is_aligned(const void* p) {
    return reinterpret_cast<std::uintptr_t>(p) % alignof(T) == 0;
}

int main() {
    alignas(int) unsigned char storage[sizeof(int)] = {}; // int の境界に整列
    int* p = reinterpret_cast<int*>(storage);
    std::cout << std::boolalpha << is_aligned<int>(p) << '\n';
}

実行結果

true

オブジェクトの生存期間を守る

オブジェクトは「構築」されて初めて、その型としてアクセスできます。

生のバッファに対しては placement new を使い、破棄も行います。

C++

#include <cstddef>
#include <iostream>
#include <memory>
#include <new>

int main() {
    alignas(double) std::byte buf[sizeof(double)];
    // double* pd_ng = reinterpret_cast<double*>(buf); // NG: まだ double
    // は存在しない

    // OK: placement new で buf 上に double を構築
    double* pd = ::new (buf) double(3.14);
    std::cout << *pd << '\n';

    // 明示的に破棄
    std::destroy_at(pd);
}

実行結果

3.14

注: 以前に別のオブジェクトが同じ場所にあり、ポインタを保持している場合は std::launder が必要になることがあります。

ポインタと整数はstd::uintptr_tで往復

ポインタを整数へ、整数からポインタへは std::uintptr_t を使います。

uintptr_t に変換した値を元のポインタ型へ戻す往復は定義されていますが、任意の整数値から生成したポインタは未定義です。

C++

#include <cstdint>
#include <iostream>

int main() {
    int x = 42;
    void* p = &x;

    std::uintptr_t u = reinterpret_cast<std::uintptr_t>(p); // ポインタ→整数
    void* q = reinterpret_cast<void*>(u);                   // 整数→ポインタ(往復)

    std::cout << std::boolalpha << (p == q) << '\n';
}

実行結果

true

安全確認チェックリスト

そのメモリ位置に「本当に」その型のオブジェクトが構築されていますか。
アライメントは alignof(T) を満たしていますか。
strict aliasing に違反していませんか(異型のオブジェクトを直接参照していませんか)。
バイト列として読む必要だけなら、char/unsigned char 経由、または std::bit_cast/std::memcpy を使えませんか。
ポインタと整数の相互変換は std::uintptr_t で往復に限っていますか。
関数ポインタやメンバポインタの reinterpret_cast を避けていますか(ABI/呼出規約の差に注意)。

安全なreinterpret_castの使い方

charやstd::byteでバイト列を読む

char/unsigned char はあらゆるオブジェクトのバイト表現を読み取ることができます。

以下は32ビット整数のバイト列を表示する例です。

C++

#include <cstdint>
#include <cstddef>
#include <iostream>
#include <iomanip>

int main() {
    std::uint32_t v = 0x12345678u;
    // unsigned char は任意オブジェクトのバイト表現の読み取りが許可されている
    const unsigned char* bytes = reinterpret_cast<const unsigned char*>(&v);

    for (std::size_t i = 0; i < sizeof(v); ++i) {
        std::cout << std::hex << std::setw(2) << std::setfill('0')
                  << static_cast<unsigned>(bytes[i])
                  << (i + 1 < sizeof(v) ? " " : "\n");
    }
}

実行結果リトルエンディアン環境の一例

78 56 34 12

std::byte を使う場合は、reinterpret_cast で直接オブジェクトを参照するのではなく、std::bit_cast または std::memcpy でバイト配列に安全にコピーします。

C++

// C++20: std::bit_cast でオブジェクト→バイト列に変換
#include <bit>
#include <array>
#include <cstdint>
#include <iostream>
#include <iomanip>

int main() {
    std::uint32_t v = 0x12345678u;
    auto bytes = std::bit_cast<std::array<std::byte, sizeof(v)>>(v);

    for (std::byte b : bytes) {
        std::cout << std::hex << std::setw(2) << std::setfill('0')
                  << static_cast<unsigned>(std::to_integer<unsigned>(b)) << ' ';
    }
    std::cout << '\n';
}

実行結果リトルエンディアンの一例

78 56 34 12

ハードウェアやABI固定でのポインタ変換

組込みなどメモリマップトI/Oにおいては、決め打ちのアドレスをレジスタとしてアクセスする用途で reinterpret_cast を使うことがあります。

この場合はハードウェア仕様(ABI)とアライメントを満たすこと、volatile を付けて最適化から守ることが重要です。

C++

// 実機固有の例(実行は想定しません)
#include <cstdint>

constexpr std::uintptr_t UART0_BASE = 0x40000000u;
volatile std::uint32_t* const UART0_DR =
    reinterpret_cast<volatile std::uint32_t*>(UART0_BASE + 0x00);

int main() {
    // 送信データレジスタに書き込み(実機環境前提)
    *UART0_DR = 0x55u;
}

注意:この種のコードは対象プラットフォームでのみ意味があります。

汎用OSや未マップのアドレス空間で実行するとクラッシュや未定義動作になります。

ネットワークやファイルのシリアライズ

構造体をそのままバイト列として送るのは、パディングやエンディアンの違いで不正になります。

フィールドごとに明示的にエンディアン変換してシリアライズし、CのAPI(例えば write や send、fwrite など)に渡すときだけ reinterpret_cast で char* にします。

C++

#include <cstdint>
#include <vector>
#include <iostream>
#include <iomanip>

int main() {
    struct Packet {
        std::uint16_t id;
        std::uint32_t value;
    } p{0x1234u, 0x89abcdefu};

    std::vector<std::uint8_t> buf;
    buf.reserve(2 + 4);

    auto put16_be = [&](std::uint16_t x) {
        buf.push_back(static_cast<std::uint8_t>((x >> 8) & 0xff));
        buf.push_back(static_cast<std::uint8_t>(x & 0xff));
    };
    auto put32_be = [&](std::uint32_t x) {
        buf.push_back(static_cast<std::uint8_t>((x >> 24) & 0xff));
        buf.push_back(static_cast<std::uint8_t>((x >> 16) & 0xff));
        buf.push_back(static_cast<std::uint8_t>((x >> 8) & 0xff));
        buf.push_back(static_cast<std::uint8_t>(x & 0xff));
    };

    put16_be(p.id);
    put32_be(p.value);

    // CのAPIに渡す場合の例: const char* への変換は安全
    const char* data = reinterpret_cast<const char*>(buf.data());
    std::size_t size = buf.size();
    // ここで write(fd, data, size) 等が呼べる想定

    // 受信側の復元例(ビッグエンディアン前提)
    std::uint16_t id = (static_cast<std::uint16_t>(buf[0]) << 8)
                     | static_cast<std::uint16_t>(buf[1]);
    std::uint32_t value = (static_cast<std::uint32_t>(buf[2]) << 24)
                        | (static_cast<std::uint32_t>(buf[3]) << 16)
                        | (static_cast<std::uint32_t>(buf[4]) << 8)
                        | static_cast<std::uint32_t>(buf[5]);

    std::cout << std::hex << std::showbase
              << "id=" << id << ", value=" << value << '\n';

    // バッファの中身を表示
    for (std::uint8_t b : buf) {
        std::cout << std::hex << std::setw(2) << std::setfill('0')
                  << static_cast<unsigned>(b) << ' ';
    }
    std::cout << '\n';
}

実行結果

id=0x1234, value=0x89abcdef
0x12 0x34 0x89 0xab 0xcd 0xef

ポイント:構造体をそのまま reinterpret_cast<char*>(&p) して送るのは非ポータブルです。

低レベルAPIに渡す直前の「バイト配列→char*」変換に限り reinterpret_cast を使うのは妥当です。

避けるべき使い方と代替手段

異なる型への直接アクセスは未定義動作

別の型のポインタ(や参照)に reinterpret_cast して、そのまま逆参照するのは未定義動作です。

C++

// 実行してはいけない(未定義動作)
#include <cstdint>

int main() {
    std::uint32_t u = 0;
    double* pd = reinterpret_cast<double*>(&u); // 型の不一致
    // *pd にアクセスすると UB
}

必要なのは「型変換」ではなく「ビット列のコピー」なので、std::bit_cast または std::memcpy を用いましょう。

関数ポインタやメンバポインタの変換は危険

関数ポインタを別の関数ポインタ型へ reinterpret_cast し、呼び出すのは原則未定義です。

呼出規約や引数の扱いがABIに縛られ、環境によって壊れます。

関数ポインタとオブジェクトポインタの相互変換も未定義です。

動的ロード(dlsym)の戻り値(void*)を関数ポインタへ変換する慣習はPOSIXが追加保証しますが、標準C++の枠内では未定義です。実務ではプラットフォーム規約(ドキュメント)の保証に従い、移植性に注意してください。
メンバポインタ(クラスのメンバ関数/メンバへのポインタ)のreinterpret_castは特に不透明で、内部表現が実装依存です。

代替案 std::bit_castやmemcpyを使う

reinterpret_castの代わりに、目的に応じた安全な手段を選びます。

C++

// C++20: std::bit_cast でビット列コピー(最も明確で安全)
#include <bit>
#include <cstdint>
#include <iostream>

int main() {
    float f = 1.0f;
    std::uint32_t bits = std::bit_cast<std::uint32_t>(f);
    std::cout << std::hex << std::showbase << bits << '\n';
}

実行結果IEEE 754環境の一例

0x3f800000

C++

// C++17以前: std::memcpy によるビット列コピー
#include <cstring>
#include <cstdint>
#include <iostream>

int main() {
    float f = 1.0f;
    std::uint32_t bits{};
    std::memcpy(&bits, &f, sizeof(bits));
    std::cout << std::hex << std::showbase << bits << '\n';
}

実行結果