本文共 3554 字，大约阅读时间需要 11 分钟。

模拟实现前须知知识点

1.1普通类和模板类的良好编写习惯

在编写类时，模板类和普通类的处理方式有所不同。模板类要求声明和定义必须放在同一文件中，通常将.h文件改名为.hpp以表明使用模板。普通类则建议将声明和定义分离，便于看到类的整体框架，内部可以适当放置内联函数。

1.2vector中的参数含义

vector类是一个容器类，主要用于动态数组管理。其参数主要包括构造函数的输入迭代符、模板函数的输入迭代符以及交换函数的参数。

1.3空间的开辟注意事项

在开辟空间时，需要注意以下几点：

1.4巧妙利用作用域，调用析构函数

通过在{和}作用域中使用new和delete，可以确保资源的自动释放。这对管理动态内存尤为重要。

1.5迭代器失效场景

迭代器在以下场景下可能失效：

• 迭代器指向的元素已被删除或修改。
• 迭代器操作涉及改变向量的大小或内容。

实现过程

模拟实现vector类时，需覆盖以下功能：

在实现过程中，应注重以下几点：

• 尽量使用const和引用，减少拷贝开销。
• 保持代码简洁，避免不必要的复杂性。
• 处理异常情况，如空迭代器访问等。

代码

#pragma once
#include 
   
    
#include 
    
     
#include 
     
      
#include 
      
       
using namespace std;
namespace mv {
    template
       
        
    class vector {
    public:
        typedef T* iterator;
        typedef const T* const_iterator;
        iterator begin() { return _start; }
        iterator end() { return _finish; }
        const_iterator begin() const { return _start; }
        const_iterator end() const { return _finish; }
        
        vector() : _start(nullptr), _finish(nullptr), _end_of_storge(nullptr) {}
        
        template
        
          vector(InputIterator first, InputIterator last) : _start(nullptr), _finish(nullptr), _end_of_storge(nullptr) { reserve(last - first); while (first != last) { push_back(*first); first++; } } void swap(vector
         
          & x) { std::swap(_start, x._start); std::swap(_finish, x._finish); std::swap(_end_of_storge, x._end_of_storge); } vector(const vector
          
           & x) : _start(nullptr), _finish(nullptr), _end_of_storge(nullptr) { vector
           
             temp(x.begin(), x.end()); swap(temp); } vector
            
             & operator=(const vector
             
              & x) { swap(x); return *this; } T& operator[](size_t index) { assert(index < size()); return _start[index]; } const T& operator[](size_t index) const { assert(index < size()); return *_start[index]; } ~vector() { delete[] _start; _start = _finish = nullptr; } size_t size() const { return size_t(_start - _finish); } size_t capacity() const { return size_t(_end_of_storge - _start); } void reserve(size_t n) { if (n > capacity()) { iterator temp = new T[n]; size_t old_size = size(); iterator begin_temp = _start; iterator end_temp = _finish; while (begin_temp != end_temp) { *begin_temp = *temp; begin_temp++; temp++; } delete[] _start; _start = temp; _finish = _start + old_size; _end_of_storge = _start + n; } } void push_back(const T& x) { check_capacity(); *_finish = x; _finish++; } void pop_back() { assert(_finish > _start); _finish--; } void resize(size_t newsize, const T& x=T()) { if (newsize > capacity()) { reserve(newsize); } if (newsize < size()) { while (_finish != _start + newsize) { *_finish = x; _finish++; } } } iterator insert(iterator pos, const T& x) { assert(pos >= _start && pos < _finish); size_t inpos = pos - _start; check_capacity(); pos = _start + inpos; while (_finish != pos) { *pos = *(pos - 1); pos--; } *pos = x; _finish++; return pos; } void erase(iterator pos) { assert(pos >= _start && pos < _finish); iterator temp_pos = pos; while (pos != _finish) { *pos = *(pos + 1); pos++; } _finish--; return temp_pos; } void Print() { iterator start = _start; while (start != _finish) { cout << *start << " "; start++; } cout << endl; } private: iterator _start; iterator _finish; iterator _end_of_storge; }; }
             
            
           
          
         
        
       
      
     
    
   

总结

通过以上实现过程，可以理解vector类的核心机制。模拟实现vector类需要对内存管理、迭代器操作和容量策略有深刻的理解。实际编码中，应注重代码简洁性和效率，同时注意资源的释放和异常处理。