STL之vector

于 2024-10-03 10:53:50 发布
阅读量776 收藏 26
点赞数 33
文章标签： c++ java android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_87257864/article/details/142688881
版权

vector的学习


学习完string后vector与list就能很快上手，它们的接口大致相同，string还要更复杂一些。

（一）vector的接口了解

（1）简单了解

简单的来说vector就是一个顺序表，但由于模版的特性，他会生成存储不同类型数据的顺序表，并且库里实现是使用三个指针来操作的，下面我们也会跟着库里来实现。

（2）查文档

在这里插入图片描述
首先list与vector是在容器的这一块里面，它可以储存各种数据。
在这里插入图片描述

void test1()
{
	vector<int> v1(10, 1);
	for (auto e : v1)
	{
		cout << e << ' ';
	}
	//һ˳
	cout << endl;
	vector<int>::iterator it = v1.begin();
	while (it != v1.end())
	{
		cout << *it << ' ';
		it++;
	}
	cout << endl;
	cout << v1.size() << endl;
	cout << v1.capacity() << endl;

	vector<int> v2(v1);
	for (auto e : v2)
	{
		cout << e << ' ';
	}
}//vector

库里的使用：
在这里插入图片描述
下面的数组也是支持初始化的，这里需要注意一下。

（3）常用插入、删除接口

在这里插入图片描述
这一块跟string是一摸一样的，我们就简单的调过了，但这只是我跳过了，大家下来还是需要去熟悉下这些接口的。

（4）reserve与resize

在这里插入图片描述
在这里插入图片描述
1、简单的来说reserve就是提前开好空间，因为我们在使用vector时不免会频繁扩容，如果我们知道需要多少空间的话我们可以提前开好，减少扩容的消耗，根据文档我们也知道，如果我们申请的空间小于我们原来的空间它不会缩容。

2、reszie是我们不光可以开空间，还可以初始化，这里需要注意的是：
假如我们输入的空间为n，这里有三种情况：
1、n小于size，这里是会将我们的数据清除，只剩下n个，但是容量是坚决不缩。
2、n>size&&n<capacity，这里resize会将size后面size-n个初始化，容量是坚决不缩。
3、n>capacity，这里则会扩容加初始化。

void test2()
{
	vector<int> v1(10, 1);
	cout << v1.size() << ':' << v1.capacity() << endl;
	v1.resize(20, 1);
	cout << v1.size() << ':' << v1.capacity() << endl;
	for (auto& e: v1)
	{
		cout << e << ' ';
	}
	cout << endl;
	v1.resize(15);
	cout << v1.size() << ':' << v1.capacity() << endl;
	for (auto& e : v1)
	{
		cout << e << ' ';
	}
	cout << endl;

	v1.reserve(100);
	cout << v1.size() << ':' << v1.capacity() << endl;
}//resizereserve

这是我自己的测试。

（5）operator[]

在这里插入图片描述
这一块简单的来说就是支持我们像数组一样用[]访问，第一个版本支持我们修改。
我们再结合vector是存储数据的容器，它也是可以存储自定义类型的，那假如我们再存一个vector，就可以实现类似于二维数组一样的结构。

void test3()
{
	vector<int> v1(10, 4);
	for (int i = 0; i < v1.size() - 1; i++)
	{
		cout << v1[i] << ' ';
	}
	vector<int> v(5, 1);
	vector<vector<int> > vv(10, v);
	for (int i = 0; i < vv.size(); i++)
	{
		for (int j = 0; j < v.size(); j++)
		{
			cout << vv[i][j] << ' ';
		}
		cout << endl;
	}
}//[]

这里表示的就是一个10行5列且元素全为1的矩阵了。

其他的接口我就不多说了，大家看看文档就好。

（二）vector常用接口的实现

（1）stl30、vector源码（部分）

