[C++] operator newとは？使い方や実装方法を解説

class MyClass {
public:
    MyClass() {
        // コンストラクタの処理
    }
    // その他のメンバ関数
};
int main() {
    MyClass* obj = new MyClass(); // operator newが呼ばれる
    // objを使用する処理
    delete obj; // メモリを解放
    return 0;
}

int main() {
    int size = 5;
    MyClass* arr = new MyClass[size]; // 配列のメモリを確保
    // arrを使用する処理
    delete[] arr; // 配列のメモリを解放
    return 0;
}

int main() {
    try {
        MyClass* obj = new MyClass(); // メモリの割り当て
        // objを使用する処理
        delete obj; // メモリを解放
    } catch (const std::bad_alloc& e) {
        std::cerr << "メモリの割り当てに失敗しました: " << e.what() << std::endl;
    }
    return 0;
}

#include <iostream>
#include <cstdlib> // std::malloc, std::free
void* operator new(std::size_t size) {
    std::cout << "カスタム operator new: " << size << " バイトのメモリを確保します。" << std::endl;
    void* ptr = std::malloc(size); // メモリを確保
    if (!ptr) {
        throw std::bad_alloc(); // メモリ確保失敗時に例外を投げる
    }
    return ptr;
}
void operator delete(void* ptr) noexcept {
    std::cout << "カスタム operator delete: メモリを解放します。" << std::endl;
    std::free(ptr); // メモリを解放
}

#include <iostream>
#include <vector>
class MemoryPool {
public:
    MemoryPool(std::size_t blockSize, std::size_t blockCount) {
        for (std::size_t i = 0; i < blockCount; ++i) {
            void* block = std::malloc(blockSize);
            if (block) {
                freeBlocks.push_back(block); // 確保したブロックをプールに追加
            }
        }
    }
    ~MemoryPool() {
        for (void* block : freeBlocks) {
            std::free(block); // プールのメモリを解放
        }
    }
    void* allocate() {
        if (freeBlocks.empty()) {
            return nullptr; // 空の場合はnullptrを返す
        }
        void* block = freeBlocks.back();
        freeBlocks.pop_back(); // 使用するブロックを取り出す
        return block;
    }
    void deallocate(void* block) {
        freeBlocks.push_back(block); // ブロックをプールに戻す
    }
private:
    std::vector<void*> freeBlocks; // 自由なメモリブロックのリスト
};

#include <iostream>
#include <vector>
class MemoryPool {
public:
    MemoryPool(std::size_t blockSize, std::size_t blockCount) {
        for (std::size_t i = 0; i < blockCount; ++i) {
            void* block = std::malloc(blockSize);
            if (block) {
                freeBlocks.push_back(block); // 確保したブロックをプールに追加
            }
        }
    }
    ~MemoryPool() {
        for (void* block : freeBlocks) {
            std::free(block); // プールのメモリを解放
        }
    }
    void* allocate() {
        if (freeBlocks.empty()) {
            return nullptr; // 空の場合はnullptrを返す
        }
        void* block = freeBlocks.back();
        freeBlocks.pop_back(); // 使用するブロックを取り出す
        return block;
    }
    void deallocate(void* block) {
        freeBlocks.push_back(block); // ブロックをプールに戻す
    }
private:
    std::vector<void*> freeBlocks; // 自由なメモリブロックのリスト
};
int main() {
    MemoryPool pool(sizeof(int), 10); // int型のメモリプールを作成
    int* num = static_cast<int*>(pool.allocate()); // メモリを割り当て
    *num = 42; // 値を設定
    std::cout << "割り当てた値: " << *num << std::endl;
    pool.deallocate(num); // メモリを解放
    return 0;
}

#include <iostream>
#include <cstring>

void* operator new(std::size_t size) {
    std::cout << "デバッグ: " << size << " バイトのメモリを確保します。" << std::endl;
    void* ptr = std::malloc(size);
    if (!ptr) {
        throw std::bad_alloc();
    }
    return ptr;
}
void operator delete(void* ptr) noexcept {
    std::cout << "デバッグ: メモリを解放します。" << std::endl;
    std::free(ptr);
}

struct Student {
    int id;
    char name[20];
};

int main() {
    Student* src = new Student{1, "山田太郎"}; // コピー元の構造体
    Student* dest = new Student; // コピー先の構造体
    std::memcpy(dest, src, sizeof(Student)); // 構造体全体をコピー
    std::cout << "コピーした構造体: ID=" << dest->id << ", 名前=" << dest->name << std::endl;
    delete src;
    delete dest;
    return 0;
}

#include <iostream>
#include <map>
#include <cstdlib> // std::malloc, std::free
std::map<void*, std::size_t> allocations; // 割り当てたメモリのトラッキング
void* operator new(std::size_t size) {
    void* ptr = std::malloc(size);
    if (!ptr) {
        throw std::bad_alloc();
    }
    allocations[ptr] = size; // 割り当てたメモリを記録
    return ptr;
}
void operator delete(void* ptr) noexcept {
    if (allocations.find(ptr) != allocations.end()) {
        allocations.erase(ptr); // 割り当てたメモリを削除
    }
    std::free(ptr);
}
void reportMemoryUsage() {
    std::cout << "現在のメモリ使用状況:" << std::endl;
    for (const auto& allocation : allocations) {
        std::cout << "ポインタ: " << allocation.first << ", サイズ: " << allocation.second << " バイト" << std::endl;
    }
}