【C++】new deleteを使わずに動的メモリ確保を行う方法

#include <iostream>
int main() {
    // int型のメモリを動的に確保
    int* p = new int;
    // 確保したメモリに値を代入
    *p = 42;
    // 値を表示
    std::cout << *p << std::endl;
    // メモリを解放
    delete p;
    return 0;
}

int* p = new int; // delete p; // メモリを解放しない

int* p = new int;
delete p;
// delete p; // 二重解放

#include <iostream>
#include <memory>
int main() {
    // int型の動的メモリを確保し、unique_ptrに所有させる
    std::unique_ptr<int> ptr = std::make_unique<int>(10);
    // ポインタが所有する値を表示
    std::cout << *ptr << std::endl;
    // unique_ptrはスコープを抜けると自動的にメモリを解放する
    return 0;
}

#include <iostream>
#include <memory>
int main() {
    // int型の動的メモリを確保し、shared_ptrに所有させる
    std::shared_ptr<int> ptr1 = std::make_shared<int>(20);
    {
        // ptr1の所有権を共有するshared_ptrを作成
        std::shared_ptr<int> ptr2 = ptr1;
        // ポインタが所有する値を表示
        std::cout << *ptr2 << std::endl;
    } // ptr2がスコープを抜けると、参照カウントが減少
    // ptr1が所有する値を表示
    std::cout << *ptr1 << std::endl;
    // ptr1がスコープを抜けると、メモリが解放される
    return 0;
}

#include <iostream>
#include <memory>
int main() {
    // int型の動的メモリを確保し、shared_ptrに所有させる
    std::shared_ptr<int> ptr1 = std::make_shared<int>(30);
    // shared_ptrの所有権を共有するweak_ptrを作成
    std::weak_ptr<int> weakPtr = ptr1;
    // weak_ptrをlockしてshared_ptrを取得
    if (auto sharedPtr = weakPtr.lock()) {
        // ポインタが所有する値を表示
        std::cout << *sharedPtr << std::endl;
    } else {
        std::cout << "リソースは解放されました" << std::endl;
    }
    return 0;
}

#include <iostream>
#include <vector>
int main() {
    std::vector<int> vec; // int型の動的配列を作成
    // 要素の追加
    vec.push_back(1);
    vec.push_back(2);
    vec.push_back(3);
    // 要素の表示
    for (int i = 0; i < vec.size(); ++i) {
        std::cout << vec[i] << " ";
    }
    std::cout << std::endl;
    return 0;
}

#include <iostream>
#include <string>
int main() {
    std::string str = "Hello, "; // 文字列を初期化
    str += "World!"; // 文字列を連結
    std::cout << str << std::endl; // 文字列を表示
    return 0;
}

#include <iostream>
#include <list>
int main() {
    std::list<int> lst; // int型の双方向リストを作成
    // 要素の追加
    lst.push_back(1);
    lst.push_back(2);
    lst.push_back(3);
    // 要素の表示
    for (int val : lst) {
        std::cout << val << " ";
    }
    std::cout << std::endl;
    return 0;
}

#include <iostream>
#include <map>
int main() {
    std::map<int, std::string> mp; // int型のキーとstring型の値を持つ連想配列を作成
    // 要素の追加
    mp[1] = "One";
    mp[2] = "Two";
    mp[3] = "Three";
    // 要素の表示
    for (const auto& pair : mp) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
    return 0;
}

#include <iostream>
#include <unordered_map>
int main() {
    std::unordered_map<int, std::string> ump; // int型のキーとstring型の値を持つハッシュテーブルを作成
    // 要素の追加
    ump[1] = "One";
    ump[2] = "Two";
    ump[3] = "Three";
    // 要素の表示
    for (const auto& pair : ump) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
    return 0;
}

#include <boost/pool/simple_segregated_storage.hpp>
#include <iostream>
#include <vector>
int main() {
    // メモリプールの準備
    boost::simple_segregated_storage<std::size_t> storage;
    std::vector<char> memory_pool(1024); // 1KBのメモリプールを確保
    storage.add_block(&memory_pool.front(), memory_pool.size(), 32); // 32バイトのブロックに分割
    // メモリの確保
    void* p1 = storage.malloc();
    void* p2 = storage.malloc();
    // メモリの利用
    if (p1 && p2) {
        std::cout << "メモリ確保成功" << std::endl;
    }
    // メモリの解放
    storage.free(p1);
    storage.free(p2);
    return 0;
}