template <class T, class Alloc = alloc>
class vector {
public:
  typedef T value_type;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type* iterator;
  typedef const value_type* const_iterator;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;

#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
  typedef reverse_iterator<const_iterator> const_reverse_iterator;
  typedef reverse_iterator<iterator> reverse_iterator;
#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  typedef reverse_iterator<const_iterator, value_type, const_reference, 
                           difference_type>  const_reverse_iterator;
  typedef reverse_iterator<iterator, value_type, reference, difference_type>
          reverse_iterator;
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
protected:
  typedef simple_alloc<value_type, Alloc> data_allocator;
  iterator start;
  iterator finish;
  iterator end_of_storage;
  void insert_aux(iterator position, const T& x);
  void deallocate() {
    if (start) data_allocator::deallocate(start, end_of_storage - start);
  }

  void fill_initialize(size_type n, const T& value) {
    start = allocate_and_fill(n, value);
    finish = start + n;
    end_of_storage = finish;
  }
public:
  iterator begin() { return start; }
  const_iterator begin() const { return start; }
  iterator end() { return finish; }
  const_iterator end() const { return finish; }
  reverse_iterator rbegin() { return reverse_iterator(end()); }
  const_reverse_iterator rbegin() const { 
    return const_reverse_iterator(end()); 
  }
  reverse_iterator rend() { return reverse_iterator(begin()); }
  const_reverse_iterator rend() const { 
    return const_reverse_iterator(begin()); 
  }
  size_type size() const { return size_type(end() - begin()); }
  size_type max_size() const { return size_type(-1) / sizeof(T); }
  size_type capacity() const { return size_type(end_of_storage - begin()); }
  bool empty() const { return begin() == end(); }
  reference operator[](size_type n) { return *(begin() + n); }
  const_reference operator[](size_type n) const { return *(begin() + n); }

  vector() : start(0), finish(0), end_of_storage(0) {}
  vector(size_type n, const T& value) { fill_initialize(n, value); }
  vector(int n, const T& value) { fill_initialize(n, value); }
  vector(long n, const T& value) { fill_initialize(n, value); }
  explicit vector(size_type n) { fill_initialize(n, T()); }

  vector(const vector<T, Alloc>& x) {
    start = allocate_and_copy(x.end() - x.begin(), x.begin(), x.end());
    finish = start + (x.end() - x.begin());
    end_of_storage = finish;
  }
#ifdef __STL_MEMBER_TEMPLATES

这里只是给大家看一下产品级的代码长啥样，我们的水平还是不足的，当然我们也可以从中学到一部分对吧。

在这里插入图片描述
在这一部分中我们可以看到，库里是用三个指针来操作我们的顺序表，start、finish、end_of_storage。size就是finish-start,capacity就是end_of_storage-finish。

(2)实现

.h

#include<iostream>
#include<assert.h>
#include<stdbool.h>
using namespace std;

namespace TSY
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		size_t size()
		{
			return _finsh - _start;
		}
		size_t capacity()
		{
			return _end_of_storage - _start;
		}
		size_t size()const
		{
			return _finsh - _start;
		}
		size_t capacity()const
		{
			return _end_of_storage - _start;
		}
		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t oldsize = size();
				T* tmp = new T[n];
				memcpy(tmp, _start, sizeof(T) * oldsize);
				delete[] _start;

