C++--vector

最新推荐文章于 2024-08-09 10:25:03 发布
最新推荐文章于 2024-08-09 10:25:03 发布
阅读量1k 收藏 10
点赞数 14
分类专栏： C++ 文章标签： c++ 开发语言 c语言 java 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74085682/article/details/139099039
版权

目录

 1.vector的介绍

1.1介绍

1.2构造函数

1.3 迭代器的使用

​1.4容量空间相关的接口

 1.5增删改查相关的接口

 2.模拟实现

 模拟实现大致效果​

成员变量 

 容量接口

增删改查接口

[] 重载接口 

构造函数

源码（包含测试用例）： 

 1.vector的介绍

1.1介绍
1. vector 是表示可变大小数组的序列容器。
2. 就像数组一样， vector 也采用的连续存储空间来存储元素。也就是意味着可以采用下标对 vector 的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
3.与其它动态序列容器相比（ deque, list and forward_list ）， vector 在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list 和 forward_list统一的迭代器和引用更好

vector - C++ Reference

1.2构造函数

vector比较常用的构造

1.3 迭代器的使用

常用迭代器接口

begin()获取第一个数据位置的 iterator/const_iterator ， end()获取最后一个数据的下一个位置
的 iterator/const_iterator
 1.4容量空间相关的接口

 capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。 不要固化的认为，vector增容都是2倍，具体增长多少是根据具体的需求定义

的。 vs 是 PJ 版本 STL ， g++ 是 SGI 版本 STL 。
reserve 只负责开辟空间，如果确定知道需要用多少空间， reserve 可以缓解 vector 增容的代价缺陷问题。 resize在开空间的同时还会进行初始化，影响 size 。
 1.5增删改查相关的接口

 2.模拟实现

 模拟实现大致效果
成员变量 
namespace s{
	template<class T>
	class vector {
	public:
        //vector的迭代器底层实际上就是T类型的指针
		typedef T* iterator;
		typedef const T* const_iterator;	
    private:
        //指向第一个数据的位置
		iterator _start = nullptr;
        //指向最后一个数据的位置的下一个位置
		iterator _finish = nullptr;
        //指向最后一个能被用来存放数据的位置（最大容量处）的下一个位置
		iterator _endOfStorage = nullptr;
    };
}
 容量接口
namespace s{
	template<class T>
	class vector {
	public:
        //vector的迭代器底层实际上就是T类型的指针
		typedef T* iterator;
		typedef const T* const_iterator;

        //capacity
        //_finish-_start就是数据个数
		size_t size() const {
			return _finish - _start;
		}

        //_endOfStorage - _start就是容量
		size_t capacity() const {
			return _endOfStorage - _start;
		}

        //如果所开空间小于原来空间不做处理
        //大于就开新空间然后将旧数据拷贝过去，然后更新成员变量
		void reserve(size_t n) {
			if (n > capacity()) {
				size_t oldsize = size();
				T* tmp = new T[n];
				if (_start) {
					for (int i = 0; i < oldsize; i++) {
                        //memcpy()
						tmp[i] = _start[i];
					}
					delete[] _start;
                    _start = tmp;
				    _finish = _start + oldsize;
				    _endOfStorage = _start + n;
				}
			}
		}

        //n>容量->扩容 否则改变_finish指向的位置
		void resize(size_t n,const T& value=T()) {
			if (n > size()) {
				if (n > capacity()) {
					reserve(n);
				}
				while (size() != n) {
					push_back(value);
				}
			}
			else {
				_finish = _start + n;
			}

		}	
    private:
        //指向第一个数据的位置
		iterator _start = nullptr;
        //指向最后一个数据的位置的下一个位置
		iterator _finish = nullptr;
        //指向最后一个能被用来存放数据的位置（最大容量处）的下一个位置
		iterator _endOfStorage = nullptr;
    };
}

对于reserve扩容，这里涉及到了一个问题：如何拷贝？1.浅拷贝 2.深拷贝

先看看浅拷贝，如果T是int类型，使用memcpy确实没有问题，那如果是自定义类型呢？

如vector<string>，T是string，使用memcpy会将_start指向的空间上的值拷贝给新空间，也就产生了下图这样的情况：

当释放旧空间时_start就是个野指针 ，所以这里使用tmp[i] = _start[i]进行拷贝，T若是string，就会调用string的赋值拷贝（深拷贝） 

