13天带你了解C++ ---DAY10 C++之vector

最新推荐文章于 2024-06-11 08:56:11 发布
最新推荐文章于 2024-06-11 08:56:11 发布
阅读量378 收藏
点赞数
文章标签： c++ 开发语言 linux c语言 vim
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61720091/article/details/124591142
版权

目录

1.string容器

2.构造函数和析构函数的相关操作

3.迭代器

4.容量相关

5.元素访问相关

6.元素遍历相关

7.元素操作相关

 8.vector模拟实现

1.string容器

        vector容器是C++标准模板库提供的管理任意元素的动态顺序表容器。vector容器底层实现和string很像，都是动态的顺序表。也可以说string是vector的一种特例，它将普通的vector容器封装，增加了对字符串的操作，即对‘0’的操作，下边介绍了vector容器的一些基本操作，均参考于C++官方文档。

2.构造函数和析构函数的相关操作

#include<iostream>
using namespace std;
#include<vector>
void TestVector1() {
	vector<int> v1;
	vector<int> v2(10);
	vector<int> v3(3,5);
	vector<int> v4{ 1,2,3,4,5,6,7,8,9,0 };

	string s("hello world");
	vector<char> v5(s.begin(), s.end());

	vector<char> v6(v5);			//拷贝构造
	vector<char> v7=v6;
	
}

int main() {
	TestVector1();

	return 0;
}

​

3.迭代器

#include<iostream>
using namespace std;
#include<vector>
void TestVector1() {
	vector<int> v4{ 1,2,3,4,5,6,7,8,9,0 };
	string s("hello world");
	vector<char> v5(s.begin(), s.end());

	vector<int>::iterator it = v4.begin();		//正向迭代器
	auto rit = v5.rbegin();						//反向迭代器
	for (it = v4.begin(); it != v4.end(); it++) {
		cout << *it << " " ;
	}
	cout<< endl;

	while (rit != v5.rend()) {
		cout << *rit;
		rit++;
	}
    cout<< endl;

}

int main() {
	TestVector1();
	return 0;
}

​

4.容量相关

#include<iostream>
using namespace std;
#include<vector>
void TestVector2() {
	vector<int> v4{ 1,2,3,4,5,6,7,8,9,0 };

	int len=v4.size();
	cout << "len:" << len << endl;

	v4.resize(15,11);                     //调整有效元素个数为15，若原对象小于15，则用11补位
	cout << "v4.resize(15,11):";
	for (auto e : v4) 
		cout << e<<" ";
		cout << endl;

	v4.resize(5);                           //调整有效元素个数为5，若原对象大于5，则截断
	cout << "v4.resize(5):";
	for (auto e : v4) 
		cout << e<<" ";
		cout << endl;

	v4.reserve(20);                        //调整capcity大小为20
	cout<<"v4.reserve(20):" << v4.capacity()<<endl;

	v4.reserve(3);                         //调整capcity大小为3
	cout << "v4.reserve(3):" << v4.capacity()<<endl;

    v4.clear();                            //清空有效元素
	 bool emp = v4.empty();                //判断对象是否为空
	 cout << emp;
}


int main() {
	TestVector2();

	return 0;
}

​

​

5.元素访问相关

at和[]在使用效果方面完全一致，使用方法举例  cout << str.at(i);

区别：[]在越界访问时会触发assert断言，at会抛出异常，可供用户捕获。

#include<iostream>
using namespace std;
#include<vector>
void TestVector3() {
		vector<int> v1{ 1,2,3,4,5 };
		cout<<v1.at(2)<<endl;
		cout << v1[3] << endl;
	}

int main() {
	TestVector3();

	return 0;
}

6.元素遍历相关

1.下标遍历

2.范围for遍历

3.迭代器遍历

#include<iostream>
using namespace std;
#include<vector>
void TestVector1() {
	vector<int> v4{ 1,2,3,4,5,6,7,8,9,0 };
	string s("hello world");
	vector<char> v5(s.begin(), s.end());

	vector<char> v6(v5);			//拷贝构造
	vector<char> v7=v6;

	vector<int>::iterator it = v4.begin();		//正向迭代器
	auto rit = v5.rbegin();						//反向迭代器
	for (it = v4.begin(); it != v4.end(); it++) { //正向迭代器遍历打印
		cout << *it << " " ;
	}
	cout<< endl;

	while (rit != v5.rend()) {                    //反向向迭代器遍历打印
		cout << *rit;
		rit++;
	}
	cout << endl;

	for (auto e : v4) {							//范围for遍历打印
		cout << e << " ";
	}
	cout << endl;

	for (int i = 0; i <v4.size(); i++) {
		cout << v4[i]<<" ";					    //下标遍历打印
	}
	cout << endl;
}

