手写vector c++

手写vector c可以按照以下步骤进行：
1. 创建一个类模板，取名为Vector，其中包含私有成员变量capacity（容量）、size（大小）和指向存储元素的指针arr。
2. 在构造函数中，初始化capacity和size为0，并为arr分配一块大小为0的内存。
3. 实现析构函数，释放arr指向的内存。
4. 实现成员函数capacity()，返回当前容量。
5. 实现成员函数size()，返回当前大小。
6. 实现成员函数empty()，判断容器是否为空。
7. 实现成员函数push_back()，将元素添加到容器的末尾。如果当前大小等于容量，需要进行扩容操作。
8. 实现成员函数pop_back()，删除容器的最后一个元素。
9. 实现成员函数swap()，交换两个容器的内容。
10. 实现成员函数clear()，清空容器中的所有元素。
11. 实现成员函数erase()，删除容器中指定位置的元素。
12. 重载赋值运算符=，以实现深拷贝。
请注意，这只是一个简易版的vector，具体实现可能会有所不同。

相关问题

手写vector容器c++

手写Vector容器的实现主要包括以下几个步骤：

1. 定义Vector类，包括私有成员变量arr（存储元素的数组）、capacity（数组容量）、size（元素个数）。
2. 实现Vector类的构造函数，用于初始化成员变量。
3. 实现Vector类的析构函数，释放动态分配的内存。
4. 实现Vector类的深拷贝构造函数，用于进行深拷贝。
5. 实现Vector类的赋值运算符重载，用于进行深拷贝和防止浅拷贝问题。
6. 实现Vector类的尾部插入方法，将元素插入到数组的末尾。
7. 实现Vector类的尾部删除方法，从数组的末尾删除一个元素。

下面是一个手写Vector容器的示例代码：

template<typename T>
class Vector {
private:
    T* arr;
    int capacity;
    int size;
public:
    Vector() {
        capacity = 10;
        size = 0;
        arr = new T[capacity];
    }
    
    ~Vector() {
        delete []arr;
    }
    
    Vector(const Vector& p) {
        capacity = p.capacity;
        size = p.size;
        arr = new T[capacity];
        for (int i = 0; i < size; i++) {
            arr[i] = p.arr[i];
        }
    }
    
    Vector& operator=(const Vector& p) {
        if (this == &p) {
            return *this;
        }
        delete []arr;
        capacity = p.capacity;
        size = p.size;
        arr = new T[capacity];
        for (int i = 0; i < size; i++) {
            arr[i] = p.arr[i];
        }
        return *this;
    }
    
    void insert(const T& value) {
        if (size == capacity) {
            return;
        }
        arr[size] = value;
        size++;
    }
    
    void remove() {
        if (size == 0) {
            return;
        }
        size--;
    }
};

c++手写vector

好的，这是手写 vector 的代码示例：

#include <iostream>
#include <memory>

template <typename T>
class MyVector {
public:
    MyVector() : size_(0), capacity_(8) {
        data_ = std::make_unique<T[]>(capacity_);
    }

    ~MyVector() {
        clear();
    }

    void push_back(const T& value) {
        if (size_ == capacity_) {
            reserve(capacity_ * 2);
        }
        data_[size_++] = value;
    }

    void pop_back() {
        if (size_ > 0) {
            --size_;
        }
    }

    void clear() {
        size_ = 0;
        capacity_ = 8;
        data_.reset(new T[capacity_]);
    }

    void reserve(int new_capacity) {
        if (new_capacity <= capacity_) {
            return;
        }
        std::unique_ptr<T[]> new_data = std::make_unique<T[]>(new_capacity);
        for (int i = 0; i < size_; ++i) {
            new_data[i] = data_[i];
        }
        data_ = std::move(new_data);
        capacity_ = new_capacity;
    }

    T& operator[](int index) {
        return data_[index];
    }

    const T& operator[](int index) const {
        return data_[index];
    }

    int size() const {
        return size_;
    }

    int capacity() const {
        return capacity_;
    }

private:
    int size_;
    int capacity_;
    std::unique_ptr<T[]> data_;
};

int main() {
    MyVector<int> vec;
    for (int i = 0; i < 10; ++i) {
        vec.push_back(i);
    }
    for (int i = 0; i < vec.size(); ++i) {
        std::cout << vec[i] << " ";
    }
    std::cout << std::endl;
    vec.pop_back();
    for (int i = 0; i < vec.size(); ++i) {
        std::cout << vec[i] << " ";
    }
    std::cout << std::endl;
    vec.clear();
    for (int i = 0; i < 10; ++i) {
        vec.push_back(i);
    }
    vec.reserve(20);
    for (int i = 0; i < vec.size(); ++i) {
        std::cout << vec[i] << " ";
    }
    std::cout << std::endl;
    return 0;
}