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

#include <iostream>
#include <cstdlib> // malloc, freeを使用するために必要
int main() {
    int* array; // 整数型のポインタを宣言
    int size = 5; // 配列のサイズを指定
    // 動的メモリを確保
    array = (int*)malloc(size * sizeof(int)); // size分のメモリを確保
    // 確保したメモリに値を代入
    for (int i = 0; i < size; i++) {
        array[i] = i + 1; // 1から5までの値を代入
    }
    // 確保したメモリの内容を表示
    for (int i = 0; i < size; i++) {
        std::cout << array[i] << " "; // 配列の内容を表示
    }
    std::cout << std::endl;
    // 確保したメモリを解放
    free(array); // メモリを解放
    return 0; // プログラムの終了
}

1 2 3 4 5

#include <iostream>
#include <cstdlib> // malloc, freeを使用するために必要
int main() {
    int* numbers; // 整数型のポインタを宣言
    int count = 5; // 確保するメモリのサイズを指定
    // メモリを確保
    numbers = (int*)malloc(count * sizeof(int)); // count分のメモリを確保
    // 確保したメモリに値を代入
    for (int i = 0; i < count; i++) {
        numbers[i] = (i + 1) * 10; // 10, 20, 30, 40, 50を代入
    }
    // 確保したメモリの内容を表示
    for (int i = 0; i < count; i++) {
        std::cout << numbers[i] << " "; // 配列の内容を表示
    }
    std::cout << std::endl;
    // 確保したメモリを解放
    free(numbers); // メモリを解放
    return 0; // プログラムの終了
}

10 20 30 40 50

#include <iostream>
#include <cstdlib> // calloc, freeを使用するために必要
int main() {
    int* numbers; // 整数型のポインタを宣言
    int count = 5; // 確保するメモリのサイズを指定
    // メモリを確保し、ゼロで初期化
    numbers = (int*)calloc(count, sizeof(int)); // count分のメモリを確保
    // 確保したメモリの内容を表示
    for (int i = 0; i < count; i++) {
        std::cout << numbers[i] << " "; // 配列の内容を表示
    }
    std::cout << std::endl; // ゼロで初期化されているため、すべて0が表示される
    // 確保したメモリを解放
    free(numbers); // メモリを解放
    return 0; // プログラムの終了
}

0 0 0 0 0

#include <iostream>
#include <cstdlib> // realloc, freeを使用するために必要
int main() {
    int* numbers; // 整数型のポインタを宣言
    int count = 5; // 初期のサイズを指定
    // メモリを確保
    numbers = (int*)malloc(count * sizeof(int)); // count分のメモリを確保
    // 確保したメモリに値を代入
    for (int i = 0; i < count; i++) {
        numbers[i] = (i + 1) * 10; // 10, 20, 30, 40, 50を代入
    }
    // メモリのサイズを変更
    count = 10; // 新しいサイズを指定
    numbers = (int*)realloc(numbers, count * sizeof(int)); // メモリのサイズを変更
    // 新しいメモリに値を代入
    for (int i = 5; i < count; i++) {
        numbers[i] = (i + 1) * 10; // 60, 70, 80, 90, 100を代入
    }
    // 確保したメモリの内容を表示
    for (int i = 0; i < count; i++) {
        std::cout << numbers[i] << " "; // 配列の内容を表示
    }
    std::cout << std::endl;
    // 確保したメモリを解放
    free(numbers); // メモリを解放
    return 0; // プログラムの終了
}

10 20 30 40 50 60 70 80 90 100

#include <iostream>
#include <cstdlib> // malloc, freeを使用するために必要
int main() {
    int* ptr; // 整数型のポインタを宣言
    // メモリを確保
    ptr = (int*)malloc(sizeof(int)); // 1つの整数分のメモリを確保
    // 確保したメモリに値を代入
    *ptr = 42; // 値を代入
    // 確保したメモリの内容を表示
    std::cout << "mallocで確保した値: " << *ptr << std::endl; // 42が表示される
    // 確保したメモリを解放
    free(ptr); // メモリを解放
    return 0; // プログラムの終了
}

mallocで確保した値: 42