int main() {
	TestVector1();

	return 0;
}

7.元素操作相关

#include<iostream>
using namespace std;
#include<vector>
void TestVector4() {
		vector<int> v1{ 1,2,3,4,5 };
		v1.push_back(8);			//在顺序表最后插入一个数字
		v1.pop_back();				//删除顺序表的最后一个数字

		auto it = v1.begin();		//删除任意位置的元素
		v1.erase(it);
		
		 it = v1.begin();			//删除指定范围的元素
		 v1.erase(it , it + 2);
		
		auto i = v1.begin();		//在指定位置插入一个元素
		v1.insert(i+2, 99);

		i=v1.begin();				//在你指定位置插入多个元素
		v1.insert(i+2, 5, 88);

	}


int main() {
	TestVector4();
	return 0;
}

 8.vector模拟实现

#include<iostream>
using namespace std;
namespace vec {
	template<class T>
	class vector {
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		vector()
			:start(nullptr)
			,finish(nullptr)
			,end_of_storage(nullptr)
		{}

		vector(size_t n,T& value=T())
			:start(new T[n])
			,finish(start)
			,end_of_storage(start+n)
		{
			for (int i = 0; i < n; i++) {
				*finish++=value;
			}
		}

		vector(int n, T value = T())
			:start(new T[n])
			, finish(start)
			, end_of_storage(start + n)
		{
			for (int i = 0; i < n; i++) {
				*finish++ = value;
			}
		}

		vector(const vector<T>& v)
			: start(nullptr)
			, finish(nullptr)
			, end_of_storage(nullptr) 
		{
			vector<T> tmp(v.cbegin(),v.cend());
			this->swap(tmp);
		}

		template<class Iterator>
		size_t distance(Iterator first, Iterator last) {
			size_t count = 0;
			while (first != last) {
				++count;
				++first;
			}
			return count;
		}



		template<class Iterator>
		vector(Iterator first,Iterator last) {
			size_t n = distance(first, last);
			start = new T[n];
			finish = start;
			end_of_storage = start + n;

			while (first != last) {
				*finish = *first;
				first++;
				finish++;
			}
		}

		

		///赋值运算符重载
		vector<T>& operator=(vector<T> v) {
			this->swap(v);
			return *this;
		}

		~vector() {
			if (start) {
				delete[] start;
				start = nullptr;
				finish = nullptr;
				end_of_storage = nullptr;
			}
		}


		///iterator
		iterator begin() {
			return start;
		}

		iterator end() {
			return finish;
		}

		const_iterator cbegin()const
		{
			return start;
		}
		const_iterator cend()const
		{
			return finish;
		}

		iterator rbegin() {
			return end();
		}

		iterator rend() {
			return start;
			
		}

		/容量
		size_t size()const {
			return finish - start;
		}

		size_t capcity() {
			return end_of_storage - start;
		}

		bool empty()const {
			return finish == start;
		}

		void resize(size_t newsize,const T& value=T()) {
			size_t oldsize = size();
			if (newsize <= oldsize) {
				finish = start+newsize;
			}
			else{
				if (newsize > capcity) {
					reserve(newsize);
				}
				memset(finish, value,newsize-oldsize);
				finish = start+newsize;
			}
		}

		void reserve(size_t newcapcity) {
			size_t oldcapcity = capcity();
			size_t n = size();
			if (newcapcity > oldcapcity) {
				T* tem = new T[newcapcity];
				memcpy(tem, start, sizeof(T) * size());
				delete[] start;
				start=tem;
				finish = start + n;
				end_of_storage = start + newcapcity;
			}
		}



		/元素访问相关
		T& operator[] (size_t index) {
			assert(index < size());
			return start[index];
		}
		
		const T& operator[] (size_t index)const
		{
			assert(index < size());
			return start[index];
		}

