C++ Vector 类实现：包含基本功能和示例代码

本文将介绍 C++ 中 Vector 类的实现，涵盖了构造函数、析构函数、复制构造函数以及常见的操作方法，并提供了示例代码演示其使用方法。

1. 基本功能

以下列出了 Vector 类需要实现的功能：

• 构造函数：用于创建新的 Vector 对象。
• 析构函数：用于释放 Vector 对象占用的内存。
• 复制构造函数：用于创建现有 Vector 对象的副本。
• capacity()：返回 Vector 当前存储单元数。
• size()：返回当前存储在 Vector 中值的个数。
• empty()：当且仅当 Vector 中不包含值时返回 true。
• reserve()：增大 Vector 的容量，使之至少能够存储 n 个元素。
• push_back(value)：将 value 添加到 Vector 的尾部。
• pop_back()：删除 Vector 的最后一个元素。
• front()：返回指向 Vector 的第一个元素的引用。
• back()：返回指向 Vector 的最后一个元素的引用。
• operator[](i)：返回 Vector 中下标为 i 的元素 - 不检查越界。
• at(i)：返回 Vector 中下标为 i 的元素 - 检查越界。
• operator=(other)：将 other 的拷贝赋予当前 Vector。
• swap(other)：交换当前 Vector 和 other 的内容。
• operator==(other)：当当前 Vector 和 other 的值相同，值的顺序相同，返回 true，否则为 false。
• operator<(other)：当且仅当当前 Vector 在字典顺序上小于 other 时，返回 true。

2. 代码示例

以下是一个简单实现上述功能的 Vector 类的示例代码：

#include <iostream>

template<class T>
class Vector {
private:
    T* data;           // 存储元素的数组指针
    size_t capacity;   // 存储单元的容量
    size_t length;     // 实际存储的元素个数

public:
    Vector() : data(nullptr), capacity(0), length(0) {}
    
    Vector(size_t n) : data(new T[n]), capacity(n), length(0) {}
    
    ~Vector() {
        delete[] data;
    }
    
    Vector(const Vector& other) : data(new T[other.capacity]), capacity(other.capacity), length(other.length) {
        for (size_t i = 0; i < length; i++) {
            data[i] = other.data[i];
        }
    }
    
    size_t size() const {
        return length;
    }
    
    bool empty() const {
        return length == 0;
    }
    
    size_t capacity() const {
        return capacity;
    }
    
    void reserve(size_t n) {
        if (n > capacity) {
            T* newData = new T[n];
            for (size_t i = 0; i < length; i++) {
                newData[i] = data[i];
            }
            delete[] data;
            data = newData;
            capacity = n;
        }
    }
    
    void push_back(const T& value) {
        if (length >= capacity) {
            reserve(capacity == 0 ? 1 : capacity * 2);
        }
        data[length++] = value;
    }
    
    void pop_back() {
        if (length > 0) {
            --length;
        }
    }
    
    T& front() const {
        return data[0];
    }
    
    T& back() const {
        return data[length - 1];
    }
    
    T& operator[](size_t index) const {
        return data[index];
    }
    
    T& at(size_t index) const {
        if (index >= length) {
            throw std::out_of_range('Index out of range');
        }
        return data[index];
    }
    
    Vector& operator=(const Vector& other) {
        if (this != &other) {
            delete[] data;
            data = new T[other.capacity];
            capacity = other.capacity;
            length = other.length;
            for (size_t i = 0; i < length; i++) {
                data[i] = other.data[i];
            }
        }
        return *this;
    }
    
    void swap(Vector& other) {
        std::swap(data, other.data);
        std::swap(capacity, other.capacity);
        std::swap(length, other.length);
    }
    
    bool operator==(const Vector& other) const {
        if (length != other.length) {
            return false;
        }
        for (size_t i = 0; i < length; i++) {
            if (data[i] != other.data[i]) {
                return false;
            }
        }
        return true;
    }
    
    bool operator<(const Vector& other) const {
        size_t minLen = std::min(length, other.length);
        for (size_t i = 0; i < minLen; i++) {
            if (data[i] < other.data[i]) {
                return true;
            }
            if (data[i] > other.data[i]) {
                return false;
            }
        }
        return length < other.length;
    }
};

int main() {
    Vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    
    std::cout << 'Vector size: ' << v.size() << std::endl;
    std::cout << 'Vector capacity: ' << v.capacity() << std::endl;
    std::cout << 'Vector front: ' << v.front() << std::endl;
    std::cout << 'Vector back: ' << v.back() << std::endl;
    std::cout << 'Vector[1]: ' << v[1] << std::endl;
    
    v.pop_back();
    std::cout << 'After pop_back, Vector size: ' << v.size() << std::endl;
    
    Vector<int> v2 = v;
    std::cout << 'Copied Vector size: ' << v2.size() << std::endl;
    
    v2.push_back(4);
    std::cout << 'After push_back, Vector2 size: ' << v2.size() << std::endl;
    std::cout << 'Vector1 == Vector2: ' << (v == v2) << std::endl;
    std::cout << 'Vector1 < Vector2: ' << (v < v2) << std::endl;
    
    return 0;
}

3. 注意事项

请注意以上代码只是一个简单的示例，可能还需要根据具体的需求进行修改和完善。此示例仅包括了所需的基本功能，并不是一个完整的、生产级别的 Vector 类实现。

例如，在实际应用中，你可能需要考虑以下问题：

• 异常处理：在 at() 等方法中，需要对索引越界进行更加完善的处理，例如抛出异常。
• 内存管理：需要考虑内存分配和释放的效率，避免内存泄漏。
• 迭代器：需要实现迭代器，方便对 Vector 中的元素进行遍历。
• 其他操作：可以根据需求添加其他操作方法，例如 insert()、erase() 等。

通过学习和理解本示例代码，你可以更好地理解 Vector 类的实现原理，并根据自己的需求进行扩展和优化。