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

2025年9月5日2025年9月12日

C++のreinterpret_castは、メモリ上のビット列の“見方”を別の型として扱う強力な手段です。

ただし強力であるがゆえに、未定義動作に直結する落とし穴も多く存在します。

本記事では、C++初心者の方に向けて未定義動作を避けるための安全な使い方を中心に、避けるべきNG例や安全な代替手段まで丁寧に解説します。

目次 [ close ]

C++のreinterpret_castとは

強引な型変換の基本

reinterpret_castは、値を変換するのではなく、同じビット列を別の型として“再解釈”します。

算術的な変換や、継承関係に基づくポインタ調整は行いません。

これは強力ですが、型の規則(エイリアシングやアラインメント、オブジェクトのライフタイム)を破ると未定義動作になります。

文法例は次の通りです。ポインタ⇄整数や、ポインタ⇄別ポインタの変換に用いられます。
- auto p2 = reinterpret_cast<T*>(p1);
- auto n = reinterpret_caststd::uintptr_t(ptr);

重要なのは、コンパイルが通っても安全性は保証されないことです。

コンパイラは未定義動作を検出しきれません。

メモリの見方を変えるキャスト

reinterpret_castは、「メモリの見方」を変えると理解するとイメージしやすいです。

たとえば、数値を表すビット列をそのまま別の型として読んだり、ポインタ値を整数に一時的に格納して後で元に戻したりします。

ただし、メモリの「見方」を変えた際に、strict aliasing(有効型の規則)やalignment(境界整列)を破ると、読み書きの瞬間に未定義動作です。

未定義動作が起きやすい理由

未定義動作に陥る典型理由は次の通りです。

どれも初心者が見落としがちです。

有効型(Effective Type)違反: 別の不許可な型として同じオブジェクトにアクセスした場合。例外はchar/unsigned char/std::byteでのオブジェクト表現アクセスです。
アラインメント違反: たとえばdouble*に再解釈した先がdoubleに必要な境界に揃っていない場合。
継承オフセット無視: 多重継承などで必要なポインタ調整をreinterpret_castは行いません。
関数ポインタ変換: 互換性のない関数型への変換や、関数ポインタ⇄オブジェクトポインタの変換は未定義。
ライフタイム違反: 別型のオブジェクトとして扱っても、その型のオブジェクトが“そこに存在していなければ”未定義です。

次の表は起こりがちなリスクと回避策の対応です。

リスク	何が問題か	回避策
有効型違反	型の別名規則を破る	`char/unsigned char/std::byte`でのみオブジェクト表現を読む、または`std::memcpy`
アラインメント	必要境界を満たさない	変換先のアラインメントを満たすメモリにのみ再解釈、可能なら`std::bit_cast`
継承オフセット	基底サブオブジェクトへのオフセット未調整	`static_cast`や`dynamic_cast`を使う
関数ポインタ	呼出規約/型非互換	変換しない、正しい関数型に揃える
ライフタイム	その型のオブジェクトが存在しない	適切な構築を行う、単なる“観察”は`memcpy`/`bit_cast`

結論として、reinterpret_castは「最後の手段」と心得てください。

C++初心者向けの安全な使い方

ポインタ⇄整数(std::uintptr_t)のラウンドトリップ

ポインタ値を一時的に整数へ保存し、後で同じポインタへ戻す用途は一般に許容されます。

整数型はstd::uintptr_tを使い、往復(ラウンドトリップ)可能であることを前提にします。

C++

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

int main() {
    int value = 42;
    int* p = &value;

    // ポインタ→整数
    std::uintptr_t raw = reinterpret_cast<std::uintptr_t>(p);

    // 整数→ポインタ
    int* q = reinterpret_cast<int*>(raw);

    std::cout << "p=" << p
              << " raw=0x" << std::hex << std::setw(sizeof(std::uintptr_t)*2)
              << std::setfill('0') << raw << std::dec
              << " q=" << q
              << " equal=" << std::boolalpha << (p == q) << '\n';

    return 0;
}

実行結果

p=0x7ffd77d7a2bc raw=0x00007ffd77d7a2bc q=0x7ffd77d7a2bc equal=true