#include <boost/pool/simple_segregated_storage.hpp>
#include <iostream>
#include <vector>
#include <chrono>
int main() {
    const int num_allocations = 100000;
    // メモリプールを使わない場合
    auto start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < num_allocations; ++i) {
        void* p = std::malloc(32);
        std::free(p);
    }
    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> duration = end - start;
    std::cout << "メモリプールを使わない場合の時間: " << duration.count() << "秒" << std::endl;
    // メモリプールを使う場合
    boost::simple_segregated_storage<std::size_t> storage;
    std::vector<char> memory_pool(1024 * 1024); // 1MBのメモリプールを確保
    storage.add_block(&memory_pool.front(), memory_pool.size(), 32); // 32バイトのブロックに分割
    start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < num_allocations; ++i) {
        void* p = storage.malloc();
        storage.free(p);
    }
    end = std::chrono::high_resolution_clock::now();
    duration = end - start;
    std::cout << "メモリプールを使う場合の時間: " << duration.count() << "秒" << std::endl;
    return 0;
}

#include <iostream>
#include <memory>
#include <vector>
// カスタムアロケータの定義
template <typename T>
class CustomAllocator {
public:
    using value_type = T;
    CustomAllocator() = default;
    template <typename U>
    CustomAllocator(const CustomAllocator<U>&) {}
    T* allocate(std::size_t n) {
        std::cout << "Allocating " << n << " elements of size " << sizeof(T) << std::endl;
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }
    void deallocate(T* p, std::size_t n) {
        std::cout << "Deallocating " << n << " elements of size " << sizeof(T) << std::endl;
        ::operator delete(p);
    }
};
// アロケータの等価性を定義
template <typename T, typename U>
bool operator==(const CustomAllocator<T>&, const CustomAllocator<U>&) { return true; }
template <typename T, typename U>
bool operator!=(const CustomAllocator<T>&, const CustomAllocator<U>&) { return false; }
int main() {
    // カスタムアロケータを使用したベクトル
    std::vector<int, CustomAllocator<int>> vec;
    vec.push_back(1);
    vec.push_back(2);
    vec.push_back(3);
    for (const auto& elem : vec) {
        std::cout << elem << std::endl;
    }
    return 0;
}

#include <iostream>
#include <memory>
#include <vector>
#include <list>
// メモリプールの定義
class MemoryPool {
public:
    MemoryPool(std::size_t size) : poolSize(size), pool(new char[size]), offset(0) {}
    ~MemoryPool() {
        delete[] pool;
    }
    void* allocate(std::size_t size) {
        if (offset + size > poolSize) {
            throw std::bad_alloc();
        }
        void* ptr = pool + offset;
        offset += size;
        return ptr;
    }
    void deallocate(void* ptr, std::size_t size) {
        // メモリプールでは解放は行わない
    }
private:
    std::size_t poolSize;
    char* pool;
    std::size_t offset;
};
// カスタムアロケータの定義
template <typename T>
class PoolAllocator {
public:
    using value_type = T;
    PoolAllocator(MemoryPool& pool) : memoryPool(pool) {}
    template <typename U>
    PoolAllocator(const PoolAllocator<U>& other) : memoryPool(other.memoryPool) {}
    T* allocate(std::size_t n) {
        return static_cast<T*>(memoryPool.allocate(n * sizeof(T)));
    }
    void deallocate(T* p, std::size_t n) {
        memoryPool.deallocate(p, n * sizeof(T));
    }
private:
    MemoryPool& memoryPool;
};
// アロケータの等価性を定義
template <typename T, typename U>
bool operator==(const PoolAllocator<T>&, const PoolAllocator<U>&) { return true; }
template <typename T, typename U>
bool operator!=(const PoolAllocator<T>&, const PoolAllocator<U>&) { return false; }
int main() {
    MemoryPool pool(1024); // 1KBのメモリプールを作成
    std::vector<int, PoolAllocator<int>> vec(PoolAllocator<int>(pool));
    vec.push_back(1);
    vec.push_back(2);
    vec.push_back(3);
    for (const auto& elem : vec) {
        std::cout << elem << std::endl;
    }
    return 0;
}

#include <iostream>
#include <fstream>
class FileRAII {
public:
    // コンストラクタでファイルを開く
    FileRAII(const std::string& filename) {
        file.open(filename);
        if (!file.is_open()) {
            throw std::runtime_error("ファイルを開けませんでした");
        }
    }
    // デストラクタでファイルを閉じる
    ~FileRAII() {
        if (file.is_open()) {
            file.close();
        }
    }
    // ファイルストリームへのアクセスを提供
    std::ofstream& get() {
        return file;
    }
private:
    std::ofstream file;
};
int main() {
    try {
        FileRAII file("example.txt");
        file.get() << "Hello, RAII!" << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "エラー: " << e.what() << std::endl;
    }
    return 0;
}

#include <iostream>
#include <memory>
class Resource {
public:
    Resource() {
        std::cout << "Resource acquired" << std::endl;
    }
    ~Resource() {
        std::cout << "Resource released" << std::endl;
    }
    void doSomething() {
        std::cout << "Doing something with the resource" << std::endl;
    }
};
int main() {
    {
        std::unique_ptr<Resource> resource = std::make_unique<Resource>();
        resource->doSomething();
    } // スコープを抜けるときに自動的にリソースが解放される
    return 0;
}