vector容器初始化 new

vector容器的初始化有以下几种方法：

1. 使用默认构造函数初始化一个空的vector：

std::vector<int> vec;

2. 使用元素数量和初始值来初始化vector：

std::vector<int> vec(5, 0); // 初始化一个包含5个值为0的元素的vector

3. 使用另一个vector来初始化新的vector：

std::vector<int> originalVec{1, 2, 3, 4, 5};
std::vector<int> vec(originalVec); // 使用originalVec初始化vec

4. 使用迭代器范围来初始化vector：

std::vector<int> originalVec{1, 2, 3, 4, 5};
std::vector<int> vec(originalVec.begin(), originalVec.end()); // 使用originalVec的迭代器范围初始化vec

5. 使用初始化列表来初始化vector（C++11及以后版本可用）：

std::vector<int> vec{1, 2, 3, 4, 5}; // 使用初始化列表初始化vec

这些是常见的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 容器的实现，使用了 C++11 的新特性，包括模板、可变参数模板、移动语义、右值引用、初始化列表等：

#include <iostream>
#include <initializer_list>

template <typename T>
class Vector {
public:
    // 默认构造函数
    Vector() : m_data(nullptr), m_size(0), m_capacity(0) {}
    
    // 带参构造函数
    Vector(std::initializer_list<T> list) : m_size(list.size()), m_capacity(list.size()) {
        m_data = new T[m_capacity];
        for (size_t i = 0; i < m_size; ++i) {
            m_data[i] = *(list.begin() + i);
        }
    }
    
    // 复制构造函数
    Vector(const Vector& other) : m_size(other.m_size), m_capacity(other.m_capacity) {
        m_data = new T[m_capacity];
        for (size_t i = 0; i < m_size; ++i) {
            m_data[i] = other.m_data[i];
        }
    }
    
    // 移动构造函数
    Vector(Vector&& other) : m_data(other.m_data), m_size(other.m_size), m_capacity(other.m_capacity) {
        other.m_data = nullptr;
        other.m_size = 0;
        other.m_capacity = 0;
    }
    
    // 析构函数
    ~Vector() {
        if (m_data != nullptr) {
            delete[] m_data;
        }
    }
    
    // 复制赋值运算符
    Vector& operator=(const Vector& other) {
        if (this != &other) {
            m_size = other.m_size;
            m_capacity = other.m_capacity;
            delete[] m_data;
            m_data = new T[m_capacity];
            for (size_t i = 0; i < m_size; ++i) {
                m_data[i] = other.m_data[i];
            }
        }
        return *this;
    }
    
    // 移动赋值运算符
    Vector& operator=(Vector&& other) {
        if (this != &other) {
            m_data = other.m_data;
            m_size = other.m_size;
            m_capacity = other.m_capacity;
            other.m_data = nullptr;
            other.m_size = 0;
            other.m_capacity = 0;
        }
        return *this;
    }
    
    // 获取元素个数
    size_t size() const {
        return m_size;
    }
    
    // 在末尾添加元素
    void push_back(const T& value) {
        if (m_size >= m_capacity) {
            reserve(m_capacity == 0 ? 1 : m_capacity * 2);
        }
        m_data[m_size++] = value;
    }
    
    // 在末尾添加元素（右值引用版本）
    void push_back(T&& value) {
        if (m_size >= m_capacity) {
            reserve(m_capacity == 0 ? 1 : m_capacity * 2);
        }
        m_data[m_size++] = std::move(value);
    }
    
    // 获取元素
    const T& operator[](size_t index) const {
        return m_data[index];
    }
    
    // 获取元素（非 const 版本）
    T& operator[](size_t index) {
        return m_data[index];
    }
    
    // 清空容器
    void clear() {
        m_size = 0;
    }
    
    // 重置容器大小
    void resize(size_t size) {
        if (size > m_capacity) {
            reserve(size);
        }
        m_size = size;
    }
    
    // 重置容器大小，并用指定值填充
    void resize(size_t size, const T& value) {
        if (size > m_capacity) {
            reserve(size);
        }
        for (size_t i = m_size; i < size; ++i) {
            m_data[i] = value;
        }
        m_size = size;
    }
    
    // 保留容器空间
    void reserve(size_t capacity) {
        if (capacity > m_capacity) {
            T* new_data = new T[capacity];
            for (size_t i = 0; i < m_size; ++i) {
                new_data[i] = std::move(m_data[i]);
            }
            delete[] m_data;
            m_data = new_data;
            m_capacity = capacity;
        }
    }
    
private:
    T* m_data;
    size_t m_size;
    size_t m_capacity;
};

int main() {
    Vector<int> vec {1, 2, 3};
    vec.push_back(4);
    std::cout << "vec.size() = " << vec.size() << std::endl;
    std::cout << "vec[0] = " << vec[0] << std::endl;
    std::cout << "vec[1] = " << vec[1] << std::endl;
    std::cout << "vec[2] = " << vec[2] << std::endl;
    std::cout << "vec[3] = " << vec[3] << std::endl;
    return 0;
}

这个实现中，我们使用了初始化列表来方便地初始化 vector 容器中的元素，使用了可变参数模板来支持传递任意数量的参数，使用了移动语义和右值引用来提高效率，使用了初始化列表来初始化容器中的元素，使用了模板来实现通用性。同时，我们还实现了复制构造函数、移动构造函数、复制赋值运算符、移动赋值运算符等函数，保证了 vector 容器的正确性和效率。