注意事項として、整数にしている間にポインタの対象オブジェクトが破棄されれば、それを再利用するのは依然として不正です。

バイト列として読む(char/unsigned char/std::byte)

オブジェクト表現をバイト列として“観察”するのは合法です。

char/unsigned char/std::byteへのポインタにreinterpret_castすれば、有効型ルールの例外として読み取りが許可されます。

C++

#include <iostream>
#include <cstddef>    // std::byte
#include <iomanip>

int main() {
    float f = 1.0f;

    // unsigned char と std::byte の2通りで見る例
    const unsigned char* p_uc = reinterpret_cast<const unsigned char*>(&f);
    const std::byte* p_b = reinterpret_cast<const std::byte*>(&f);

    std::cout << "as unsigned char: ";
    for (std::size_t i = 0; i < sizeof(f); ++i) {
        std::cout << std::hex << std::setw(2) << std::setfill('0')
                  << static_cast<unsigned>(p_uc[i]) << ' ';
    }
    std::cout << std::dec << "\n";

    std::cout << "as std::byte     : ";
    for (std::size_t i = 0; i < sizeof(f); ++i) {
        std::cout << std::hex << std::setw(2) << std::setfill('0')
                  << static_cast<unsigned>(std::to_integer<unsigned>(p_b[i])) << ' ';
    }
    std::cout << std::dec << "\n";
}

実行結果

as unsigned char: 00 00 80 3f 
as std::byte     : 00 00 80 3f

書き込みは慎重に扱ってください。

別の型としての意味をもって書き換えると未定義動作に直結します。

観察目的に留めるか、必要ならstd::memcpyを使用します。

参照ではなくポインタで扱うのが無難

参照型へのreinterpret_castは未定義動作を招きやすいです。

参照は「そこにその型のオブジェクトがある」前提を強く伴うため、別型オブジェクトに無理やり別名参照を結び付けるのは危険です。

ポインタのまま保持し、必要な条件(アラインメント/有効型/ライフタイム)を満たす時だけアクセスする方が無難です。

C++

// NG例: double を int& として扱う(未定義動作)
void take_as_int_ref(int&); // どこかで定義されているとする

void bad(double& d) {
    // double オブジェクトの場所に int がある保証はない
    take_as_int_ref(reinterpret_cast<int&>(d)); // 未定義動作の可能性大
}

// 代替: 参照を使わず、観察したいなら memcpy/bit_cast を使う

未定義動作を招くNG例

別の型としてそのままアクセスする

doubleをint*に再解釈して読み書きするのは有効型違反です。

アラインメントも満たさない恐れがあります。

C++

double d = 3.14;
// NG: 未定義動作になり得る
int* pi = reinterpret_cast<int*>(&d);
int x = *pi;       // ここで既に未定義動作の可能性
*pi = 0;           // 書き込みはさらに危険

継承関係のポインタ変換はreinterpret_castを使わない

多重継承では基底サブオブジェクトへのポインタにはオフセット調整が必要です。

reinterpret_castは調整を行いません。

static_cast/dynamic_castを使います。

C++

#include <iostream>

struct B { int b; };
struct A { int a; };
struct C : B, A {}; // A は2番目の基底

int main() {
    C c;
    C* pc = &c;

    // 正: static_cast は A サブオブジェクトへのオフセットを調整する
    A* pa_static = static_cast<A*>(pc);

    // 誤: reinterpret_cast はビットそのまま。調整なし
    A* pa_reint = reinterpret_cast<A*>(pc);

    std::cout << "pc        = " << pc        << '\n'
              << "pa_static = " << pa_static << " (正しく A サブオブジェクトを指す)\n"
              << "pa_reint  = " << pa_reint  << " (調整なし: 誤った位置の可能性)\n";
}

実行結果

pc        = 0x7ffd7b3b2c40
pa_static = 0x7ffd7b3b2c44 (正しく A の位置に調整されることがある)
pa_reint  = 0x7ffd7b3b2c40 (C 全体の先頭=誤り)

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

互換でない関数ポインタ型へ再解釈して呼び出すのは未定義動作です。

メンバポインタもレイアウトが複雑なため、型をまたいだ再解釈は危険です。

C++

using F1 = int(int);
using F2 = void(double);

