C++ 顺序容器Vector、迭代器以及空间配置器

已于 2022-02-19 10:49:14 修改
阅读量559 收藏 2
点赞数
分类专栏： C++ C++程序设计 文章标签： 容器 c++ 数据结构
于 2019-03-18 16:30:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangfei5354/article/details/88637491
版权

一、迭代器Iterator

1.迭代器的定义

        迭代器是一种检查容器内元素并遍历元素的数据类型。 迭代器提供对一个容器中的对象的访问方法，并且定义了容器中对象的范围。迭代器（iterator）是一种对象，它能够用来遍历标准模板库容器中的部分或全部元素，每个迭代器对象代表容器中的确定的地址。

2.迭代器与指针

指针可以用来遍历存储空间连续的数据结构，但是对于存储空间费连续的，就需要寻找一个行为类似指针的类，来对非数组的数据结构进行遍历。 

迭代器（Iterator）是指针（pointer）的泛化，它允许程序员用相同的方式处理不同的数据结构（容器）。

迭代器是个所谓的复杂的指针，具有遍历复杂数据结构的能力。其下层运行机制取决于其所遍历的数据结构。因此，每一种容器型都必须提供自己的迭代器。事实上每一种容器都将其迭代器以嵌套的方式定义于内部。因此各种迭代器的接口相同，型号却不同。


3.容器迭代器的使用 


每种容器类型都定义了自己的迭代器类型，

如vector：

vector< int>:: iterator iter;//定义一个名为iter的变量

数据类型是由vector< int>定义的iterator 类型。简单说就是容器类定义了自己的iterator类型，用于访问容器内的元素。每个容器定义了一种名为iterator的类型，这种类型支持迭代器的各种行为。 
常用迭代器类型如下： 
 

如上图所示，迭代器类型主要支持两类，随机访问和双向访问。其中vector和deque支持随机访问，list,set,map等支持双向访问。 
1）随机访问：提供了对数组元素进行快速随机访问以及在序列尾部进行快速插入和删除操作。 
2）双向访问：插入和删除所花费的时间是固定的，与位置无关。
每种容器都定义了一对名为 begin 和 end 的函数，用于返回迭代器。下面对迭代器进行初始化操作：

// 定义一个vector对象vec
vector<int> vec;

//将迭代器iter1初始化为指向ivec容器的第一个元素
vector<int>::iterator  iter1=vec.bengin();  

//将迭代器iter2初始化为指向ivec容器的最后一个元素的下一个位置
vector<int>::iterator  iter2=vec.end();

注意：end并不指向容器的任何元素，而是指向容器的最后元素的下一位置，称为超出末端迭代器。如果vector为空，则begin返回的迭代器和end返回的迭代器相同。一旦向上面这样定义和初始化，就相当于把该迭代器和容器进行了某种关联，就像把一个指针初始化为指向某一空间地址一样。

实现CString类的空间配置器 

class CString
{
public:
	CString(char *p = NULL)
	{
		if (p != NULL)
		{
			_pstr = new char[strlen(p) + 1];
			strcpy(_pstr, p);
		}
		else
		{
			_pstr = new char[1];
			*_pstr = '\0';
		}
		cout << "CString" << endl;
	}

	~CString()
	{
		delete[]_pstr;
		_pstr = NULL;
		cout << "~CString" << endl;
	}

	CString(const CString &src)
	{
		_pstr = new char[strlen(src._pstr) + 1];
		strcpy(_pstr, src._pstr);
		cout << "CString src" << endl;
	}
	CString& operator=(const CString &src)
	{
		if (_pstr == src._pstr)
		{
			cout << "operator =" << endl;
			return *this;
		}
		delete[]_pstr;
		_pstr = new char[strlen(src._pstr) + 1];
		strcpy(_pstr, src._pstr);
		cout << "operator =" << endl;
		return *this;
	}
	bool operator>(const CString &src)const
	{
		if (strcmp(_pstr, src._pstr)>0)
		{
			return true;
		}
		return false;
	}
	bool operator<(const CString &src)const
	{
		if (strcmp(_pstr, src._pstr)<0)
		{
			return true;
		}
		return false;
	}
	bool operator==(const CString &src)const
	{
		if (strcmp(_pstr, src._pstr) == 0)
		{
			return true;
		}
		return false;
	}

