vector容器模拟实现及使用——C++

已于 2022-07-12 19:26:32 修改
阅读量457 收藏 5
点赞数 8
分类专栏： C++ 文章标签： c++ 数据结构 开发语言
于 2022-06-29 18:16:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qwer1234mnbv_/article/details/125520933
版权

目录

一、vector基本概念

二、构造函数

三、assign()赋值函数

四、empty()函数

五、capacity()函数及size()函数

六、resize()函数

七、push_back()尾插函数

八、pop_back()尾删函数

九、insert()插入函数

十、erase()删除函数

十一、clear()清空函数

十二、at()元素访问函数

十三、front()，back()获取头尾元素

十四、swap()交换函数

十五、reserve()预开辟空间函数

十六、begin(),end()迭代器

十七、运算符重载

十八、析构函数

十九、vector全部模拟实现源码

二十、main函数测试用例

一、vector基本概念

1.vector数据结构和数组非常相似，也称为单端数组，也就是顺序表。

当然也可以用链表实现

2.vector是动态的模板顺序表，可以动态扩展

3。扩展是开辟新的空间，将原有数据拷贝过来，并释放旧空间

创建准备，定义专有的命名空间

#include<iostream>
using namespace std;
namespace mxyvector
{
	template<typename T>
	class mvector
	{
		T*_start;
		T*_end;//用指针记录数据元素个数，减去_start即为元素个数
		T*_endofstorage;//记录容量

二、构造函数

函数类外书写，每个函数前都要声明模板

    template<typename T>
	mvector<T>::mvector()//无参构造
	{
		this->_start = this->_end = this->_endofstorage = NULL;
	}
	template<typename T>
	mvector<T>::mvector(T*begin, T*end)//迭代器传参，T*即为iterator
	{
		size_t len = end - begin;//拷贝所需的空间长度
		this->reserve(len);
		for (size_t i = 0; i < len; i++)
		{
			this->_start[i] = begin[i];
			this->_end++;
		}
	}
	template<typename T>
	mvector<T>::mvector(size_t n, T elmn)//元素传参构造
	{
		this->reserve(n);
		for (size_t i = 0; i < n; i++)
		{
			this->_start[i] = elmn;
			this->_end++;
		}
	}
	template<typename T>
	mvector<T>::mvector(const mvector & mvec)//拷贝构造
	{
		this->reserve(mvec.capacity());
		for (size_t i = 0; i < mvec.size(); i++)
		{
			this->_start[i] = mvec._start[i];
			this->_end++;
		}
	}

三、assign()赋值函数

    template<typename T>
	void mvector<T>::assign(T*begin, T* end)
	{
		this->clear();//先清除原有数据
		size_t len = end - begin;
		this->reserve(len);//空间开辟
		for (size_t i = 0; i < len; i++)
		{
			this->_start[i] = begin[i];
			this->_end++;
		}
	}
	template<typename T>
	void mvector<T>::assign(size_t n, T elmn)
	{
		this->clear();
		this->reserve(n);
		for (size_t i = 0; i < n; i++)
		{
			this->_start[i] = elmn;
			this->_end++;
		}
	}

四、empty()函数

    template<typename T>
	bool mvector<T>::empty()
	{
		return this->_start == this->_end;//如果头尾指针相同，则未存任何元素，为空
	}

五、capacity()函数及size()函数

    template<typename T>
	size_t mvector<T>::capacity()const
	{
		return this->_endofstorage - this->_start;//地址相减得长度
	}
	template<typename T>
	size_t mvector<T>::size()const
	{
		return this->_end - this->_start;
	}

六、resize()函数

设定指定大小的空间

