[C++] ポインタと配列のキャスト方法とその活用法

#include <iostream>
int main() {
    int number = 42; // 整数型の変数
    int* intPtr = &number; // 整数型のポインタ
    void* voidPtr = static_cast<void*>(intPtr); // void型のポインタにキャスト
    std::cout << "整数の値: " << *intPtr << std::endl; // ポインタを使って値を出力
    return 0;
}

整数の値: 42

#include <iostream>
class Base {
public:
    virtual void show() { std::cout << "Base class" << std::endl; }
};
class Derived : public Base {
public:
    void show() override { std::cout << "Derived class" << std::endl; }
};
int main() {
    Base* basePtr = new Derived(); // 派生クラスのインスタンスを基底クラスのポインタに
    Derived* derivedPtr = dynamic_cast<Derived*>(basePtr); // 動的キャスト
    if (derivedPtr) {
        derivedPtr->show(); // キャストが成功した場合、派生クラスのメソッドを呼び出す
    } else {
        std::cout << "キャスト失敗" << std::endl;
    }
    delete basePtr; // メモリの解放
    return 0;
}

Derived class

#include <iostream>
int main() {
    int number = 65; // 整数型の変数
    char* charPtr = reinterpret_cast<char*>(&number); // 再解釈キャスト
    std::cout << "文字としての値: " << *charPtr << std::endl; // ポインタを使って値を出力
    return 0;
}

文字としての値: A

#include <iostream>
int main() {
    int intArray[3] = {1, 2, 3}; // 整数型の配列
    void* voidPtr = static_cast<void*>(intArray); // void型のポインタにキャスト
    int* intPtr = static_cast<int*>(voidPtr); // 再び整数型のポインタにキャスト
    std::cout << "配列の最初の要素: " << intPtr[0] << std::endl; // 配列の要素を出力
    return 0;
}

配列の最初の要素: 1

#include <iostream>
int main() {
    int array[5] = {10, 20, 30, 40, 50}; // 整数型の配列
    int* ptr = array; // 配列名はポインタとして扱われる
    std::cout << "ポインタを使って配列の要素を出力: " << ptr[2] << std::endl; // 配列の3番目の要素を出力
    return 0;
}

ポインタを使って配列の要素を出力: 30

#include <iostream>
int main() {
    double doubleArray[3] = {1.1, 2.2, 3.3}; // double型の配列
    int* intPtr = reinterpret_cast<int*>(doubleArray); // 再解釈キャスト
    std::cout << "再解釈キャスト後の値: " << intPtr[0] << std::endl; // キャスト後の値を出力
    return 0;
}

再解釈キャスト後の値: 1072693248

#include <iostream>
int main() {
    char buffer[sizeof(double)]; // double型のサイズ分のバッファを確保
    double* doublePtr = reinterpret_cast<double*>(buffer); // バッファをdouble型のポインタにキャスト
    *doublePtr = 3.14159; // 値を設定
    std::cout << "バッファに格納された値: " << *doublePtr << std::endl; // 値を出力
    return 0;
}

バッファに格納された値: 3.14159

#include <iostream>
struct Data {
    int id;
    char name[20];
};
int main() {
    Data data = {1, "Example"}; // 構造体の初期化
    char* charPtr = reinterpret_cast<char*>(&data); // 構造体をchar型のポインタにキャスト
    std::cout << "構造体の名前: " << (charPtr + sizeof(int)) << std::endl; // 名前を出力
    return 0;
}

構造体の名前: Example

#include <iostream>
#include <cstring> // C言語の文字列操作関数を使用
void cFunction(char* str) {
    std::cout << "C言語の関数で受け取った文字列: " << str << std::endl;
}
int main() {
    std::string cppString = "Hello, C++"; // C++の文字列
    cFunction(const_cast<char*>(cppString.c_str())); // C言語の関数に渡すためにキャスト
    return 0;
}

C言語の関数で受け取った文字列: Hello, C++

#include <iostream>
int main() {
    unsigned char data[4] = {0x01, 0x02, 0x03, 0x04}; // バイナリデータ
    int* intPtr = reinterpret_cast<int*>(data); // バイナリデータをint型のポインタにキャスト
    std::cout << "バイナリデータを整数として解釈: " << *intPtr << std::endl; // 整数として出力
    return 0;
}

バイナリデータを整数として解釈: 67305985

#include <iostream>
#include <string>
void printCString(const char* cstr) {
    std::cout << "Cスタイルの文字列: " << cstr << std::endl;
}
int main() {
    std::string cppString = "C++ String"; // C++の文字列
    printCString(cppString.c_str()); // Cスタイルの文字列に変換して関数に渡す
    return 0;
}

Cスタイルの文字列: C++ String

#include <iostream>
#include <fstream>
int main() {
    std::ifstream file("data.bin", std::ios::binary); // バイナリファイルを開く
    if (!file) {
        std::cerr << "ファイルを開けませんでした。" << std::endl;
        return 1;
    }
    char buffer[4];
    file.read(buffer, sizeof(buffer)); // バイナリデータを読み込む
    int* intPtr = reinterpret_cast<int*>(buffer); // バッファをint型のポインタにキャスト
    std::cout << "バイナリデータを整数として解釈: " << *intPtr << std::endl;
    file.close();
    return 0;
}

#include <iostream>
#include <thread>
void threadFunction(void* data) {
    int* intData = static_cast<int*>(data); // void型のポインタをint型にキャスト
    std::cout << "スレッドで受け取ったデータ: " << *intData << std::endl;
}
int main() {
    int data = 100;
    std::thread t(threadFunction, &data); // スレッドにデータを渡す
    t.join(); // スレッドの終了を待つ
    return 0;
}

スレッドで受け取ったデータ: 100

#include <iostream>
struct Pixel {
    unsigned char r, g, b, a; // ピクセルのRGBA値
};
int main() {
    unsigned char imageData[4] = {255, 0, 0, 255}; // 赤色のピクセルデータ
    Pixel* pixelPtr = reinterpret_cast<Pixel*>(imageData); // ピクセルデータをPixel型にキャスト
    std::cout << "ピクセルの赤成分: " << static_cast<int>(pixelPtr->r) << std::endl;
    return 0;
}

ピクセルの赤成分: 255

#include <iostream>
struct Header {
    unsigned short id;
    unsigned short length;
};
int main() {
    unsigned char packet[4] = {0x01, 0x00, 0x10, 0x00}; // ネットワークパケットのヘッダデータ
    Header* headerPtr = reinterpret_cast<Header*>(packet); // パケットをHeader型にキャスト
    std::cout << "パケットID: " << headerPtr->id << ", 長さ: " << headerPtr->length << std::endl;
    return 0;
}

パケットID: 1, 長さ: 16