		T& front() {
			return *begin;
		}
		T& front()const {
			return start[0];
		}

		T& back() {
			return *(finish-1);
		}
		T& back()const {
			return start[finish-1];
		}

		修改相关操作
		void push_back(const T& value) {
			if (finish == end_of_storage) {
				reserve(capcity() * 2+3);
			}
			*finish = value;
			++finish;
		}
		
		void pop_back() {
			if (empty())
				return;

			--finish;
		}

		/insert
		iterator insert(iterator pos, const T& value) {
			if (pos<start || pos>finish) {
				return pos;
			}
			if (finish == end_of_storage) {
				reserve(capcity()*2);
			}
			auto it = finish - 1;
			while (it >= pos) {
				*(it + 1) = *it;
				it--;
			}
			*pos = value;
			finish++;
			return pos;
		}

		iterator erase(iterator pos) {
			if (pos < start || pos >= finish)
				return end();
			auto it = pos + 1;
			while (it<finish) {
				*(it-1)= *it;
				it++;
			}
			finish--;
		}

		void clear() {
			finish = start;
		}

		void swap(vector<T>& v) {
			std::swap(start, v.start);
			std::swap(finish, v.finish);
			std::swap(end_of_storage, v.end_of_storage);
		}

	private:
		iterator start;
		iterator finish;
		iterator end_of_storage;
	};
}


void TestVector1() {
	vec::vector<int> v1;
	vec::vector<int> v2(10,5);
	vec::vector<int> v3(v2);

	int arr[]{ 1,2,3,4,5,6 };
	vec::vector<int> v4(arr,arr+3);

	for (auto e : v3) {
		cout << e << " ";
	}
	cout<<endl;

	for (auto it = v3.begin(); it!=v3.end(); it++) {
		cout << *it<< " ";
	}
	cout << endl;
}


void TestVector2()
{
	vec::vector<int> v1(10, 5);
	v1.clear();
	v1.empty();
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.pop_back();
	for (auto e : v1) {
		cout << e << " ";
	}
	cout << endl;

	auto it = v1.begin();
	v1.insert(it+1, 99);
	for (auto e : v1) {
		cout << e << " ";
	}
	cout << endl;

	v1.erase(v1.begin());
	for (auto e : v1) {
		cout << e << " ";
	}
	cout << endl;
}



int main() {
	TestVector1();
	TestVector2();
	return 0;
}