// NG: 互換性のない関数ポインタ型への変換
F1* f1 = nullptr;
// これを F2* に再解釈して呼ぶのは未定義
F2* f2 = reinterpret_cast<F2*>(f1); // 呼び出せば未定義動作

C++

struct X { int f(); };
struct Y { int f(); };

// NG: メンバポインタの型をまたいで再解釈する
int (X::*pmx)() = &X::f;
auto pmy = reinterpret_cast<int (Y::*)()>(pmx); // 未定義動作の可能性

newで作った型と違う型でdelete

newで確保した型と同じ型(または適切な基底)でのみdeleteできます。

別の型にreinterpret_castしてdeleteするのは未定義です。

C++

struct A { int x; };
struct B { int y; };

int main() {
    B* pb = new B{};
    A* pa = reinterpret_cast<A*>(pb);

    // NG: newした型(B)と異なる型(A*)でdelete → 未定義動作
    delete pa;
}

サイズや境界を無視したアクセス

サイズの大きい型へ再解釈して読み書きすると、範囲外やアラインメント違反を招きます。

C++

#include <cstdint>

// 4バイト配列を8バイト整数として読む(未定義の可能性)
std::uint32_t buf[1] = {0x11223344};
std::uint64_t* p64 = reinterpret_cast<std::uint64_t*>(buf); // アラインメント/範囲が不適切
std::uint64_t v = *p64; // 未定義動作の可能性

安全な代替と判断基準

まずstatic_cast/const_cast/dynamic_castを検討

static_cast: 数値やポインタの安全な変換、継承に基づく上位/下位変換(下位は注意)に使います。
dynamic_cast: 多態基底に対する安全なダウンキャスト。失敗時はnullptrや例外になります。
const_cast: const性の付与/除去のみ。オブジェクトが本来constなら書き込みは未定義です。

これらで目的を達せられるならreinterpret_castは不要です。

C++20ならstd::bit_castでビット等価変換

std::bit_castは、サイズが等しいトリビアルコピー可能型同士でビットパターンを安全にコピーします。

未定義動作に触れにくく、最優先で検討すべき手段です。

C++

#include <bit>
#include <cstdint>
#include <iomanip>
#include <iostream>

int main() {
    std::uint32_t u = 0x40490fdb; // IEEE754で約3.1415927f
    float f = std::bit_cast<float>(u);

    std::uint32_t u2 = std::bit_cast<std::uint32_t>(f); // 往復もOK

    std::cout << "f = " << std::setprecision(7) << f << '\n'
              << "u2=0x" << std::hex << u2 << std::dec << '\n';
}

実行結果

f = 3.141593
u2=0x40490fdb

コピーはstd::memcpyを使う

有効型を尊重しつつオブジェクト表現を別型へ搬送したいならstd::memcpyが安全です。

読み書きの側は自分の型のオブジェクトとして扱うため、未定義動作を避けられます。

C++

#include <cstring>
#include <cstdint>
#include <iostream>
#include <iomanip>

int main() {
    float f = 1.0f;
    std::uint32_t u = 0;

    // f のオブジェクト表現を u にコピー(サイズは等しい前提)
    static_assert(sizeof(f) == sizeof(u), "サイズが一致している必要があります");
    std::memcpy(&u, &f, sizeof(u));

    std::cout << "u=0x" << std::hex << u << std::dec << '\n';

    // 逆方向も同様に安全
    float g = 0.0f;
    std::memcpy(&g, &u, sizeof(g));
    std::cout << "g=" << g << '\n';
}

実行結果

u=0x3f800000
g=1

使う前のチェックリスト(本当に必要か/往復可能か/意図をコメント)

reinterpret_castを使う前に自問するチェックです。

短いコメントを添えることも品質向上に役立ちます。

それはstatic_cast/dynamic_cast/const_cast/std::bit_cast/std::memcpyで代替できないか。
ポインタ⇄整数などは往復して同じ値に戻ることが前提か。戻せない・戻さないなら設計を見直す。
アラインメント、有効型、ライフタイムの条件を満たしているか。
書き込みは本当に必要か。観察だけならstd::byteやstd::memcpyで済むのでは。
コードの意図をコメントで明示したか(将来の保守者のため)。