				_start = tmp;
				_finsh = _start + oldsize;
				_end_of_storage = _start + n;
			}
		}
		void push_back(const T& x)
		{
			if (_finsh == _end_of_storage)
			{
				reserve(capacity() == 0 ? 4 : 2 * capacity());
			}
			*_finsh = x;
			_finsh++;
		}
		T& operator[](size_t n)
		{
			return *(_start + n);
		}
		const T& operator[](size_t n)const
		{
			return *(_start + n);
		}
		iterator begin()
		{
			return _start;
		}
		iterator end()
		{
			return _finsh;
		}
		const iterator begin()const
		{
			return _start;
		}
		const iterator end()const
		{
			return _finsh;
		}
		void pop_back()
		{
			_finsh--;
		}
		iterator insert(iterator pos, const T& x)
		{
			assert(pos >= _start);
			assert(pos <= _finsh);
			if (_finsh == _end_of_storage)
			{
				size_t k = pos - _start;
				reserve(capacity() == 0 ? 4 : 2 * capacity());
				pos = _start + k;
			}
			iterator end = _finsh - 1;
			while (end >= pos)//
			{
				*(end + 1) = *end;
				end--;
			}
			*pos = x;
			_finsh++;
			return pos;
		}
		bool empty()
		{
			return _finsh == _start;
		}
		void resize(size_t n, T val = T())//n<size/  n>size&&n<capacity  n>capacity
		{
			if (n < size())
			{
				_finsh = _start + n;
			}
			else
			{
				reserve(n);
				while (n > size())
				{
					*_finsh = val;
					_finsh++;
				}
			}
		}
		void erase(iterator pos)
		{
			assert(pos >= _start);
			assert(pos < _finsh);
			iterator cur = pos+1；
			while (cur != end())
			{
				*(cur - 1) = *cur;
				cur++;
			}
			--_finsh;
		}
		vector(){}
		vector(const vector<T>& v)
		{
			reserve(v.size());
			for (auto e : v)
			{
				push_back(e);
			}
		}
		void swap(vector<T> v)
		{
			std::swap(_start, v._start);
			std::swap(_finsh, v._finsh);
			std::swap(_end_of_storage, v._end_of_storage);
		}
		vector<T> operator=(vector<T> v)
		{
			//clear();
			swap(v);
			return *this;
		}
		void clear()
		{
			_finsh = _start;
		}
		vector(size_t n, const T& val = T())
		{
			reserve(n);
			while (n--)
			{
				push_back(val);
			}
		}
		vector(int n, const T& val = T())
		{
			reserve(n);
			while (n--)
			{
				push_back(val);
			}
		}
		~vector()
		{
			if (_start)
			{
				delete[] _start;
				_start = _finsh = _end_of_storage = nullptr;
			}
		}
	private:
		iterator _start = nullptr;
		iterator _finsh = nullptr;
		iterator _end_of_storage = nullptr;
	};
	template<class T>
	void print_vector(const vector<T>& v)
	{
		auto it = v.begin();
		while (it != v.end())
		{
			cout << *it <<" ";
			it++;
		}
		cout << endl;
		for (auto e : v)
		{
			cout << e << " ";
		}
		cout << endl;
	}
	void test1()
	{
		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(5);
		for (size_t i = 0; i < v.size(); i++)
		{
			cout << v[i] << ' ';
		}
		cout << endl;

		vector<int>::iterator it = v.begin();
		while (it != v.end())
		{
			cout << *it << ' ';
			it++;
		}
		cout << endl;

		for (auto& e : v)
		{
			cout << e << ' ';
		}
		cout << endl;

		vector<int>::iterator iit = v.begin();
		iit = v.insert(iit + 2, 3);
		for (auto& e : v)
		{
			cout << e << ' ';
		}
		cout << endl;
	}

	void test2()
	{
		vector<int> v;
		v.insert(v.begin(), 1);
		v.insert(v.begin(), 1);
		v.insert(v.begin(), 1);
		v.insert(v.begin(), 1);
		v.insert(v.begin(), 1);
		for (auto& e : v)
		{
			cout << e << ' ';
		}
		cout << endl;

		/*v.resize(20, 2);
		for (auto& e : v)
		{
			cout << e << ' ';
		}
		cout << endl;*/
		v.erase(v.begin());
		v.erase(v.begin());
		v.erase(v.begin());
		v.erase(v.begin());
		v.erase(v.begin());
		//v.erase(v.begin());
		for (auto& e : v)
		{
			cout << e << ' ';
		}
		cout << endl;
	}

	void test3()
	{
		vector<int> v;
		for (int i = 0; i < 5; i++)
		{
			v.push_back(i);
		}
		print_vector(v);
	}

	void test4()//캯
	{
		vector<int> v1;
		for (int i = 0; i < 10; i++)
		{
			v1.push_back(i);
		}
		print_vector(v1);
		cout << endl;


		vector<int> v2(v1);
		print_vector(v2);
		cout << endl;

		vector<int> v3 = v1;
		print_vector(v3);
	}

	void test5()
	{
		vector<int> v(10, 1);
		print_vector(v);
	}
}