    template<typename T>
	void mvector<T>::resize(size_t num)
	{
		if (num <= this->size())//指定任意大小空间
		{
			this->_end = this->_start + num;//重新指定尾指针
			this->_endofstorage = this->_start + num;
			return;
		}
		if (num > this->capacity())//扩大开辟空间
			this->reserve(num);
	}
	template<typename T>
	void mvector<T>::resize(size_t num, T elmn)//则个加个初始化赋值
	{
		if (num <= this->size())
		{
			this->_end = this->_start + num;
			this->_endofstorage = this->_start + num;
			return;
		}
		if (num > this->capacity())
		{
			size_t len = this->size();
			this->reserve(num);
			for (size_t i = len; i < num; i++)
			{
				this->_start[i] = elmn;
				this->_end++;
			}
		}
	}

七、push_back()尾插函数

    template<typename T>
	void mvector<T>::push_back(T elmn)
	{
		this->reserve(this->size()+1);
		this->_start[this->size()] = elmn;
		this->_end++;
	}

八、pop_back()尾删函数

    template<typename T>
	void mvector<T>::pop_back()
	{
		this->_end -= 1;//尾指针后退一位就行
	}

九、insert()插入函数

插入函数的设计：先开辟对应大小空间，再将pos位置后的数据进行移动，再赋上设定值

    template<typename T>
	void mvector<T>::insert(const_iterator pos, T elmn)
	{
		this->reserve(this->size()+ 1);//检查空间是否足够大
		T* end = this->_end- 1;//指向最后一个元素
		while (end >= pos)
		{
			*(end + 1) = *end;//移位覆盖
			end--;
		}
		*(end+1) = elmn;//插入元素
		this->_end++;
	}
	template<typename T>
	void mvector<T>::insert(iterator pos, size_t count, T elmn)
	{
		size_t len1 = pos - this->_start, len2 = this->size();
		this->reserve(this->size() + count);
		pos = this->_start+len1;//pos地址可能会由于扩容改变，需要重新赋值
		for(size_t i=0;i<count;i++)
		{
			for (size_t j = 0; j < len2; j++)
				this->_end[i-j] = this->_end[i-j-1];//循环移位
			pos[i] = elmn;//给挪出来的空间赋值
		}
		this->_end += count;
	}

十、erase()删除函数

    template<typename T>
	void mvector<T>::erase(iterator pos)
	{
		for (iterator i = pos; i < this->_end - 1; i++)//移位覆盖清除
			*i = *(i + 1);
		this->_end -= 1;
	}
	template<typename T>
	void mvector<T>::erase(iterator begin, iterator end)
	{
		size_t len = end - begin;
		for (iterator i = begin; i < end; i++)
			*i = *(i + len);
		this->_end -= len;
	}

十一、clear()清空函数

    template<typename T>
	void mvector<T>::clear()
	{
		this->erase(this->begin(), this->_end);
	}

十二、at()元素访问函数

    template<typename T>
	T&mvector<T>::at(size_t index)
	{
		return *(this->_start + index);
	}

十三、front()，back()获取头尾元素

    template<typename T>
	T&mvector<T>::front()
	{
		return *this->_start;
	}
	template<typename T>
	T&mvector<T>::back()
	{
		return *(this->_end-1);//返回最后一个元素
	}

十四、swap()交换函数

    template<typename T>
	void mvector<T>::swap(mvector & mvec)
	{
		std::swap(this->_start, mvec._start);//运用库函数交换
		std::swap(this->_end, mvec._end);
		std::swap(this->_endofstorage, mvec._endofstorage);
	}

十五、reserve()预开辟空间函数

template<typename T>
	void mvector<T>::reserve(size_t len)
	{
		if (len >this->capacity())
		{
			size_t sz = this->size();
			T* tmp = new T[len];
			if (this->_start) 
			{
				for (size_t i = 0; i < sz; i++)
					tmp[i] = this->_start[i];
				delete[] _start;
			}
			this->_start = tmp;
			this->_end = tmp + sz;//end指向最后一个元素的下一位
			this->_endofstorage = _start + len;
		}
	}

十六、begin(),end()迭代器

这部分类外写报错，只好写在类中了