#include <iostream>
int main() {
    int* ptr; // 整数型のポインタを宣言
    // メモリを確保
    ptr = new int; // 1つの整数分のメモリを確保
    // 確保したメモリに値を代入
    *ptr = 42; // 値を代入
    // 確保したメモリの内容を表示
    std::cout << "newで確保した値: " << *ptr << std::endl; // 42が表示される
    // 確保したメモリを解放
    delete ptr; // メモリを解放
    return 0; // プログラムの終了
}

newで確保した値: 42

#include <iostream>
#include <cstdlib> // malloc, freeを使用するために必要
int main() {
    int* ptr = (int*)malloc(sizeof(int) * 1000000000); // 大きなメモリを要求
    // メモリ確保の成功を確認
    if (ptr == NULL) {
        std::cerr << "メモリの確保に失敗しました。" << std::endl;
        return 1; // エラー終了
    }
    // メモリを使用する処理
    free(ptr); // メモリを解放
    return 0; // プログラムの終了
}

#include <iostream>
#include <cstdlib> // malloc, freeを使用するために必要
int main() {
    int* ptr = (int*)malloc(sizeof(int) * 10); // メモリを確保
    // メモリを使用する処理
    // free(ptr); // 解放を忘れないようにする
    return 0; // プログラムの終了
}

#include <iostream>
#include <cstdlib> // malloc, freeを使用するために必要
int main() {
    int* ptr = (int*)malloc(sizeof(int)); // メモリを確保
    free(ptr); // メモリを解放
    ptr = NULL; // ポインタをNULLに設定
    // free(ptr); // これ以降の解放は安全
    return 0; // プログラムの終了
}

#include <iostream>
#include <cstdlib> // malloc, freeを使用するために必要
int main() {
    int* ptr = (int*)malloc(sizeof(int)); // 明示的なキャスト
    if (ptr != NULL) {
        *ptr = 42; // 値を代入
        std::cout << "値: " << *ptr << std::endl; // 42が表示される
    }
    free(ptr); // メモリを解放
    return 0; // プログラムの終了
}

#include <iostream>
#include <cstdlib> // malloc, freeを使用するために必要
int main() {
    int count = 10;
    int* ptr = (int*)malloc(count * sizeof(int)); // 正しいサイズを指定
    // メモリを使用する処理
    free(ptr); // メモリを解放
    return 0; // プログラムの終了
}

#include <iostream>
#include <vector> // std::vectorを使用するために必要
int main() {
    std::vector<int> numbers; // 整数型のベクターを宣言
    // 要素を追加
    for (int i = 1; i <= 5; i++) {
        numbers.push_back(i * 10); // 10, 20, 30, 40, 50を追加
    }
    // ベクターの内容を表示
    for (int num : numbers) {
        std::cout << num << " "; // 10 20 30 40 50が表示される
    }
    std::cout << std::endl;
    return 0; // プログラムの終了
}

10 20 30 40 50

#include <iostream>
#include <memory> // std::unique_ptrを使用するために必要
int main() {
    std::unique_ptr<int> ptr(new int); // 整数型のユニークポインタを宣言
    *ptr = 42; // 値を代入
    // 確保したメモリの内容を表示
    std::cout << "unique_ptrで確保した値: " << *ptr << std::endl; // 42が表示される
    // メモリは自動的に解放される
    return 0; // プログラムの終了
}

unique_ptrで確保した値: 42

#include <iostream>
#include <memory> // std::shared_ptrを使用するために必要
int main() {
    std::shared_ptr<int> ptr1(new int); // 整数型のシェアードポインタを宣言
    *ptr1 = 42; // 値を代入
    // ptr1をptr2にコピー
    std::shared_ptr<int> ptr2 = ptr1; // 参照カウントが増加
    // 確保したメモリの内容を表示
    std::cout << "shared_ptrで確保した値: " << *ptr1 << std::endl; // 42が表示される
    std::cout << "参照カウント: " << ptr1.use_count() << std::endl; // 参照カウントが表示される
    // メモリは自動的に解放される
    return 0; // プログラムの終了
}

shared_ptrで確保した値: 42
参照カウント: 2

