constが外れる？Cスタイルキャストの落とし穴と対処法

#include <iostream>

int main() {
    int i = 42;

    double d1 = (double)i;  // Cスタイル
    double d2 = double(i);  // 関数風(意味はCスタイルと同じ)

    std::cout << d1 << ", " << d2 << std::endl;
}

#include <iostream>

int main() {
    // 安全なケース: 元のオブジェクトは非const
    int x = 42;
    const int* cp = &x;                // 読み取り専用ビュー
    int* wp = (int*)cp;                // Cスタイルでconstを外す(よくないが今回は安全)
    *wp = 100;                         // 実体は非constなので書き換えは定義済み

    std::cout << "safe: x=" << x << std::endl;

    // 危険なケース: 実体がconst
    const int y = 7;
    const int* cpy = &y;
    int* wpy = (int*)cpy;              // const除去
    // *wpy = 200;                     // 実体はconst。書き込みは未定義動作。コメントアウト
    std::cout << "danger: y=" << y << " (書き換えは未定義動作)" << std::endl;
}

#include <iostream>

struct P { int a; int b; };

int main() {
    double d = 3.14159;
    void* vp = &d;

    // 全く関係ない型にCスタイルキャスト(通ってしまう)
    P* p = (P*)vp;

    // 以下の読み書きは未定義動作。アラインメントや表現が保証されない。
    // 実行環境によってはクラッシュする可能性があります。
    std::cout << "p->a (未定義動作の一例): " << p->a << std::endl;
}

#include <iostream>
#include <iomanip>

int main() {
    double big = 1e20;                 // intの範囲を超える
    int narrowed = (int)big;          // Cスタイルで縮小(情報落ち)
    float f = (float)16777217.0;      // floatが表現できる整数の限界を超える

    std::cout << "narrowed=" << narrowed << std::endl;
    std::cout << std::setprecision(20) << "float f=" << f << std::endl;

    // 推奨: 明示のstatic_cast (それでも縮小だが、意図が明示されレビューで気付きやすい)
    int safer = static_cast<int>(big);
    std::cout << "safer=" << safer << std::endl;

    // さらに推奨: 波括弧初期化なら縮小はコンパイルエラー
    // int ng{big}; // エラー: narrowing conversion
}

#include <iostream>

int main() {
    double d = 3.14;

    // 型ねじれ: doubleの実体にint参照を無理やり紐付ける(未定義動作)
    int& ir = (int&)d;     // 通ってしまう
    ir = 0;                // doubleのビット列を書き換える

    std::cout << "d after write via int& (未定義動作の一例): " << d << std::endl;

    // 寿命切れ: 一時std::stringから得たポインタを保持
    const char* p = ((std::string)"hello").c_str();
    // ここで一時オブジェクトは破棄済み。pはダングリング。
    std::cout << "dangling c_str (未定義動作の一例): " << p << std::endl;
}

#include <iostream>
#include <memory>

struct Base { virtual ~Base() = default; };
struct Derived : Base { void hello() const { std::cout << "Derived::hello\n"; } };

int main() {
    // 数値変換
    double d = 3.7;
    int i = static_cast<int>(d);     // 明示的に小数を切り捨て
    std::cout << "i=" << i << std::endl;

    // アップキャスト(派生->基底)
    std::unique_ptr<Derived> pd = std::make_unique<Derived>();
    Base* pb = static_cast<Base*>(pd.get()); // 安全。dynamic_cast不要な方向
    (void)pb;

    // コンパイルで拒否してくれる例
    // double* dp = &d;
    // int* ip = static_cast<int*>(dp); // エラー: 無関係なポインタは拒否
}

#include <iostream>

// レガシAPIの仮定: バッファを書き換えないが、歴史的事情でchar*を受け取る
void legacy_print(char* p) {
    // 書き換えない契約
    std::cout << p << std::endl;
}

int main() {
    std::string s = "hello";
    const char* cp = s.c_str();

    // 一時的にconstを外して渡す(書き換えない契約がある前提でのみ許容)
    legacy_print(const_cast<char*>(cp));

    // 危険例: 実体がconstのものは決して外してはいけません
    // const int x = 42;
    // int* px = const_cast<int*>(&x); // 取得自体はできるが、書き込みは未定義動作
}

#include <iostream>
#include <memory>
#include <typeinfo>

struct Base { virtual ~Base() = default; };
struct Derived : Base { void hello() const { std::cout << "Derived!\n"; } };

void call_if_derived(Base* pb) {
    if (auto pd = dynamic_cast<Derived*>(pb)) {
        pd->hello();                  // 成功時のみ呼べる
    } else {
        std::cout << "not Derived\n"; // 失敗を安全に検出
    }
}

int main() {
    Base b;
    Derived d;

    call_if_derived(&b);
    call_if_derived(&d);
}

#include <iostream>
#include <cstdint>

int main() {
    int x = 42;
    // デバッグ用途: ポインタを整数に一時的に変換(元に戻せる保証が前提)
    std::uintptr_t addr = reinterpret_cast<std::uintptr_t>(&x);
    std::cout << std::hex << "addr=0x" << addr << std::endl;

    // 注意: 無関係な型へのポインタ変換や、変換後の逆参照は未定義動作になり得ます
    // double* dp = reinterpret_cast<double*>(&x); // 逆参照は未定義動作の可能性
}