[C++] 配列をメンバ変数として動的に確保する方法

class DynamicArray {
private:
    int* array; // 配列を指すポインタ
    size_t size; // 配列のサイズ
public:
    DynamicArray(size_t n) : size(n), array(nullptr) {
        // コンストラクタで配列を動的に確保
    }
};

DynamicArray::DynamicArray(size_t n) : size(n), array(nullptr) {
    array = new int[size]; // 配列を動的に確保
    for (size_t i = 0; i < size; ++i) {
        array[i] = 0; // 初期化
    }
}

DynamicArray::~DynamicArray() {
    delete[] array; // 配列のメモリを解放
}

DynamicArray::DynamicArray(const DynamicArray& other) : size(other.size), array(nullptr) {
    array = new int[size];
    for (size_t i = 0; i < size; ++i) {
        array[i] = other.array[i];
    }
}
DynamicArray& DynamicArray::operator=(const DynamicArray& other) {
    if (this != &other) {
        delete[] array; // 既存のメモリを解放
        size = other.size;
        array = new int[size];
        for (size_t i = 0; i < size; ++i) {
            array[i] = other.array[i];
        }
    }
    return *this;
}

void DynamicArray::resize(size_t newSize) {
    int* newArray = new int[newSize]; // 新しい配列を確保
    size_t minSize = (newSize < size) ? newSize : size;
    for (size_t i = 0; i < minSize; ++i) {
        newArray[i] = array[i]; // データをコピー
    }
    delete[] array; // 古い配列を解放
    array = newArray; // 新しい配列を指す
    size = newSize; // 新しいサイズを設定
}

#include <memory>
#include <iostream>
class UniqueArray {
private:
    std::unique_ptr<int[]> array; // unique_ptrを使用して配列を管理
    size_t size;
public:
    UniqueArray(size_t n) : size(n), array(std::make_unique<int[]>(n)) {
        for (size_t i = 0; i < size; ++i) {
            array[i] = 0; // 初期化
        }
    }
    void print() const {
        for (size_t i = 0; i < size; ++i) {
            std::cout << array[i] << " ";
        }
        std::cout << std::endl;
    }
};

#include <memory>
#include <iostream>
class SharedArray {
private:
    std::shared_ptr<int[]> array; // shared_ptrを使用して配列を管理
    size_t size;
public:
    SharedArray(size_t n) : size(n), array(std::shared_ptr<int[]>(new int[n], std::default_delete<int[]>())) {
        for (size_t i = 0; i < size; ++i) {
            array[i] = 0; // 初期化
        }
    }
    void print() const {
        for (size_t i = 0; i < size; ++i) {
            std::cout << array[i] << " ";
        }
        std::cout << std::endl;
    }
};

#include <iostream>
#include <memory>
class DynamicList {
private:
    std::unique_ptr<int[]> array;
    size_t size;
    size_t capacity;
    void resize(size_t newCapacity) {
        std::unique_ptr<int[]> newArray = std::make_unique<int[]>(newCapacity);
        for (size_t i = 0; i < size; ++i) {
            newArray[i] = array[i];
        }
        array = std::move(newArray);
        capacity = newCapacity;
    }
public:
    DynamicList() : size(0), capacity(1), array(std::make_unique<int[]>(1)) {}
    void add(int value) {
        if (size == capacity) {
            resize(capacity * 2);
        }
        array[size++] = value;
    }
    void print() const {
        for (size_t i = 0; i < size; ++i) {
            std::cout << array[i] << " ";
        }
        std::cout << std::endl;
    }
};
int main() {
    DynamicList list;
    list.add(1);
    list.add(2);
    list.add(3);
    list.print(); // 出力: 1 2 3
    return 0;
}

#include <iostream>
#include <memory>
class DynamicStack {
private:
    std::unique_ptr<int[]> array;
    size_t size;
    size_t capacity;
    void resize(size_t newCapacity) {
        std::unique_ptr<int[]> newArray = std::make_unique<int[]>(newCapacity);
        for (size_t i = 0; i < size; ++i) {
            newArray[i] = array[i];
        }
        array = std::move(newArray);
        capacity = newCapacity;
    }
public:
    DynamicStack() : size(0), capacity(1), array(std::make_unique<int[]>(1)) {}
    void push(int value) {
        if (size == capacity) {
            resize(capacity * 2);
        }
        array[size++] = value;
    }
    int pop() {
        if (size == 0) throw std::out_of_range("Stack is empty");
        return array[--size];
    }
    void print() const {
        for (size_t i = 0; i < size; ++i) {
            std::cout << array[i] << " ";
        }
        std::cout << std::endl;
    }
};
int main() {
    DynamicStack stack;
    stack.push(1);
    stack.push(2);
    stack.push(3);
    stack.print(); // 出力: 1 2 3
    std::cout << "Popped: " << stack.pop() << std::endl; // 出力: Popped: 3
    stack.print(); // 出力: 1 2
    return 0;
}

#include <iostream>
#include <memory>
class DynamicQueue {
private:
    std::unique_ptr<int[]> array;
    size_t front;
    size_t back;
    size_t size;
    size_t capacity;
    void resize(size_t newCapacity) {
        std::unique_ptr<int[]> newArray = std::make_unique<int[]>(newCapacity);
        for (size_t i = 0; i < size; ++i) {
            newArray[i] = array[(front + i) % capacity];
        }
        array = std::move(newArray);
        front = 0;
        back = size;
        capacity = newCapacity;
    }
public:
    DynamicQueue() : front(0), back(0), size(0), capacity(1), array(std::make_unique<int[]>(1)) {}
    void enqueue(int value) {
        if (size == capacity) {
            resize(capacity * 2);
        }
        array[back] = value;
        back = (back + 1) % capacity;
        ++size;
    }
    int dequeue() {
        if (size == 0) throw std::out_of_range("Queue is empty");
        int value = array[front];
        front = (front + 1) % capacity;
        --size;
        return value;
    }
    void print() const {
        for (size_t i = 0; i < size; ++i) {
            std::cout << array[(front + i) % capacity] << " ";
        }
        std::cout << std::endl;
    }
};
int main() {
    DynamicQueue queue;
    queue.enqueue(1);
    queue.enqueue(2);
    queue.enqueue(3);
    queue.print(); // 出力: 1 2 3
    std::cout << "Dequeued: " << queue.dequeue() << std::endl; // 出力: Dequeued: 1
    queue.print(); // 出力: 2 3
    return 0;
}