增删改查接口
        //modify
		void push_back(const T& x) {
			//if (_finish == _endOfStorage) {
			//	size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
			//	reserve(newcapacity);
			//}
			//*_finish = x;
			//_finish++;
			insert(end(), x);
		}

		void pop_back() {
			assert(_finish != _start);
			_finish--;
		}

		void swap(vector<T>& v) {
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endOfStorage,v._endOfStorage );
		}

		iterator insert(iterator pos, const T& x) {
			assert(pos >= _start && pos <= _finish);
			size_t olddistance = pos - _start;
			if (_finish == _endOfStorage) {
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
			}
			pos = _start + olddistance;
			iterator it = end();
			while (it != pos) {
				*it = *(it - 1);
				it--;
			}
			*pos = x;
			_finish++;
			return pos;
		}

		iterator erase(iterator pos) {
			assert(pos >= _start && pos < _finish);
			iterator it = pos;
			while (it != end() - 1) {
				*it = *(it + 1);
				it++;
			}
			_finish--;
			return pos;
		}

此处需要注意的是迭代器的失效问题在vs中迭代器在vector对象经过insert或者erase后就会失效需要更新，更新的方法为通过方法返回值更新

[] 重载接口 
		//access
		T& operator[](size_t pos) {
			assert(pos >= 0 && pos < size());
			return _start[pos];
		}
		const T& operator[](size_t pos) const {
			assert(pos >= 0 && pos < size());
			return _start[pos];
		}
构造函数
		// construct and destroy

        //强制生成默认构造的方法
		vector() = default;
		vector(int n, const T& value = T()) {
			resize(n);
			for (int i = 0; i < size(); i++) {
				_start[i] = value;
			}
		}
        //传入迭代器区间的方式
		template<class InputIterator>
		vector(InputIterator first, InputIterator last) {
			while (first != last) {
				push_back(*first);
				first++;
			}
		}
        //现代方法拷贝构造
		vector(const vector<T>& v) {
			vector<int> tmp(v.cbegin(), v.cend());
			swap(tmp);
		}
        //现代方法赋值构造
		vector<T>& operator= (vector<T> v) {
			swap(v);
			return *this;
		}
源码（包含测试用例）：
#pragma once
#include<assert.h>
namespace xxx
{
	template<class T>
	class vector {

	public:
		typedef T* iterator;
		typedef const T* const_iterator;
		iterator begin() {
			return _start;
		}
		iterator end() {
			return _finish;
		}
		const_iterator cbegin() const {
			return _start;
		}
		const_iterator cend() const {
			return _finish;
		}

		// construct and destroy
		vector() = default;
		vector(int n, const T& value = T()) {
			resize(n);
			for (int i = 0; i < size(); i++) {
				_start[i] = value;
			}
		}
		template<class InputIterator>
		vector(InputIterator first, InputIterator last) {
			while (first != last) {
				push_back(*first);
				first++;
			}
		}
		vector(const vector<T>& v) {
			vector<int> tmp(v.cbegin(), v.cend());
			swap(tmp);
		}
		vector<T>& operator= (vector<T> v) {
			swap(v);
			return *this;
		}
		~vector() {
			delete[] _start;
			_start = _finish = _endOfStorage = nullptr;
		}

		//capacity
		size_t size() const {
			return _finish - _start;
		}
		size_t capacity() const {
			return _endOfStorage - _start;
		}
		void reserve(size_t n) {
			if (n > capacity()) {
				size_t oldsize = size();
				T* tmp = new T[n];
				if (_start) {
					for (int i = 0; i < oldsize; i++) {
						tmp[i] = _start[i];
					}
					delete[] _start;
					_start = tmp;
					_finish = _start + oldsize;
					_endOfStorage = _start + n;
				}
			}
		}
		void resize(size_t n,const T& value=T()) {
			if (n > size()) {
				if (n > capacity()) {
					reserve(n);
				}
				while (size() != n) {
					push_back(value);
				}
			}
			else {
				_finish = _start + n;
			}

		}


		//access
		T& operator[](size_t pos) {
			assert(pos >= 0 && pos < size());
			return _start[pos];
		}
		const T& operator[](size_t pos) const {
			assert(pos >= 0 && pos < size());
			return _start[pos];
		}

		//modify
		void push_back(const T& x) {
			//if (_finish == _endOfStorage) {
			//	size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
			//	reserve(newcapacity);
			//}
			//*_finish = x;
			//_finish++;
			insert(end(), x);
		}
		void pop_back() {
			assert(_finish != _start);
			_finish--;
		}
		void swap(vector<T>& v) {
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endOfStorage,v._endOfStorage );
		}
		iterator insert(iterator pos, const T& x) {
			assert(pos >= _start && pos <= _finish);
			size_t olddistance = pos - _start;
			if (_finish == _endOfStorage) {
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
			}
			pos = _start + olddistance;
			iterator it = end();
			while (it != pos) {
				*it = *(it - 1);
				it--;
			}
			*pos = x;
			_finish++;
			return pos;
		}
		iterator erase(iterator pos) {
			assert(pos >= _start && pos < _finish);
			iterator it = pos;
			while (it != end() - 1) {
				*it = *(it + 1);
				it++;
			}
			_finish--;
			return pos;
		}