	int length()const
	{
		return strlen(_pstr);
	}
	char operator[](int index)const
	{
		return _pstr[index];
	}
	const char* c_str()const
	{
		return _pstr;
	}	
	//迭代器
	class iterator
	{
	private:
		char *ps;
	public:
		iterator(char *p) :ps(p) {}
		bool operator!=(const iterator &src)
		{
			return ps != src.ps;
		}
		void operator++()
		{
			ps++;
		}
		char& operator*()
		{
			return *ps;
		}

	};
	//容器的成员变量供迭代器使用
	iterator begin()
	{
		return iterator(_pstr);
	}
	iterator end()
	{
		return iterator(_pstr + length());
	}
private:
	char *_pstr;
	friend CString operator+(const CString &lhs, const CString &rhs);
	friend ostream& operator<<(ostream &out, const CString &str);
};

二、顺序容器vector

1.容器的定义

在数据存储上，有一种对象类型，它可以持有其他对象或指向其他对象的指针，这种对象类型就叫做容器。简单理解，即容器就是保存其他对象的对象。而且，这种“对象”还有处理“其他对象”的方法。分为顺序性容器、关联式容器

标准库定义了三种顺序容器的类型：vector、list和deque（双端队列）。此外，标准库还提供了三种容器适配器：stack、queue和prioroty_queue类型。适配器是根据原始的容器类型所提供的操作，通过定义新的操作接口，来适应基础的容器类型。如下

顺序容器
vector                    支持快速随机访问
list                      支持快速插入/删除
deque                     双端队列

顺序容器适配器
stack                     后进先出栈
queue                     先进先出队列
priority_queue            有优先级管理的队列

2.不带空间配置器的vector