一颗二叉树_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
序列式容器 之 vector详解
qq_40115163的博客
02-12 1478
vector容器是c++模板库中十分重要且有用的容器，它的存储结构属于线性表，不过究其根本，vector容器的存储地址是在堆区开辟的，以下本文将简单介绍vector容器的使用方法以及内部实现原理。 一.vector的迭代器 由于vector维护的是一个连续的线性空间（通过SGI提供的配置器alloc申请的连续内存），所以vector的迭代器（迭代器说白了就相当于指针的作用，由于容器是一种特殊的数据结构，需要迭代器这种特殊的指针进行维护，从而实现像普通指针那样对容器内存的访...
vector容器小结
qq_50917103的博客
10-25 239
vector 一、概念 vector本质就是一个封装好的数组（也就是数组描述的线性表），使用vector可以方便快捷的实现对数组中元素进行某些操作。 二、vector的声明 1、一维数组的声明 a、vector<T> vec(n) 声明一个有n个元素的数组，数组中的元素为T类型 vector<char> vec(10); b、vector<T> vec(n,a) 声明一个有n个元素的数组，数组中元素为T类型，而且将数组中所有元素 初始...
操作系统 | 银行家算法及代码实现
偶然i的博客
05-05 946
技术交流qq：1032492413 技术交流VX:Chamfion
C++之unordered_map和unordered_set以及哈希详解
小赵小赵福星高照的博客
03-30 2393
unordered_map和unordered_set的使用 文章目录unordered_map和unordered_set的使用unordered_map的文档unordered_set和unordered_map的两个OJ题两个数组的交集两个数组的交集二set和undered_set的性能比较哈希哈希概念哈希冲突常见哈希函数哈希冲突的解决闭散列开散列闭散列的实现数据的存储结构哈希表的结构哈希表的插入哈希表的查找哈希表的删除哈希表闭散列的代码哈希表闭散列的完整代码开散列的实现开散列概念数据的存储结构哈希表
malloc/new
We need more……
10-08 1216
malloc: 原型：extern void *malloc(unsigned int num_bytes);　　头文件：在TC2.0中可以用malloc.h或 alloc.h (注意：alloc.h 与 malloc.h 的内容是完全一致的)，而在Visual C++6.0中可以用malloc.h或者stdlib.h。　　功能：分配长度为num_bytes字节的内存块　　返回值：如果分配成功则返回指向被分配内存的指针，否则返回空指针NULL。当内存不再使用时，应使用free()函数将内存块释放。　　说明
13天带你了解C++ ---DAY8 C++之STL简介
王童学的博客
04-19 1188
STL六大组件介绍 容器、迭代器、仿函数、适配器、空间配置器
gcc-c++-5.3.1-离线安装aarch64.rpm
11-09
在国产化环境中标麒麟操作系统中，安装软件时提示出现不支持c++编译环境。系统中只能查找到gcc，未找到g++&c++，发现需要重新安装gcc-c++。离线环境无法通过yum命令安装，自己整理了aarch64.rpm离线包。仅供大家参考...
gcc-c++-4.8.5-39.el7.x86_64.rpm
07-08
gcc-c++-4.8.5-39.el7.x86_64.rpm
C++ vector----臭飯飯_C++_vector_
10-03
vector类中所有函数介绍，所有的操作基本上都有
gcc-c++-4.4.4-13.el6.x86_64.rpm
10-22
数据库安装必须的包；
c++运行库2015-2019
05-22
c++运行库2015-2019
C++ 内存分配(new，operator new)面面观 （转）
weixin_33752045的博客
08-30 328
本文主要讲述C++ new运算符和operator new, placement new之间的种种关联，new的底层实现，以及operator new的重载和一些在内存池，STL中的应用。 一 new运算符和operator new()： new：指我们在C++里通常用到的运算符，比如A* a = new A; 对于new来说，有new和::new之分，前者位于std ...
C++new的三种用法
热门推荐
liu111111113的博客
08-02 1万+
转发至：https://zhidao.baidu.com/question/390081383.html 1. new() 分配这种类型的一个大小的内存空间,并以括号中的值来初始化这个变量; 2. new[] 分配这种类型的n个大小的内存空间,并用默认构造函数来初始化这些变量; #include&lt;iostream&gt; #include&lt;cstring&gt; using name...
[C++] 写入到“newSpace”时缓冲区溢出: 可写大小为“newSize*4”个字节，但可能写入了“8”个字节。
qq_44747572的博客
09-18 6302
[写入到“newSpace”时缓冲区溢出: 可写大小为“newSize4”个字节，但可能写入了“8”个字节。] 警告消除 解决方法：newSize后面加4 //添加 //计算添加新空间的大小 int newSize = this->m_EmpNum + addNum; //新空间人数 = 原来记录人数 + 新增人数 //开辟新空间 Worker ** newSpace = new Worker * [newSize+4]; //解决内存溢出问题 newSize+4
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1012
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 147
BCSP-X 11题 C++代码详解
LeetCode 算法：轮转数组c++
小金牛来了
06-09 683
LeetCode 算法：轮转数组c++
c++|unordered系列关联式容器(unordered_set、unordered_map介绍使用+哈希结构)
weixin_68201503的博客
06-09 758
1.unordered_set与set一样元素key与value是一一对应的，且是唯一的,set中的key不能在容器中修改(元素总是const)，但是可以插入和删除,且元素是去重的。2.unordered_set与set不一样的是，其底层是由数组实现，数组存储的是，且节点值的顺序没有按照特定的顺序排序，为了能在常数范围内找到可以所对应的key，unordered_set将相同哈希值的键值对放在相同的桶中(比较抽象，待后续分析)。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
最新发布
清隆学长的博客
06-11 325
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
C++查找5天内过生日的人员的信息
06-12
你需要一个包含所有人员生日信息的数据结构（如数组、哈希表等），以及一些时间处理函数。 首先，获取当前时间，然后遍历人员生日信息，将其转化为时间格式，并计算与当前时间的差值（单位为天）。如果差值小于等于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一颗二叉树_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值