	private:
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _endOfStorage = nullptr;
	};

	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 (auto e : v) {
			cout << e << " ";
		}
		cout << endl;
		v.pop_back();
		for (auto e : v) {
			cout << e << " ";
		}
		cout << endl;
	}
	void test2() {
		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(5);
		for (auto e : v) {
			cout << e << " ";
		}
		cout << endl;
		vector<int> s;
		s.push_back(3);
		s.push_back(3);
		s.push_back(3);
		s.push_back(3);
		for (auto e : s) {
			cout << e << " ";
		}
		cout << endl;
		v.swap(s);
		for (int i = 0; i < s.size(); i++) {
			cout << s[i] << " ";
		}
		cout << endl;
	}
	void test3() {
		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(5);
		v.resize(2);
		for (auto e : v) {
			cout << e << " ";
		}
		cout << endl;
		vector<int> s(5, 6);
		for (auto e : s) {
			cout << e << " ";
		}
	}
	void test4() {
		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(5);
		vector<int> s(v.begin(), v.end());
		for (auto e : s) {
			cout << e << " ";
		}
		cout << endl;
		string ss("hello");
		vector<int> x(ss.begin(), ss.end());
		for (auto e : x) {
			cout << e << " ";
		}
		cout << endl;
	}
	void test5() {
		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(5);
		vector<int> s(v);
		for (auto e : s) {
			cout << e << " ";
		}
		cout << endl;
		vector<int> x;
		x = v;
		for (auto e : x) {
			cout << e << " ";
		}
		cout << endl;
	}
	void test6() {
		vector<int> v;
		v.push_back(1);
		v.push_back(20);
		v.push_back(2);
		v.push_back(3);
		v.push_back(3);
		for (auto e : v) {
			cout << e << " ";
		}
		cout << endl;
		v.resize(10,1);
		for (auto e : v) {
			cout << e << " ";
		}
		cout << endl;
		v.resize(4, 1);
		for (auto e : v) {
			cout << e << " ";
		}
		cout << endl;
	}
	void test7() {
		vector<int> v;
		v.push_back(1);
		v.push_back(20);
		v.push_back(2);
		v.push_back(3);
		v.push_back(3);
		v.insert(v.begin()+1, 6);
		for (auto e : v) {
			cout << e << " ";
		}
		cout << endl;
	}
	void test8() {
		vector<int> v;
		v.push_back(1);
		v.push_back(20);
		v.push_back(2);
		v.push_back(3);
		v.push_back(3);
		for (auto e : v) {
			cout << e << " ";
		}
		cout << endl;
		v.erase(v.end()-1);
		for (auto e : v) {
			cout << e << " ";
		}
		cout << endl;
		v.erase(v.end() - 1);
		v.erase(v.end() - 1);
		v.erase(v.end() - 1);
		v.erase(v.end() - 1);
		for (auto e : v) {
			cout << e << " ";
		}
		cout << endl;
		/*v.erase(v.end() - 1);*/
	}
	void test8() {
		vector<int> v;
		v.push_back(1);
		v.push_back(20);
		v.push_back(2);
		v.push_back(3);
		bit::vector<int>::iterator it = v.begin();
		it=v.insert(it, 1);
	}
}