        iterator&begin()
		{
			return this->_start;
		}
		iterator&end()
		{
			return this->_end;
		}
		const_iterator&begin()const
		{
			return this->_start;
		}
		const_iterator&end()const
		{
			this->_end;
		}

十七、运算符重载

这部分就重载了【】和赋值=，其他的比较函数还有输入输出流函数也可以重载

    template<typename T>
	mvector<T>&mvector<T>::operator=(const mvector & mvec)
	{
		this->reserve(mvec.capacity());
		for (size_t i = 0; i < mvec.size(); i++)
		{
			this->_start[i] = mvec._start[i];
			this->_end++;
		}
		return *this;
	}


    template<typename T>
	T&mvector<T>::operator[](size_t index)
	{
		return *(this->_start + index);
	}

十八、析构函数

释放_start指向的空间内存

    template<typename T>
	mvector<T>::~mvector()
	{
		if(this->_start)
			delete[]this->_start;
		this->_start = this->_end = this->_endofstorage = NULL;
	}

十九、vector全部模拟实现源码

#include<iostream>
using namespace std;
namespace mxyvector
{
	template<typename T>
	class mvector
	{
		T*_start;
		T*_end;//用指针记录数据元素个数，减去_start即为元素个数
		T*_endofstorage;//记录容量
	public:
		typedef T* iterator;//因使用模板，必须定义在类中
		typedef const T* const_iterator;
		mvector();	//采用模板实现类实现，默认构造函数
		mvector(T*begin, T*end);	//将v[begin(),ens()]区间的元素拷贝给本身
		mvector(size_t n, T elmn);	//构造函数将n个elem拷贝给本身
		mvector(const mvector&mvec);	//拷贝构造函数
		mvector&operator=(const mvector&mvec); //重载=号
		void assign(T* begin, T* end);	//将[begin,end]区间中的数据拷贝复制给本身
		void assign(size_t n, T elmn);	//将n个elem拷贝给本身
		bool empty();	//判断容器是否为空
		size_t capacity()const;	//容器容量
		size_t size()const;	//容器中元素的个数
		void resize(size_t num);	//重新指定容器的长度为num,变长用默认值填充新位置，变短删除超出元素
		void resize(size_t num, T elmn);	//重新指定容器的长度为num,变长用elmn填充新位置，变短删除超出元素
		void push_back(T elmn);	//尾插一个元素
		void pop_back();	//尾删一个元素
		void insert(const_iterator pos, T elmn);	//迭代器指向位置pos插入元素elmn
		void insert(iterator pos, size_t count, T elmn);	//迭代器指向位置pos插入count个元素elmn
		void erase(iterator pos);	//删除迭代器指向的元素
		void erase(iterator begin, iterator end);	//删除迭代器葱begin到end之间的元素
		void clear();	//删除容器中所有元素
		T&at(size_t index);	//返回索引index所指的数据
		T&operator[](size_t index);	//返回索引index所指的数据
		T&front();	//返回容器中的第一个元素
		T&back();	//返回容器中的最后一个数据元素
		void swap(mvector&mvec);	//将mvec与本身的元素互换
		void reserve(size_t len);	//容器预留len个元素长度,预留位置不初始化,元素不可访问
		iterator&begin()
		{
			return this->_start;
		}
		iterator&end()
		{
			return this->_end;
		}
		const_iterator&begin()const
		{
			return this->_start;
		}
		const_iterator&end()const
		{
			this->_end;
		}
		~mvector();	//析构函数
	}; 
	template<typename T>
	mvector<T>::mvector()
	{
		this->_start = this->_end = this->_endofstorage = NULL;
	}
	template<typename T>
	mvector<T>::mvector(T*begin, T*end)
	{
		size_t len = end - begin;//拷贝所需的空间长度
		this->reserve(len);
		for (size_t i = 0; i < len; i++)
		{
			this->_start[i] = begin[i];
			this->_end++;
		}
	}
	template<typename T>
	mvector<T>::mvector(size_t n, T elmn)
	{
		this->reserve(n);
		for (size_t i = 0; i < n; i++)
		{
			this->_start[i] = elmn;
			this->_end++;
		}
	}
	template<typename T>
	mvector<T>::mvector(const mvector & mvec)
	{
		this->reserve(mvec.capacity());
		for (size_t i = 0; i < mvec.size(); i++)
		{
			this->_start[i] = mvec._start[i];
			this->_end++;
		}
	}
	template<typename T>
	mvector<T>&mvector<T>::operator=(const mvector & mvec)
	{
		this->reserve(mvec.capacity());
		for (size_t i = 0; i < mvec.size(); i++)
		{
			this->_start[i] = mvec._start[i];
			this->_end++;
		}
		return *this;
	}
	template<typename T>
	void mvector<T>::assign(T*begin, T* end)
	{
		this->clear();//先清除原有数据
		size_t len = end - begin;
		this->reserve(len);
		for (size_t i = 0; i < len; i++)
		{
			this->_start[i] = begin[i];
			this->_end++;
		}
	}
	template<typename T>
	void mvector<T>::assign(size_t n, T elmn)
	{
		this->clear();
		this->reserve(n);
		for (size_t i = 0; i < n; i++)
		{
			this->_start[i] = elmn;
			this->_end++;
		}
	}
	template<typename T>
	bool mvector<T>::empty()
	{
		return this->_start == this->_end;//如果头尾指针相同，则未存任何元素，为空
	}
	template<typename T>
	size_t mvector<T>::capacity()const
	{
		return this->_endofstorage - this->_start;//地址相减
	}
	template<typename T>
	size_t mvector<T>::size()const
	{
		return this->_end - this->_start;
	}
	template<typename T>
	void mvector<T>::resize(size_t num)
	{
		if (num <= this->size())//指定任意大小空间
		{
			this->_end = this->_start + num;//重新指定尾指针
			this->_endofstorage = this->_start + num;
			return;
		}
		if (num > this->capacity())//扩大开辟空间
			this->reserve(num);
	}
	template<typename T>
	void mvector<T>::resize(size_t num, T elmn)//则个加个初始化赋值
	{
		if (num <= this->size())
		{
			this->_end = this->_start + num;
			this->_endofstorage = this->_start + num;
			return;
		}
		if (num > this->capacity())
		{
			size_t len = this->size();
			this->reserve(num);
			for (size_t i = len; i < num; i++)
			{
				this->_start[i] = elmn;
				this->_end++;
			}
		}
	}
	template<typename T>
	void mvector<T>::push_back(T elmn)
	{
		this->reserve(this->size()+1);
		this->_start[this->size()] = elmn;
		this->_end++;
	}
	template<typename T>
	void mvector<T>::pop_back()
	{
		this->_end -= 1;//尾指针后退一位就行
	}
	template<typename T>
	void mvector<T>::insert(const_iterator pos, T elmn)
	{
		this->reserve(this->size()+ 1);//检查空间是否足够大
		T* end = this->_end- 1;//指向最后一个元素
		while (end >= pos)
		{
			*(end + 1) = *end;//移位覆盖
			end--;
		}
		*(end+1) = elmn;//插入元素
		this->_end++;
	}
	template<typename T>
	void mvector<T>::insert(iterator pos, size_t count, T elmn)
	{
		size_t len1 = pos - this->_start, len2 = this->size();
		this->reserve(this->size() + count);
		pos = this->_start+len1;//pos地址可能会由于扩容改变，需要重新赋值
		for(size_t i=0;i<count;i++)
		{
			for (size_t j = 0; j < len2; j++)
				this->_end[i-j] = this->_end[i-j-1];//循环移位
			pos[i] = elmn;//给挪出来的空间赋值
		}
		this->_end += count;
	}
	template<typename T>
	void mvector<T>::erase(iterator pos)
	{
		for (iterator i = pos; i < this->_end - 1; i++)//移位覆盖清除
			*i = *(i + 1);
		this->_end -= 1;
	}
	template<typename T>
	void mvector<T>::erase(iterator begin, iterator end)
	{
		size_t len = end - begin;
		for (iterator i = begin; i < end; i++)
			*i = *(i + len);
		this->_end -= len;
	}
	template<typename T>
	void mvector<T>::clear()
	{
		this->erase(this->begin(), this->_end);
	}
	template<typename T>
	T&mvector<T>::at(size_t index)
	{
		return *(this->_start + index);
	}
	template<typename T>
	T&mvector<T>::operator[](size_t index)
	{
		return *(this->_start + index);
	}
	template<typename T>
	T&mvector<T>::front()
	{
		return *this->_start;
	}
	template<typename T>
	T&mvector<T>::back()
	{
		return *(this->_end-1);//返回最后一个元素
	}
	template<typename T>
	void mvector<T>::swap(mvector & mvec)
	{
		std::swap(this->_start, mvec._start);//运用库函数交换
		std::swap(this->_end, mvec._end);
		std::swap(this->_endofstorage, mvec._endofstorage);
	}
	template<typename T>
	void mvector<T>::reserve(size_t len)
	{
		if (len >this->capacity())
		{
			size_t sz = this->size();
			T* tmp = new T[len];
			if (this->_start) 
			{
				for (size_t i = 0; i < sz; i++)
					tmp[i] = this->_start[i];
				delete[] _start;
			}
			this->_start = tmp;
			this->_end = tmp + sz;
			this->_endofstorage = _start + len;
		}
	}
	template<typename T>
	mvector<T>::~mvector()
	{
		if(this->_start)
			delete[]this->_start;
		this->_start = this->_end = this->_endofstorage = NULL;
	}
}

二十、main函数测试用例

#include"mvector.hpp"
using namespace mxyvector;
void printMvector(mvector<int>&v)
{
	for (auto i : v)//auto自动判断类型，表示从v中逐一读取
		cout << i << " ";
	cout << endl;
}
void test01()
{
	mvector<int>v1;//默认无参构造
	for (int i = 0; i < 10; i++)
		v1.push_back(i);
	printMvector(v1);
	//通过区间构造
	mvector<int>v2(v1.begin(), v1.end());
	printMvector(v2);
	//n个elmn构造
	mvector<int>v3(7, 3);
	printMvector(v3);
	//拷贝构造
	mvector<int>v4(v3);
	printMvector(v4);
}
void test02()
{
	mvector<int>v1;
	for (int i = 0; i < 10; i++)
		v1.push_back(i);
	printMvector(v1);
	mvector<int>v2;
	v2 = v1;
	printMvector(v2);
	mvector<int>v3;
	v3.assign(v1.begin(), v1.end());
	printMvector(v3);
	mvector<int>v4;
	v4.assign(7, 3);
	printMvector(v4);
}
void test03()
{
	mvector<int>v1;
	for (int i = 0; i < 10; i++)
		v1.push_back(i);
	printMvector(v1);
	if (v1.empty())
		cout << "v1为空" << endl;
	else
	{
		cout << "v1不为空" << endl;
		cout << "v1的容量为:" << v1.capacity() << endl;
		cout << "v1的大小为:" << v1.size() << endl;
	}
	v1.resize(15,3);//指定空间大小
	printMvector(v1);
	v1.resize(5);
	printMvector(v1);
}
void test04()
{
	mvector<int>v1;
	v1.push_back(10);
	v1.push_back(20);
	v1.push_back(30);
	v1.push_back(40);
	v1.push_back(50);
	printMvector(v1);
	v1.pop_back();
	printMvector(v1);
	v1.insert(v1.begin(), 100);
	printMvector(v1);
	v1.insert(v1.begin(), 3, 373);
	printMvector(v1);
	v1.erase(v1.begin());
	printMvector(v1);
	v1.erase(v1.begin() + 1, v1.end());
	printMvector(v1);
	v1.clear();
	printMvector(v1);
}
void test05()
{
	mvector<int>v1;
	for (int i = 0; i < 10; i++)
		v1.push_back(i);
	for (int i = 0; i < v1.size(); i++)
		cout << v1[i] << " ";
	cout << endl;
	for (int i = 0; i < v1.size(); i++)
		cout << v1.at(i) << " ";
	cout << endl;
	cout << "第一个元素为:" << v1.front() << endl;
	cout << "最后一个元素为:" << v1.back() << endl;
}
void test06()
{
	mvector<int>v1;
	for (int i = 0; i < 10; i++)
		v1.push_back(i);
	printMvector(v1);
	mvector<int>v2;
	for (int i = 9; i >=0; i--)
		v2.push_back(i);
	printMvector(v2);
	v1.swap(v2);
	printMvector(v1);
	printMvector(v2);
}
void test07()
{
	mvector<int>v;
	v.reserve(100000);//由实现代码知此时_start仍为空指针
	int num = 0;
	int*p = NULL;
	for (int i = 0; i < 100000; i++)
	{
		v.push_back(i);
		if (p != &v[0])
		{
			p = &v[0];
			num++;
		}
	}
	cout << "num=" << num << endl;
}
int main()
{
	//test01();
	//test02();
	//test03();
	//test04();
	//test05();
	//test06();
	test07();
}

...404 Not Found
关注
  • 8
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
C++ vector 容器的实现
fushanzhifeng的博客
01-30 127
通过C++实现了vector容器。直接上代码。必要的说明在注释中。 #include <iostream> #define DEAFAULT_CAPACITY 4 //默认初始容量 using namespace std; template <typename T> class Vector; template <typename T> ostream &operator<<(ostream &out, Vector<T> &
C++_vector容器模拟实现
lhn的博客
01-23 243
vector容器模拟实现 #include<iostream> #include<assert.h> using namespace std; namespace mystd { template<class T> class vector { public: typedef T * iterator; typedef const T * c...
vector详解~
小磊's blog
01-26 622
贴的函数参考库中的~ cppreference.com -> C++ Vectors -> Details C++ Vectors 构造函数 语法: vector(); vector( size_type num, const TYPE &val ); vector( const vector &from ); vector(
C++——vector容器的基本使用和模拟实现
m0_57249790的博客
10-29 1009
由上图可知vs下vector是以大约1.5增容的。而Linux下g++是以2倍增容的。
C++实现简单的vector容器
TL_mood的博客
03-15 441
vector容器的底层原理其实就是一个顺序表，将一个指针(指向开辟数组)和两个(数组相关参数，数组元素个数和开辟空间大小)封装到一个类里面，作为类的属性。然后再通过定义各种接口函数作为成员函数实现vector容器的功能。vector容器其实是一个类模板，使得容器可以存放各种类型的元素，vector类的定义如下，包括属性、成员函数和运算符重载几部分，MyVector.h文件。
c++ vector模拟实现代码
08-25
vector是C++ STL中一个非常重要的容器，了解 vector 的底层实现原理，可以很好的帮助我们更加熟练的使用vector。这篇文章通过实例代码给大家介绍c++ vector模拟实现，感兴趣的朋友跟随小编一起看看吧
C++中vector容器使用详细说明
09-01
在c++中，vector是一个十分有用的容器，下面通过本文给大家介绍C++中vector容器使用详细说明,需要的朋友可以参考下
C++ vector容器实现贪吃蛇小游戏
12-20
本文实例为大家分享了C++ vector容器 实现贪吃蛇，供大家参考，具体内容如下 使用vector容器实现贪吃蛇简化了很多繁琐操作，且相比之前我的代码已经做到了尽量的简洁 技术环节： 编译环境：windows VS2019 需求： ...
C++实现STL容器之Vector
最新发布
04-08
C++实现STL容器之Vector
C++——vector容器模拟实现
qq_64662686的博客
10-01 488
vector模拟实现+迭代器失效和深浅拷贝
C++中vector容器的常用操作方法实例总结
09-02
vector容器一般被用作创建动态数组,动态数组就像Python中的list结构一样,可以比普通数组拥有更丰富操作方法,下面就为大家整理了一些最常用的操作:
【C++】vector容器的模拟实现
ly_6699的博客
03-10 1029
vector容器实际是一个动态数组，它与array的操作非常相似。最大的区别就在于vector的“动态”，动态的理解就是数组的扩容由vector内部机制实现动态开辟空间，无需用户手动操作（申请新空间-复制元素-释放原空间）。 下面我将通过对vector的理解，自己模拟实现vector的基本操作方法，供大家更好的理解这个容器。 下面是vector函数实现的思想，最下面附有笔者完整代码和测试类，有需要的自取~
C++ vector容器的使用与模拟实现
m0_59074850的博客
10-03 368
C++ vector容器常见接口的使用与模拟实现 迭代器失效问题
c++ vector容器 最全教程
weixin_41874599的博客
06-08 716
#include <iostream> #include <vector> using namespace std; //vector 容器 vector容器是单口容器 //vector 容器提供正向，与反向的迭代器，如v.begin v.end 对应反向v.rbegin v.rend 也提供v.insert()在指定位置插入元素 //vector 在尾部进行操作 v.p...
C++实现图书库存的管理（vector类）
被迫敲代码的张先森的博客
04-13 2197
请设计一个程序实现图书库存的管理（vector类） 【问题描述】 请设计一个程序实现图书库存的管理。请根据给定的main函数及程序输出，完成设计。具体要求如下。 一、请设计一个Book类（与动态数组类的要求一致）： 1、包括私有成员： unsigned int m_ID;//编号 string m_Name;//书名 string m_Introductio//简介 string m_A...
C++ young 程序库——y_vector.hpp
youngphoneix的专栏
08-14 1022
文件位置：young/y_vector.hpp/*The young LibraryCopyright (c) 2005 by 杨桓Permission to use, copy, modify, distribute and sell this software for anypurpose is hereby granted without fee, provided that the abo
vector中的.begin()和.end()
wanglongjiayou的博客
04-14 3467
从cin读入一组词并把它们存入一vector对象,然后设法把所有词都改写为大写形式 #include <iostream> #include <string> #include <vector> using namespace std; int main() { vector<string> V; for (string t; cin >> t; V.push_back(t)); //这种循环语句确实简洁 for
C++：超市货架管理系统
https://github.com/W4ited
11-15 5814
文章目录前言一、超市货架管理系统1.题目说明2.功能要求及说明3.测试数据4.提示二、使用步骤1.引入库2.读入数据总结 前言 关于超市货架管理系统，具体使用语言C++，其中用到STL Stack 和Vector 以个人的想法编写而成代码，感觉使用stack和vector比较方便，就天马行空的写下代码✍。 提示：以下是本篇文章正文内容，下面案例可供参考 一、超市货架管理系统 1.题目说明 在商店中，每种商品用一个货架专门摆放。生产日期越近的越靠近货架底部，出货时从货架顶层取货。一天营业结束后，如果
vector的讲解及模拟实现(c++)
weixin_49312527的博客
05-01 3783
为了方便大家理解我们边模拟实现vector容器的常用操作,然后根据代码讲解如何使用vector的这些功能,这样的话相信可以帮助大家更好的理解vector. 一.vector的介绍 什么是vector以及同其他容器相比的优缺点: 1.vector是表示可变大小数组的序列容器.(因此其空间存在于堆上) 2.就像数组一样,vector也采用的连续存储空间来存储元素,也就是意味着可以采用下标对vector的元素进行访问,和数组一样高效,但是又不像数组,它的大小是可以动态改变的,而且它的大小会被容器..
vector容器一组元素截取——前的字符
07-11
如果你想截取一个vector容器中的每个元素的前面的字符，可以使用字符串的`substr()`函数来实现。你可以遍历vector中的每个元素，然后对每个元素的字符串进行截取操作。 以下是一个示例代码，展示了如何截取vector...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

...404 Not Found

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

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

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

打赏作者

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

抵扣说明：

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

余额充值