.cpp

#include"vector.h"

int main()
{
	TSY::test5();
	return 0;
}

在.cpp文件调用接口即可。

（3）迭代器失效

在这里，迭代器失效我们可以理解为出现了野指针，或者指针不指向我们想要的位置，但是有些容器的迭代器并非指针，只是vector这里与string指针，下一节的list的迭代器就不是单纯的指针。

例如这一块：
在这里插入图片描述
如果我们将_start = tmp;
_finsh = _start + oldsize;
换一个顺序就会出现问题，我们先让finsh等于start+size的话，start就是野指针。

在日常使用中常见的野指针会出现在erase与insert处，例如
在这里插入图片描述

在这里插入图片描述
当我们原本想要删除4的时候，这里出现了错位，为了解决这里的问题官方给了返回值
在这里插入图片描述
这里返回下一个位置的迭代器。
在这里插入图片描述
insert同理。

（三）了解

既然我们知道string也是用顺序表存储的，那么vector里的元素类型变为char不就变成了string，官方为什么还要写一个string呢？
有没有这样想的同学，之所以会出现string有很大一部分原因是因为\0,vector是不会结尾补充\0的

小码农<^_^>
关注
C++ STL之vector详解
行码棋
01-04 7万+
本文介绍了STL的vector的常用操作以及相关的注意事项
C++——STL之vector详解
weixin_59055853的博客
12-21 1822
学习了string之后，学习其他模板将会更容易上手，一起来看一下vector吧！vector是表示大小可以变化的数组的序列容器。
【C++】-- STL之vector详解
局部变量和全局变量
05-31 2267
vecotr是可以改变大小的数组的序列容器，其特点有： （1）vector采用连续空间来存储元素，可以使用下标访问vector元素，访问元素和数组一样方便。vector大小可以动态改变，而且会被容器自动处理，这一点数组无法做到。 （2）vector使用动态分配分配数组来存储元素，插入新元素时，vector数组为了增加存储空间，会分配一个新数组，再把所有元素全部移动到这个数组里，代价相对高一些。...
STL之vector详解
Da_un的博客
10-03 1261
STL是一个很棒的东西，下面讲一讲STL容器vector的一般用法。 介绍 vector是一种动态数组，是基本数组的类模板。其内部定义了很多基本操作。 ——摘自度娘 vector之所以被称为动态数组，是因为它既可以采用下标对vector的元素进行访问，和数组一样高效。还可以对它的大小进行动态改变，并且它的大小会被容器自动处理。 定义 使用vector的标准模板，就需要在添加vector的头文件，即#include<vector>。 定义如下： v
【C++】STL之vector类源码剖析
phoenixFlyzzz的博客
04-27 2382
vector类的源码实现
C++编程语言STL之vector介绍
liitdar的博客
08-21 2707
vector是C++编程语言的STL中的内容，是同一种类型的对象的集合，每个对象都有一个对应的整数索引值，和（C++编程语言中的）string对象一样，标准库负责管理与存储元素相关的内存。有时候会把vector称为容器，是因为它可以包含其他对象，能够存放任意类型的动态数组、增加和压缩数据。一个容器中的所有对象都必须是同一种类型的。vector不是一种数据类型，而是一个类模板（class template）。使用模板可以编写一个类定义或函数定义，用于多种不同的数据类型。
STL之vector（数组）详解
qq_36721032的博客
08-26 1599
STL之vector容器详解一、什么是vector？二、容器特性2.1、顺序序列2.2、动态数组2.3、能够感知内存分配器三、基本函数实现3.1、构造函数3.2、添加元素3.3、删除元素3.4、遍历函数3.5、大小函数3.6、其他函数 一、什么是vector？ 向量（vector）是一个封装了动态大小数组的顺序容器（sequence container）。跟任意其它类型的容器一样，它能够存放任何类型的对象。可以简单地认为，vector是一个能够存放任意类型的动态数组。 二、容器特性 2.1、顺序序列 顺序容
C++ STL之vector容器
咸鱼势力登场
04-25 2741
vector容器的介绍 vector容器的使用 [1.vector的构造函数 2.vector的赋值操作 3.vector的容量与大小 4.vector的插入和删除 5.vector的数据存取 6.vector的互换容器 7.算法模块在vector的应用①find算法(std)②sort算法(std)]
STL之vector篇
关关x雎鸠的博客
08-13 3822
vector容器 动态数组 可变数组 单口容器 动态增长：插入新元素的时候，如果内存空间不足，vector会自动申请更大的空间，将原来的空间的数据拷贝到新空间，同时释放旧空间，再把新元素插入到新空间，默认申请旧空间两倍大小的新空间 vector常用API 构造函数 vector(); vector( size_type num, const TYPE &val ); ...
stl之vector带注释
07-17
SGI STL之vector源码，带注释
cpp代码-C++ STL之vector动态数组
07-16
其中，`std::vector`是STL中的一种容器，它代表了一个动态数组，允许程序员进行高效地插入、删除和访问元素。`vector`在内存管理上具有自动扩展的能力，使得开发者可以更专注于业务逻辑，而不是底层内存操作。 `std...
使用socket编程来实现一个简单的C/S模型（TCP协议）
caiji0169的博客
10-02 1025
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
【C++】红黑树的封装——同时实现map和set
Mesar的博客
09-27 651
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
求n的阶乘的相反数（c语言）
scy2429828663的博客
09-26 420
【代码】求n的阶乘的相反数（c语言）
C语言中的日志机制：打造全面强大的日志系统
极客代码
09-30 392
构建一个全面强大的日志机制对于软件开发至关重要。通过上述示例，你应该已经了解了如何在C语言中实现日志记录的不同方面。这种能力对于调试程序、监控应用程序状态和维护系统的稳定性非常有帮助。在软件开发中，良好的日志记录机制对于调试、监控程序状态和维护系统的稳定性至关重要。本文将介绍如何在C语言中构建一个全面强大的日志系统，并提供一些示例代码。实现日志文件的自动旋转，以便管理日志文件的大小。定义日志级别的宏，便于管理和调整日志输出。使用定义好的日志宏来记录日志。实现日志配置的读取和设置。1. 日志的基本概念。
【YOLOv8改进[SPPF]】使用SPPFCSPC替换SPPF模块 + 含全部代码和详细修改方式
静谧、淡雅
09-29 233
【YOLOv8改进[SPPF]】使用SPPFCSPC替换SPPF模块 + 含全部代码和详细修改方式
第 21 章 一条记录的多幅面孔——事务的隔离级别与 MVCC
最新发布
weixin_45740473的博客
10-02 580
并发的事务在运行过程中会出现一些可能的引发一致性问题SQL 标准中有4种隔离级别版本链ReadView。
AI驱动TDSQL-C Serverless数据库技术实战营--- 操作与电商可视分析
chasemydreamidea的博客
09-27 714
本文将基于腾讯云的高性能应用服务HAI和TDSQL-C MYSQL Serverless版构建AI电商数据分析系统。HAI作为一个面向AI和科学计算的GPU应用服务产品，它具有强大的计算能力，让复杂的AI模型的快速部署和运行的可行性加大，进而支持自然语言处理和图形生成等高级任务。TDSQL-C MYSQL版是一款云原生关系型数据库，其100%的MySQL兼容性，以及极致的弹性、高性能和高可用性，是电商业务中处理海量数据存储和查询的理想选择。本文实践除了使用TDSQL-C MYSQL外，通过python语言和
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值