wht6587
关注
  • 14
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ vector 初始化_C++--vector()的用法
萧海的博客
09-20 4935
vector()的用法 概念 vector 是向量类型，它可以容纳许多类型的数据，如若干个整数，所以称其为容器。vector 是C++ STL的一个重要成员，使用它时需要包含头文件： #include<vector>; 一、vector的初始化 (1) vector<int> a(10); //定义了10个整型元素的向量（尖括号中为元素类型名，它可以是任何合法的数据类型），但没有给出初值，其值是不确定的。 测试 #include<iostream> #include&
C++_vector操作
热门推荐
刘同学的博客
05-28 45万+
vector说明： vector是向量类型，可以容纳许多类型的数据，因此也被称为容器 (可以理解为动态数组，是封装好了的类） vector头文件-vector vector初始化： 方式1. vector<int>a(10);//定义具有10个整型元素的向量（尖括号为元素类型名，它可以是任何合法的数据类型），不具有初值，其值不确定 方式2. vector<int>a...
C++ -- vector的元素删除
dongyanxia1000的专栏
10-17 18万+
1、pop_back() void pop_back(); Delete last element Removes the last element in the vector, effectively reducing the container size by one. This destroys the removed element. #include #i
C++--vector()的用法
海到无边天作岸 山登绝顶我为峰
10-06 4275
vector()的用法 概念 vector 是向量类型，它可以容纳许多类型的数据，如若干个整数，所以称其为容器。vector 是C++ STL的一个重要成员，使用它时需要包含头文件： #include<vector>; 一、vector的初始化 (1) vector<int> a(10); //定义了10个整型元素的向量（尖括号中为元素类型名，它可以是任何合法的数据类型）...
C++--vector--修改操作
qq_46659987的博客
04-06 5600
vectorvector的修改操作 vector的修改操作 assign ：分配新内容，替换当前内容 pop_back ：尾删元素 push_back ：尾插元素 template <class T> void printFor(const vector<T>& vec) { for (const auto& e : vec) { cout << e << " "; } cout << endl; } vo
C++ STL--vector详解
weixin_62590142的博客
05-03 2149
以上是vector的几种定义方式，
c++---vector二维数组
m0_50046535的博客
06-18 1万+
1、创建二维数组： 2、获取数组长度： 3、赋值操作 4、增加操作根据需求，增加操作可分为增加行和增加列。增加行列元素，可以使用vector提供的方法push_back()或insert()。对于增行，可以使用asd1.push_back(asd);，其中asd是vector。对于增加列中的元素，需要指定插入的行，可以使用asd1[0].push_back(23);完成插入操作。使用insert()时，需要使用迭代器才能完成在相应位置的插入操作。 5、删除操作删除同样分为删除行和删...
C++-vector：vector切片操作
u013250861的博客
11-30 7547
数组片段截取就是将vector数组的某一段连续的区间单独提取出来存储在另外一个vector数组。
C++ -- vector空间管理
dongyanxia1000的专栏
08-08 4312
1、vector中的reverse()函数用来定义预留空间，改变capacity，不改变size。会去分配内存，但不会构造出对象。 如果改变后的capacity比当前的capacity大，则capacity会变为改变后的capacity，反之capacity不变。 #include #include #include using namespace std; int main() {
C++详解------vector
bububububuDDD的博客
05-27 1698
vector的文档介绍vector是表示可变大小数组的序列容器。就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。
C++ vector----臭飯飯_C++_vector_
10-03
在C++编程语言中，`std::vector`是标准模板库(STL)中的一种容器，它提供了动态数组的功能。`vector`是一个可以容纳任意类型的对象的容器，它能够自动管理内存，允许我们在运行时改变其大小。这个容器的灵活性使得它...
C++ - SGI 版本 STL源码
10-25
**C++ SGI版STL源码详解** STL（Standard Template Library，标准模板库）是C++编程语言中的一个重要组成部分，它提供了高效且灵活的数据结构和算法。SGI（Silicon Graphics, Inc.）公司在90年代为C++社区贡献了一...
C++-2320-1-2
02-15
8. **STL（Standard Template Library）**：C++的标准模板库包含了容器（如vector、list、set）、迭代器、算法和函数对象，是C++编程的强大工具。 9. **智能指针**：如unique_ptr、shared_ptr和weak_ptr，用于自动...
C++ Vector用法详解
09-03
C++中的Vector是一种非常常用的动态数组，它是C++标准模板库(STL)的一部分。STL提供了许多高效且灵活的容器，而Vector就是其中最基础也是最常用的一种。它允许程序员像操作普通数组那样进行动态存储和管理元素，同时...
C++重构vector
05-04
在C++编程中，`std::vector`是一个非常重要的容器，它提供了动态数组的功能，允许在运行时调整大小。在软件开发过程中，由于各种原因，我们可能会遇到需要对`std::vector`进行重构的情况，例如为了提高性能、优化...
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 331
STL中的迭代器失效（vector为例）
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 447
c++ error: ‘*’ does not name a type； did you mean ‘**’?
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
最新发布
qq_19319481的博客
08-09 224
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
C++ STL专题 list的讲解
Mike的博客
08-07 739
1.list是可以在常数范围内任意位置进行插入和删除的序列式容器，并且可以前后双向迭代。2. list的底层是双链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代。4. 与其他的序列式容器相比(vector，deque), list通常在任意位置进行插入，移除元素的执行效率更好。5. 与其他序列式容器相比，
C++ - Vector 计算 均值(mean) 和 方差(variance)
05-30
计算均值和方差可以使用 C++ 的标准库中的 `std::vector` 和 `std::accumulate` 函数以及一些基本数学函数。 以下是计算向量均值和方差的代码示例： ```c++ #include #include <vector> #include <numeric> // ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值