【C++】vector模拟实现+迭代器失效

慈云数据 2024-03-15 技术支持 60 0

vector模拟实现

  • 成员变量定义
  • 默认成员函数
    • 构造函数
    • 迭代器
      • 范围for、对象类型匹配原则
      • 容量操作
        • size
        • empty
        • capacity
        • reserve
          • 成员变量未更新
          • memcpy值拷贝
          • resize
            • 内置类型的构造函数
            • 数据访问
              • front
              • back
              • operator[ ]
              • 数据修改操作
                • push_back
                • pop_back
                • swap
                • clear
                • insert
                  • pos位置未更新
                  • 返回
                  • erase
                    • 无返回值
                    • 迭代器失效
                      • 定义
                      • insert导致的迭代器失效
                      • erase导致的迭代器失效
                        • 删除vector中的奇数
                        • 非法的间接寻址

                          铁汁们,今天给大家分享一篇vector模拟实现 + 迭代器失效,来吧,开造⛳️

                          成员变量定义

                          • 指向最后一个空间的下一个位置

                            💡 iterator _endofstorage

                            • 指向存储第一个有效数据空间的位置

                              💡 iterator _start

                              • 指向存储最后一个有效数据空间的下一个位置

                                💡 iterator _finish

                                在这里插入图片描述

                                • 在成员变量声明处给缺省值,实质上是将缺省值给了初始化列表。
                                • 在创建一个新的对象时,都需要先走初始化列表完成初始化,在走构造函数。
                                  #define _CRT_SECURE_NO_WARNINGS 1
                                  #include
                                  #include
                                  #include
                                  using namespace std;
                                  template
                                  class vector {
                                  private:
                                  	iterator _start = nullptr; //起始位置
                                  	iterator _finish = nullptr;  //有效数据的结束位置
                                  	iterator _endofstorage = nullptr;  //容量的结束位置
                                  };
                                  

                                  默认成员函数

                                  构造函数

                                  💡vector( ) { } ;

                                  • 功能:构造无参的对象
                                    vector() {};  //无参构造
                                    

                                    💡vector(size_t n, const T& val = T( ) ) ;

                                    • 功能:构造含n个val值的对象
                                      vector(size_t n, const T& val = T()) //用n个val值构造
                                      {
                                      	resize(n, val);
                                      }
                                      

                                      💡vector( InputIterator first, InputIterator last ) ;

                                      • 功能:构造与[first, last)范围一样多元素的对象
                                        template  //  注意: 模板内可以在嵌套模板
                                        vector(InputIterator first, InputIterator last)    //用迭代区间进行构造
                                        {     //泛型编程,函数模板,不是只适用于某个容器的的迭代器,适用于所有容器的的迭代器
                                        	while (first != last)
                                        	{
                                        		push_back(*first);
                                        		first++;
                                        	}
                                        }
                                        

                                        💡Tips:模板内可以嵌套其他模板。

                                        迭代器

                                        template
                                        class vector {
                                        public:
                                        	typedef T* iterator;
                                        	typedef const T* const_iterator;
                                        }
                                        

                                        💡 Tips:指向连续物理空间的指针是天然的迭代器。

                                        💡iterator begin( ) ;

                                        • 功能:返回指向第一个元素的位置。
                                          iterator begin() //迭代器所指向的空间内的值 “既可读又可写”
                                          {   //只适用于const对象(权限可以平移)、不适用于非const对象(权限不可以放大)
                                          	return _start;  //vector第一个元素所在的位置(指针)
                                          }
                                          

                                          💡Tips : const_iterator 修饰的是迭代器所指向的元素不能被修改,而迭代器本身可以被修改。const修饰this指针,表示在该成员函数中成员变量不允许被修改,此处const的用法只能用于类中的成员函数。

                                          💡iterator end( ) ;

                                          • 功能:返回指向最后一个元素的下一个位置。
                                            iterator end()
                                            {
                                            	return _finish; //vector最后一个元素后面所在的位置(指针)
                                            }
                                            

                                            💡const_iterator begin( )const ;

                                            const_iterator begin()const //迭代器所指向的空间内的值 “只可不可写”
                                            {
                                            	return _start;  //既适用于const对象(权限可以平移)、又适用于非const对象(权限可以缩小)
                                            }
                                            

                                            💡const_iterator end( )const ;

                                            const_iterator end()const
                                            {
                                            	return _finish;
                                            }
                                            

                                            范围for、对象类型匹配原则

                                            const vector v(5, 2);
                                            for (auto& e : v)
                                            {
                                            	cout 
                                            	return _finish - _start;
                                            }
                                            
                                            	return size() == 0;
                                            }
                                            vector
                                            	return _endofstorage - _start;
                                            }
                                            
                                            	if (n  capacity()) //此处在判断:1.自己直接调用reserve,2.其他接口间接调用reserve
                                            	{
                                            		T* tmp = new T[n];  //扩容  new:开空间+构造函数,完成初始化
                                            		size_t old = size();  // 注意 :因为new[]会开辟新的空间
                                            		if (_start)  //拷贝旧空间中的值
                                            		{
                                            			for (int i = 0; i 
微信扫一扫加客服

微信扫一扫加客服

点击启动AI问答
Draggable Icon