#include <iostream>
#include <array> // std::arrayを使用するために必要
int main() {
    std::array<int, 5> numbers = {10, 20, 30, 40, 50}; // 固定サイズの配列を宣言
    // 配列の内容を表示
    for (int num : numbers) {
        std::cout << num << " "; // 10 20 30 40 50が表示される
    }
    std::cout << std::endl;
    return 0; // プログラムの終了
}

10 20 30 40 50

#include <iostream>
#include <vector>
#include <memory> // std::unique_ptrを使用するために必要
class PoolAllocator {
public:
    PoolAllocator(size_t size) {
        pool = std::malloc(size); // プールのメモリを確保
        current = pool; // 現在の位置を初期化
    }
    ~PoolAllocator() {
        std::free(pool); // プールのメモリを解放
    }
    void* allocate(size_t size) {
        void* result = current; // 現在の位置を返す
        current = static_cast<char*>(current) + size; // 現在の位置を更新
        return result; // 割り当てたメモリを返す
    }
private:
    void* pool; // プールのメモリ
    void* current; // 現在の位置
};
int main() {
    PoolAllocator allocator(1024); // 1KBのプールを作成
    // メモリを割り当て
    int* num = static_cast<int*>(allocator.allocate(sizeof(int)));
    *num = 42; // 値を代入
    std::cout << "プールアロケータで確保した値: " << *num << std::endl; // 42が表示される
    return 0; // プログラムの終了
}

プールアロケータで確保した値: 42

#include <iostream>
#include <memory> // std::unique_ptrを使用するために必要
void customDeleter(int* ptr) {
    std::cout << "カスタムデリータが呼ばれました。" << std::endl;
    delete ptr; // メモリを解放
}
int main() {
    std::unique_ptr<int, decltype(&customDeleter)> ptr(new int, customDeleter); // カスタムデリータを指定
    *ptr = 42; // 値を代入
    std::cout << "値: " << *ptr << std::endl; // 42が表示される
    return 0; // プログラムの終了
}

カスタムデリータが呼ばれました。
値: 42

#include <iostream>
#include <fstream>
#include <sys/mman.h> // mmap, munmapを使用するために必要
#include <fcntl.h> // openを使用するために必要
#include <unistd.h> // closeを使用するために必要
int main() {
    const char* filename = "example.txt"; // マップするファイル名
    int fd = open(filename, O_RDONLY); // ファイルをオープン
    if (fd == -1) {
        std::cerr << "ファイルをオープンできませんでした。" << std::endl;
        return 1; // エラー終了
    }
    // ファイルサイズを取得
    off_t filesize = lseek(fd, 0, SEEK_END);
    lseek(fd, 0, SEEK_SET); // ファイルポインタを先頭に戻す
    // メモリマッピング
    char* mapped = static_cast<char*>(mmap(nullptr, filesize, PROT_READ, MAP_PRIVATE, fd, 0));
    if (mapped == MAP_FAILED) {
        std::cerr << "メモリマッピングに失敗しました。" << std::endl;
        close(fd); // ファイルをクローズ
        return 1; // エラー終了
    }
    // マップされたデータを表示
    std::cout.write(mapped, filesize); // ファイルの内容を表示
    // メモリマッピングを解除
    munmap(mapped, filesize);
    close(fd); // ファイルをクローズ
    return 0; // プログラムの終了
}

(example.txtの内容が表示される)

#include <iostream>
#include <memory> // std::unique_ptrを使用するために必要
#include <mutex> // std::mutexを使用するために必要
#include <thread> // std::threadを使用するために必要
std::mutex mtx; // ミューテックスを宣言
void threadFunction() {
    std::lock_guard<std::mutex> lock(mtx); // ミューテックスをロック
    int* ptr = new int; // メモリを確保
    *ptr = 42; // 値を代入
    std::cout << "スレッドで確保した値: " << *ptr << std::endl; // 42が表示される
    delete ptr; // メモリを解放
}
int main() {
    std::thread t1(threadFunction); // スレッドを作成
    std::thread t2(threadFunction); // もう1つのスレッドを作成
    t1.join(); // スレッドの終了を待機
    t2.join(); // スレッドの終了を待機
    return 0; // プログラムの終了
}

スレッドで確保した値: 42
スレッドで確保した値: 42