class Vector
{
public:
	// 按指定size进行构造，size个空间，没有元素
	Vector(int size = 0):mCur(0),mSize(size)
	{
		mpVec = new T[mSize];
	}
	// 按指定size进行构造,添加size个元素，元素值是val
	Vector(int size, const T &val = T()) :mSize(size),mCur(size)
	{
		mpVec = new T[mSize];
		int i = 0;
		while (i < mSize)
		{
			mpVec[i++] = val;
		}

	}
	// 按[first, last)区间的元素来构造Vector
	Vector(T *first, T *last)
	{
		mSize = last - first;
		mCur = 0;
		mpVec = new T[mSize];
		while(mCur<mSize)
		{
			mpVec[mCur++] = *first++;
		}
	}
	// 从末尾添加元素
	void push_back(const T &val)
	{
		if (full())
		{
			resize();
		}
		mpVec[mCur++] = val;
	}
	// 从末尾删除元素
	void pop_back()
	{
		if (empty())
		{
			return;
		}
		--mCur;
	}
	bool full()const
	{
		return mCur == mSize;
	}
	bool empty()const
	{
		return mCur == 0;
	}
	// 返回容器元素的个数
	int size()const
	{
		return mCur;
	}
	// Vector的迭代器
	class iterator
	{
	public:
		iterator(T *argv = nullptr) :_mpVec(argv) {}
		void operator++()
		{
			_mpVec++;
		}
		bool operator!=(const iterator &rhs)
		{
			return _mpVec != rhs._mpVec;
		}
		T& operator*()
		{
			return *_mpVec;
		}
	private:
		T *_mpVec;
	};
	iterator begin()
	{
		return iterator(mpVec);
	}
	iterator end()
	{
		return iterator(mpVec + size());
	}

private:
	T *mpVec;
	int mCur;
	int mSize;
	// 容器内存2倍扩容
	void resize()
	{
		if (mSize == 0)
		{
			mCur = 0;
			mSize = 1;
			mpVec = new T[1];
		}
		T *tmp = new T[mSize * 2];
		for (int i = 0; i < mSize; i++)
		{
			tmp[i] = mpVec[i];
		}
		delete[]mpVec;
		mpVec = tmp;
		mSize *= 2;
	}
};
int main()
{
	Vector<int> vec1; // 底层不开辟空间
					  //vec1.push_back(10); // 0 - 1 - 2 - 4 - 8 - 16 - 32 - 64 - 128
					  //vec1.push_back(20);
	for (int i = 0; i < 20; ++i)
	{
		vec1.push_back(rand() % 100 + 1);
	}
	cout << vec1.size() << endl;

	// 用通用的迭代器遍历方式，遍历vec1，并打印容器中所有的元素值
	Vector<int>::iterator it = vec1.begin();
	for (; it != vec1.end(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;

	Vector<int> vec2(10, 20);

	Vector<int>::iterator it1 = vec2.begin();
	for (; it1 != vec2.end(); ++it1)
	{
		cout << *it1 << " ";
	}
	cout << endl;

	int arr[] = { 12,4,56,7,89 };
	Vector<int> vec3(arr, arr + sizeof(arr) / sizeof(arr[0]));

	Vector<int>::iterator it2 = vec3.begin();
	for (; it2 != vec3.end(); ++it2)
	{
		cout << *it2 << " ";
	}
	cout << endl;
	getchar();
	return 0;
}

容器的空间配置器

1.为什么要使用容器的空间配置器

当我们利用容器开辟一段A类型的内存空间，如果A类的构造 要开辟1000个空间，就要调用1000次构造函数。但是我们这里只需要空间，不需要构造对象 ，因此这样的容器显然不是理想的状态。

class A {};
A* pa = new A;
//...执行其他操作
delete pa;

Vector<A> vec(100);

这里我们需要了解构造对象与析构对象中的 new 和delete。

对于new，我们都是先配置内存，然后调用对应的构造函数；而delete则是先调用对应的析构函数，然后释放内存。

因为我们有时候只需要内存空间不需要构造函数。因此我们就需要有一种配置器能够将new操作与delete操作拆分开

就是将开辟内存与调用构造函数分开   将释放内存与调用析构函数分开

此时我们就要给容器使用空间配置器。

使用容器的空间配置器的目的：把对象的内存开辟和对象的构造分开；把对象的析构和内存释放分开。

可以这么理解空间配置器  ：由于new与delete的特殊机制（开辟内存调用构造函数，释放内存调用析构函数），使得我们使用容器开辟一段空间就要调用构造函数（没必要），因此我们需要将这些操作分开来使用。

2.空间配置器的实现

template<typename T>
class Allocator
{
public:
	T* allocate(size_t size) // 开辟内存
	{
		return (T*)malloc(size);
	}
	void deallocate(void *ptr) // 释放内存
	{
		free(ptr);
	}
	void construct(T *ptr, const T &val) // 构造
	{
		new (ptr) T(val);
	}
	void destroy(T *ptr) // 析构
	{
		ptr->~T();
	}
};

3.实现带空间配置器Vector

// 实现容器的空间配置器
template<typename T>
class Allocator
{
public:
	T* allocate(size_t size) // 开辟内存
	{
		return (T*)malloc(size);
	}
	void deallocate(void *ptr) // 释放内存
	{
		free(ptr);
	}
	void construct(T *ptr, const T &val) // 构造
	{
		new (ptr) T(val);
	}
	void destroy(T *ptr) // 析构
	{
		ptr->~T();
	}
};

template<typename T, 
		typename allocator = Allocator<T>>
class Vector
{
public:
	// 按指定size进行构造，size个空间，没有元素
	Vector(int size = 0)
		:mCur(0), mSize(size)
	{
		if (size == 0)
		{
			mpVec = nullptr;
		}	
		else
		{
			//mpVec = new T[mSize];
			mpVec = mAllocator.allocate(mSize * sizeof(T));
		}
	}
	
	// 按指定size进行构造,添加size个元素，元素值是val
	Vector(int size, const T &val)
		:mCur(size), mSize(size)
	{
		mpVec = new T[mSize];
		for (int i = 0; i < mSize; ++i)
		{
			mpVec[i] = val;
		}
	}
	
	// 按[first, last)区间的元素来构造Vector
	Vector(T *first, T *last)
	{
		int size = last - first;
		mSize = size;
		mpVec = new T[mSize];
		for (mCur=0; first < last; ++first)
		{
			mpVec[mCur++] = *first;
		}
	}
	
	~Vector() 
	{ 
		//delete[]mpVec; 
		// 析构有效的对象
		for (int i = 0; i < mCur; ++i)
		{
			mAllocator.destroy(mpVec+i);
		}
		// 释放内存
		mAllocator.deallocate(mpVec);
	}
	
	// 从末尾添加元素
	void push_back(const T &val)
	{
		if (full())
			resize();
		//mpVec[mCur++] = val;
		mAllocator.construct(mpVec+mCur, val);
		mCur++;
	}
	
	// 从末尾删除元素
	void pop_back()
	{
		if (empty())
			return;
		--mCur;
		mAllocator.destroy(mpVec+mCur);
	}
	
	bool full()const { return mCur == mSize; }
	bool empty()const { return mCur == 0; }
	
	// 返回容器元素的个数
	int size()const { return mCur; }
	
	// Vector的迭代器
	class iterator
	{
	public:
		iterator(T *p = nullptr) :_ptr(p) {}
		bool operator!=(const iterator &it)
		{
			return _ptr != it._ptr;
		}
		void operator++() { _ptr++; }
		T& operator*() { return *_ptr; }
	private:
		T *_ptr;
	};
	iterator begin() { return iterator(mpVec); }
	iterator end() { return iterator(mpVec + size()); }
	
private:
	T *mpVec;
	int mCur;
	int mSize;
	allocator mAllocator;  // 存储容器的空间配置器

	// 容器内存2倍扩容
	void resize()
	{
		if (0 == mSize)
		{
			mCur = 0;
			mSize = 1;
			mpVec = mAllocator.allocate(mSize * sizeof(T));
		}
		else
		{
			T *ptmp = mAllocator.allocate(2 * mSize * sizeof(T));
			for (int i = 0; i < mSize; ++i)
			{
				mAllocator.construct(ptmp + i, mpVec[i]);	
			}
			for (int i = 0; i < mSize; ++i)
			{
				mAllocator.destroy(mpVec + i);	
			}
			mAllocator.destroy(mpVec);
			mpVec = ptmp;
			mSize *= 2;
		}
	}
};

偶然i
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
vector容器与iterator迭代器
sead+
08-02 3万+
vector容器 vector是同一种类型的对象的集合，每个对象都有一个对应的整数索引值。和string对象一样，标准库负责管理存储元素的相关内存。我们把vector称为容器，是因为它可以包含其他对象。一个容器中的所有对象都必须是同一种类型的。 使用vector之前，必须包含相应的头文件。 #include using std::vector; vector是一个类模板（class
C++中vector迭代器
最新发布
m0_59674848的博客
03-29 4682
该代码定义了一个vector对象v，并使用auto关键字定义了一个迭代器it来遍历vector中的所有元素。C++ STL中的容器类，如vector、list、map、set等都提供了迭代器，可以通过调用容器的成员函数begin()和end()获取指向容器第一个元素和最后一个元素的迭代器。反向迭代器遍历vector的方法与正向迭代器类似，只需使用rbegin()和rend()方法获取反向迭代器的起始和结束位置。迭代器是一个类或者一个指针，它可以指向容器中的一个元素，然后遍历容器中的所有元素。
c++ vector迭代器
greatzls的博客
08-27 2604
vector<int>::iterator ans;这样定义的一个是迭代器 begin(),end(),返回的是指向容器首元素和末尾元素后一个的两个指针。 #include "mylib7.h" #include <fstream> vector<int>::iterator finds(vector<int>::iterator b , vector<int>::iterator e ,int a); int main() { v
C++标准库vector及迭代器
热门推荐
卡尔
10-05 4万+
vector是同一种对象的集合，每个对象都有一个对应的整数索引值。和string对象一样，标准库将负责管理与存储元素相关的类存。引入头文件 #include 1.vector对象的定义和初始化 vector v1 vector保存类型为T的对象。默认构造函数，v1为空 vector v2(v1) v2是v1的一个副本 vector v3(n,i)
c++ STL容器总结之:vertor与list的应用
09-05
STL的核心组成部分包括容器、算法、迭代器、仿函数、配接器和配置器。在这篇文章中，我们将重点讨论两种常见的序列容器：`vector`和`list`。 首先，容器是STL的基础，它们提供了存储和组织数据的结构。`vector`和`...
C++容器知识点总结
12-26
`：返回指向容器最后一个元素之后的迭代器。 - `Reference front();`：返回对容器第一个元素的引用。 - `Reference back();`：返回对容器最后一个元素的引用。 - `Size_type size();`：返回容器当前的大小。 - `...
C++ STL标准程序库开发指南
02-28
STL的主要组件包括容器、迭代器、算法和函数对象，它们通过模板机制实现，使得代码具有高度的重用性。下面将详细介绍这些组件及其在实际开发中的应用。 1. 容器： - **vector**：动态数组，支持随机访问和快速插入...
C++中list的使用方法及常用list操作总结
08-30
此外，`list`还支持使用`accumulate()`、`transform()`等算法，以及与其他容器的组合使用，如`vector`和`set`。在实际应用中，根据需求选择合适的数据结构和操作可以极大地提高代码效率和可读性。对于需要频繁插入和...
(完整word版)北邮C++数据结构课后习题-习题1参考答案.doc
11-15
8. C++标准模板库(STL)提供了两类容器：顺序容器（如vector、list和deque）和关联容器（如set、map和hash_map），其中顺序容器按照元素的插入顺序保存元素，而关联容器根据某种键值关系组织元素。 9. STL的算法都是...
vector容器的类型和迭代器使用
qq_36812406的博客
10-12 1085
注意：for循环中使用“！=”来代替“&lt;”符号进行条件判断。 vector是同一种类型的集合，使用时需要包含如下的头文件： #include&lt;vector&gt;  using std::vector; 1、vector可以保存系统的数据类型也可以保存自定义对象类型： vector&lt;int&gt; ivec;//ivec holds object of int . v...
STL vector的构造函数和析构函数(2)
roaylchen的博客
06-21 6486
public member function std::vector::vector C++98 C++11 default (1) explicit vector (const allocator_type& alloc = allocator_type()); fill (2) explicit vec
python vector_C++ vector使用方法
weixin_39859954的博客
11-25 3817
在 c++ 中，vector 是一个十分有用的容器。它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。C++ 中数组很坑，有没有类似 Python 中 list 的数据类型呢？类似的就是 vector！vector 是同一种类型的对象的集合，每个对象都有一个对应的整数索引值。和 string 对象一样，标准库将负责管理与存储元...
C++基础知识（十四）--- vector容器
woshizuopie的博客
08-03 1244
因为vector迭代器所需要的操作行为，如：operator->，operator++，operator+=等，普通指针天生具备。Vector 以两个两个迭代器 _Myfirst 和 _Mylast 分别指向配置得来的连续空间中目前已使用的范围，并以迭代器 _Myend 指向整块连续内存空间的尾端。......
自定义vector容器 空间配置器
l2020429的博客
09-03 318
详细注释 使用了空间配置器实现了new和delete功能的拆解，大体实现了vector的功能。
C++迭代器理解与实例详解
HappyToEat的博客
11-13 5783
定义一个数组：char buff[1024]；当我们用指针char *p（char *p = buff）遍历数组时，指针p指向一维数组首元素地址，每次都是从数组第一个元素的偏移到指定位置，即进行指针运算。例如：访问p[100]时，需要p+100，这样浪费时间，影响效率。因此，我们引入迭代器概念。 一、迭代器介绍  迭代器iterator 提供了对顺序或关联容器类型中的每个元素进行连续
【C++】list 用法总结
qq_35516517的博客
03-11 629
list是双向链表 头文件 #include <list> 定义 std::list<int> nameList; // empty list std::list<int> nameList(20); // name list with 20 empty elements std::list<int> List(9, 13);
基于Vector实现C++中的适配器stack（顺序栈）
ChaseRaod的博客
05-02 1991
前面我们讲过用模板实现顺序表的代码实现 模板顺序表 而实际应用中，我们常需要将一种接口转换为用户所需要的另一种接口，这就要用到C++中的适配器，对原本的程序进行一层包装。栈就是其中的一种。 栈遵循后进先出的规则，其插入和删除都是在栈顶操作，是一种特殊的线性顺序表，因此，实现栈我们通常建立在顺序表的基础上。srack不允许遍历，也不提供迭代器。 下面是栈的代码实现：#define _CRT
容器+空间配置器+迭代器理解与应用
qq_41804181的博客
07-25 207
vector 容器 vector容器的特征=》向量容器（底层是数组结构） 默认构造的vector,底层没分配内存 vector添加元素，满了以后，内存以2倍方式增长 问题一：构造了一堆没有用的对象，构造容器时。只需要内存但是new附加的会调用默认构造生成对象（无效对象）。 问题二：从容器删除对象时，并没有真正的析构对象（内存没有释放）。 生成容器时：只需要内存，不需要构造对象。所以需要将...
STL入门：容器、算法与迭代器解析
它由六大组件组成：容器、算法、迭代器、仿函数、适配器和空间配置器。STL容器主要包括序列式容器（如vector、list、deque）和关联式容器（如set、map），它们提供了数据结构的实现。算法则包含了各种常见操作，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值