[C++] 構造体をmemcpyでコピーする方法と注意点

#include <cstring> // memcpyを使用するために必要
void* memcpy(void* dest, const void* src, std::size_t count);

#include <iostream>
#include <cstring>
int main() {
    char source[] = "Hello, World!";
    char destination[20];
    // sourceからdestinationへコピー
    std::memcpy(destination, source, sizeof(source));
    std::cout << "Copied string: " << destination << std::endl;
    return 0;
}

Copied string: Hello, World!

#include <iostream>
struct Example {
    char a;     // 1バイト
    int b;      // 4バイト
    double c;   // 8バイト
};
int main() {
    std::cout << "Size of Example: " << sizeof(Example) << " bytes" << std::endl;
    return 0;
}

Size of Example: 16 bytes

#include <iostream>
#include <cstring>
struct Data {
    int id;
    char name[50];
};
int main() {
    Data source = {1, "Sample Name"};
    Data destination;
    // sourceからdestinationへ構造体をコピー
    std::memcpy(&destination, &source, sizeof(Data));
    std::cout << "Copied Data: ID = " << destination.id << ", Name = " << destination.name << std::endl;
    return 0;
}

Copied Data: ID = 1, Name = Sample Name

#include <iostream>
#include <cstring>
struct Node {
    int value;
    int* pointer;
};
int main() {
    int data = 42;
    Node source = {1, &data};
    Node destination;
    // シャローコピー
    std::memcpy(&destination, &source, sizeof(Node));
    std::cout << "Source pointer value: " << *(source.pointer) << std::endl;
    std::cout << "Destination pointer value: " << *(destination.pointer) << std::endl;
    return 0;
}

Source pointer value: 42
Destination pointer value: 42

#include <iostream>
struct AlignedStruct {
    char a;
    int b;
};
int main() {
    std::cout << "Alignment of AlignedStruct: " << alignof(AlignedStruct) << std::endl;
    return 0;
}

Alignment of AlignedStruct: 4

#include <iostream>
#include <cstring>
struct DeepCopyStruct {
    int size;
    int* data;
};
void deepCopy(DeepCopyStruct& dest, const DeepCopyStruct& src) {
    dest.size = src.size;
    dest.data = new int[src.size];
    std::memcpy(dest.data, src.data, src.size * sizeof(int));
}
int main() {
    DeepCopyStruct source = {3, new int[3]{1, 2, 3}};
    DeepCopyStruct destination;
    // ディープコピー
    deepCopy(destination, source);
    std::cout << "Source data: " << source.data[0] << ", " << source.data[1] << ", " << source.data[2] << std::endl;
    std::cout << "Destination data: " << destination.data[0] << ", " << destination.data[1] << ", " << destination.data[2] << std::endl;
    delete[] source.data;
    delete[] destination.data;
    return 0;
}

Source data: 1, 2, 3
Destination data: 1, 2, 3

#include <iostream>
#include <cstring>
struct SafeCopyStruct {
    int id;
    char name[50];
};
int main() {
    SafeCopyStruct source = {1, "Safe Copy"};
    SafeCopyStruct* destination = new SafeCopyStruct;
    // メモリが十分に確保されていることを確認
    std::memcpy(destination, &source, sizeof(SafeCopyStruct));
    std::cout << "Copied ID: " << destination->id << ", Name: " << destination->name << std::endl;
    delete destination;
    return 0;
}

Copied ID: 1, Name: Safe Copy

#include <iostream>
#include <cstring>
struct Item {
    int id;
    char name[20];
};
int main() {
    Item sourceArray[3] = {{1, "Item1"}, {2, "Item2"}, {3, "Item3"}};
    Item destinationArray[3];
    // 配列全体をコピー
    std::memcpy(destinationArray, sourceArray, sizeof(sourceArray));
    for (const auto& item : destinationArray) {
        std::cout << "ID: " << item.id << ", Name: " << item.name << std::endl;
    }
    return 0;
}

ID: 1, Name: Item1
ID: 2, Name: Item2
ID: 3, Name: Item3

#include <iostream>
#include <fstream>
#include <cstring>
struct Record {
    int id;
    char name[30];
};
int main() {
    Record record = {1, "Binary Record"};
    std::ofstream outFile("record.bin", std::ios::binary);
    if (outFile) {
        outFile.write(reinterpret_cast<const char*>(&record), sizeof(Record));
        outFile.close();
        std::cout << "Record written to file." << std::endl;
    } else {
        std::cerr << "Failed to open file for writing." << std::endl;
    }
    return 0;
}

Record written to file.

#include <iostream>
#include <cstring>
struct Packet {
    int type;
    char data[256];
};
void sendPacket(const Packet& packet) {
    // ここでネットワーク送信処理を行う
    std::cout << "Packet sent: Type = " << packet.type << ", Data = " << packet.data << std::endl;
}
int main() {
    Packet packet = {1, "Network Data"};
    char buffer[sizeof(Packet)];
    // 構造体をバッファにコピー
    std::memcpy(buffer, &packet, sizeof(Packet));
    // バッファを送信
    sendPacket(*reinterpret_cast<Packet*>(buffer));
    return 0;
}

Packet sent: Type = 1, Data = Network Data

#include <iostream>
#include <cstring>
struct Message {
    int id;
    char text[100];
};
void processBuffer(const char* buffer) {
    const Message* msg = reinterpret_cast<const Message*>(buffer);
    std::cout << "Processing Message: ID = " << msg->id << ", Text = " << msg->text << std::endl;
}
int main() {
    Message message = {42, "Buffered Message"};
    char buffer[sizeof(Message)];
    // 構造体をバッファにコピー
    std::memcpy(buffer, &message, sizeof(Message));
    // バッファを処理
    processBuffer(buffer);
    return 0;
}

Processing Message: ID = 42, Text = Buffered Message