【STL】 vector的底层实现

已于 2024-08-05 20:10:41 修改
阅读量1.1k 收藏 17
点赞数 23
分类专栏： C++ STL系列 文章标签： c++ 算法 开发语言
于 2024-08-05 20:02:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79582015/article/details/140933966
版权

1.vector的模拟代码完整实现（后面会拆分开一个一个细讲）

#pragma once
#include<assert.h>

// 抓重点

namespace bit
{
	/*template<class T>
	class vector
	{
	public:
		typedef T* iterator;

	private:
		T* _a;
		size_t _size;
		size_t _capacity;
	};*/

	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;


		const_iterator begin() const
		{
			return _start;
		}

		const_iterator end() const
		{
			return _finish;
		}

		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		// 类模板的成员函数
		// 函数模板 -- 目的支持任意容器的迭代器区间初始化
		template <class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		vector(size_t n, const T& val = T()) //创建一个包含 n 个元素的向量，并且每个元素都被初始化为 val 的值。
			//如果没有提供 val 参数，则默认使用 T() 构造出的默认值。
		{
			reserve(n);
			for (size_t i = 0; i < n; i++)
			{
				push_back(val);
			}
		}

		vector(initializer_list<T> il)
		//vector(initializer_list<T> il)：这是 vector 类的构造函数。它允许使用花括号 {} 括起来的一组元素来初始化 vector 对象。

		{
			reserve(il.size());
			for (auto e : il)
			{
				push_back(e);
			}
		}

		vector(int n, const T& val = T())
		{
			reserve(n);
			for (int i = 0; i < n; i++)
			{
				push_back(val);
			}
		}

		// 强制编译器生成默认的
		vector() = default;

		// v2(v1)
		vector(const vector<T>& v)
		{
			reserve(v.capacity());
			for (auto e : v)
			{
				push_back(e);
			}
		}
		// 16:05继续
		void swap(vector<T>& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_end_of_storage, v._end_of_storage);
		}

		// v1 = v3
		vector<T>& operator=(vector<T> v)
		{
			swap(v);
			return *this;
		}

		~vector()
		{
			if (_start)
			{
				delete[] _start;
				_start = _finish = _end_of_storage = nullptr;
			}
		}

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t oldsize = size();
				T* tmp = new T[n];

				if (_start)
				{
					//memcpy(tmp, _start, sizeof(T) * old_size);
					for (size_t i = 0; i < oldsize; i++)
					{
						tmp[i] = _start[i];
					}

					delete[] _start;
				}

				_start = tmp;
				_finish = _start + oldsize;
				_end_of_storage = _start + n;
			}
		}

		size_t capacity() const
		{
			return _end_of_storage - _start;
		}

		size_t size()  const
		{
			return _finish - _start;
		}

		T& operator[](size_t i)
		{
			assert(i < size());

			return _start[i];
		}

		const T& operator[](size_t i) const
		{
			assert(i < size());

			return _start[i];
		}

		void push_back(const T& x)
		{
			/*if (_finish == _end_of_storage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
			}

			*_finish = x;
			++_finish;*/

			insert(end(), x);
		}

		void pop_back()
		{
			assert(size() > 0);

			--_finish;
		}

		iterator insert(iterator pos, const T& x)
		{
			assert(pos >= _start);
			assert(pos <= _finish);

			if (_finish == _end_of_storage)
			{
				size_t len = pos - _start;

				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);

				pos = _start + len;
			}

			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}

			*pos = x;
			++_finish;

			return pos;
		}

		// 迭代器
		// 勿在浮沙筑高台
		void erase(iterator pos)
		{
			assert(pos >= _start);
			assert(pos < _finish);

			iterator it = pos + 1;
			while (it != _finish)
			{
				*(it - 1) = *it;
				++it;
			}

			--_finish;
		}

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

2.vector的成员变量

在查看STL库里面vector的实现时，我们发现它是一个类模板并且定义了三个成员变量，分别是iterator start、iterator finish、 iterator end_of_storage用来标记开始，结束，以及总容量，对于vector来说其迭代器iterator就是T*，例如我们之前学习过的顺序表插入的是int类型的数据，所以对存放int类型的vector来说T*就是int*。以此类推，在定义的时候<>里面定义的类型就是容器中所存放的类型  char string list等都可以存放在里面

3.vector中的部分成员变量

template<class T>
class vector
{
public:
	typedef T* iterator;
	typedef const T* const_iterator;


	const_iterator begin() const
	{
		return _start;
	}

	const_iterator end() const
	{
		return _finish;
	}

	iterator begin()
	{
		return _start;
	}

	iterator end()
	{
		return _finish;
	}

4.vector中的构造函数

        1.默认构造

vector()
	:_start(nullptr)
	, _finish(nullptr)
	, _endOfStorage(nullptr)
{}
//上下等价
//vector() = default; //强制编译器生成默认的

        2.拷贝构造

// v2 (v1)
vector(const vector<T>& v)
{
	reserve(v.capacity());
	for (auto e : v) push_back(e);
}

        3.迭代器区间初始化

        

//类模板的成员函数,迭代器区间初始化
//函数模板  -- 目的支持任意容器迭代器区间初始化
template <class InputIterator>
vector(InputIterator first, InputIterator last)
{
	//reserve(last - first);
	while (first != last)
	{
		push_back(*first);
		++first;
	}
}

        4.n个val构造

//n个val构造
vector(size_t n, const T& val = T())//缺省值不能给0，因为T可能是string，所以给匿名对象T()
{
	reserve(n);
	while(n--)
	{
		push_back(val);
	}
}
 
//n个val构造，第一个参数为int类型
vector(int n, const T& val = T())//缺省值不能给0，因为T可能是string，所以给匿名对象
{
	reserve(n);
	while(n--)
	{
		push_back(val);
	}
}

5.对于构造函数的测试

void test_vector7()
{
	vector<string> v1(10);
	vector<string> v2(10, "xxx");
 
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;
	for (auto e : v2)
	{
		cout << e << " ";
	}
	cout << endl;
 
	vector<int> v3(10,1); //若没有迭代器函数区间匹配，可以将就运行
	//vector <int> v3(10u, 1); //因为调用的是unsigned那个
	for (auto e : v3)
	{
		cout << e << " ";
	}
	cout << endl;
 
	vector<int> v4(10, 1);
	for (auto e : v4)
	{
		cout << e << " ";
	}
	cout << endl;
}

6.initializer_list构造

initializer_list是C++新增的一个类型，方便初始化，支持将花括号括起来的值initializer_list，initializer_list对象里面有两个指针，指向花括号里面值开始和结尾的下一个，并支持迭代器，所以可以使用范围for来遍历，当然这个要编译器支持将花括号传给容器

//initializer_list构造
vector(initializer_list<T> il)
{
    reserve(il.size());//size表示数据个数
    for (auto i : il)
    {
        push_back(i);
    }
}

6.1 initializer_list构造的测试代码

void test_vector8() //initializer_list构造测试
{
	//隐式类型转换
	vector<int> v1({ 1,2,3,4,5 });
	vector<int> v2 = { 6,7,8,9,10 };
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;
	for (auto e : v2)
	{
		cout << e << " ";
	}
}

7.赋值运算符的重载

// v1 = v3
vector<T>& operator = (vector<T> v)
{
	swap(v);
	return *this;
}

这里使用传值传参，是实参的拷贝，所以我们将它与被赋值的对象交换后返回即可完成赋值，并且交换后形参生命周期结束就会自动调用析构函数释放原来的空间。

5.vector类中的容量操作

1.size 与 capacity

int main()
 {
 cout << "指定⼤⼩为10时：\n";
 vector<int> v(10, 1);
 cout << v.size() << endl;
 cout << v.capacity() << endl;
 vector<int> v1;
 v1.push_back(1);
 v1.push_back(1);
 v1.push_back(1);
 v1.push_back(1);
 cout << "插⼊四个数据时：\n";
 cout << v1.size() << endl;
 cout << v1.capacity() << endl;
 cout << "插⼊五个数据时：\n";
 v1.push_back(1);
 cout << v1.size() << endl;
 cout << v1.capacity() << endl;
 return 0;
 }
输出结果：
指定⼤⼩为10时：
10
 10
插⼊四个数据时：
4
 4
插⼊五个数据时：
5
 8

capacity的代码在g++ vs 和 clang下分别允许会发现，vs下capacity是按1.5倍增⻓，clang和g++是按2倍增⻓。这个 问题经常会考察，不要固化的认为，vector增容都是2倍，具体增⻓多少是根据具体的需求定义的。vs是PJ版本 STL，g++是SGI版本STL

2.resize

resize在开空间的同时还会进⾏初始化，影响size 使⽤resize()函数可以改变调⽤对象的size和capacity⼤⼩，如果指定的⼤⼩⼩于size时相当于删除数据，当指定⼤⼩ ⼤于size时则作⽤为扩容＋初始化（对于int默认初始化为0）

int main()
 {
 vector<int> v(10, 1);
 for (size_t i = 0; i < v.size(); i++)
  {
 cout << v[i] << " ";
  }
 cout << endl;
 //1 1 1 1 1 1 1 1 1 1 
v.resize(20);
 for (size_t i = 0; i < v.size(); i++)
  {
 cout << v[i] << " ";
  }
 cout << endl;
 //1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 
v.resize(5);
 for (size_t i = 0; i < v.size(); i++)
  {
 cout << v[i] << " ";
  }
 cout << endl;
 //1 1 1 1 1 
//指定⼤⼩⼩于当前的size时，再指定初始化内容时不会修改原始内容
v.resize(3, 3);
 for (size_t i = 0; i < v.size(); i++)
  {
 cout << v[i] << " ";
  }
 //1 1 1
 return 0;
 }

3.reserve

reserve只负责开辟空间，如果确定知道需要⽤多少空间，reserve可以缓解vector增容的代价缺陷问题。 使⽤reserve()函数可以更改调⽤对象的capacity的⼤⼩，注意，如果指定⼤⼩⼩于当前的capacity时，则不会做任何 处理

int main()
 {
 vector<int> v(10, 1);
 cout << "原始⼤⼩：\n";
 cout << v.capacity() << endl;
 cout << v.size() << endl;
 cout << "扩容到20：\n";
 v.reserve(20);
 cout << v.capacity() << endl;
 cout << v.size() << endl;
 cout << "扩容到5：\n";
 v.reserve(5);
 cout << v.capacity() << endl;
 cout << v.size() << endl;
 return 0;
 }
输出结果：
原始⼤⼩：
10
 10
扩容到20：
20
 10
扩容到5：
20
 10

6.vector类中的数据遍历操作

void test2(){
 vector<int> v;
 v.push_back(1);
 v.push_back(2);
 v.push_back(3);
 v.push_back(4);
//迭代器遍历
//指明迭代器类型
vector<int>::iterator it1 = v.begin();
 while (it1 != v.end()) {
 cout << *it1 <<" ";
 it1++;
  }
 cout << endl;//1 2 3 4
 //下标遍历
for (size_t i = 0; i < v.size(); i++) {
 cout << v[i] << " ";
  }
 cout << endl;//1 2 3 4
 //范围for
 for(auto &e : v){
 cout << e <<" ";
  }
 cout << endl;//1 2 3 4
 }
 int main(){
 test2();
 }

6.2 operator 与at()函数

6.3 正向遍历begin()和end()迭代器——⾮const

#include <iostream>
 #include <vector>
 using namespace std;
 int main()
 {
 vector<int> v(10, 1);
 //正向迭代器——⾮const
 vector<int>::iterator it = v.begin();
 while (it != v.end())
  {
 *it = 2;//可修改
cout << *it << " ";
 it++;
  }
 return 0;
 }
输出结果：
2 2 2 2 2 2 2 2 2 2

6.4逆向遍历rbegin()和rend()迭代器——⾮const

#include <iostream>
 #include <vector>
 using namespace std;
 int main()
 {
 vector<int> v;
 v.push_back(1);
 v.push_back(2);
 v.push_back(3);
 v.push_back(4);
 //逆向迭代器——⾮const
 vector<int>::reverse_iterator rit = v.rbegin();
 while (rit != v.rend())
  {
  (*rit)++;//可修改
cout << *rit << " ";
rit++;
  }
 return 0;
 }
输出结果：
5 4 3 2

6.5 assign()函数

//使⽤⼀个对象的迭代器区间为调⽤对象分配内容
#include <iostream>
 #include <vector>
 using namespace std;
 int main()
 {
 //vector<int> v(5, 1);
 vector<int> v;
 v.push_back(1);
 v.push_back(2);
 v.push_back(3);
 v.push_back(4);
 for (auto num : v)
  {
 cout << num << " ";
  }
cout << endl;
 vector<int> v1(10, 2);
 //v.assign(v1.begin(), v1.end());
 v.assign(v1.begin(), v1.end());
 for (auto num : v)
  {
 cout << num << " ";
  }
 return 0;
 }
输出结果：
1 2 3 4
 2 2 2 2 2 2 2 2 2 2
 //指定n个内容为调⽤对象分配
#include <iostream>
 #include <vector>
 using namespace std;
 int main()
 {
 //vector<int> v(5, 1);
 vector<int> v;
 v.push_back(1);
 v.push_back(2);
 v.push_back(3);
 v.push_back(4);
 for (auto num : v)
  {
 cout << num << " ";
  }
 cout << endl;
 //vector<int> v1;
 //v1.push_back(5);
 //v1.push_back(6);
 //v1.push_back(7);
 //v1.push_back(8);
 //v.assign(v1.begin(), v1.end());
 v.assign(10, 5);
 for (auto num : v)
  {
 cout << num << " ";
  }
 return 0;
 }
输出结果：
1 2 3 4
 5 5 5 5 5 5 5 5 5 5

7.插入insert

iterator insert(iterator pos, const T& x)
{
	assert(pos >= _start);
	assert(pos <= _finish);
 
	if (_finish == _end_of_storage)
	{
		//防止迭代器因为后面的扩容失效，所以要提前记录pos位置
		size_t len = pos - _start;
		//size_t len = size();
 
		size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newcapacity);
 
		pos = _start + len; //判断扩容之后os位置，防止野指针出现使迭代器失效
	}
 
	iterator end = _finish - 1; //后移
	while (end >= pos)
	{
		*(end + 1) = *end;
		--end;
	}
 
	*pos = x;
	++_finish;
	return pos;
}

这里要注意迭代器因为扩容导致pos失效的问题(野指针)，所以要提前规避，记录好pos相对位置，然后再即时更新pos迭代器，否则就会出现随机值;

此外，insert的参数pos是对实参的拷贝，形参的改变不会影响实参，所以外部的实参也会失效，但是我们也不能通过引用传参，因为其迭代器返回的是临时拷贝具有常性不能通过引用传参，所以这里我们就可以通过控制insert函数的返回值来解决，我们会返回更新后的迭代器，这样就可以访问该位置了。

7.2push_back可以直接复用insert进行实现

//尾插
void push_back(const T& x)
{
	insert(end(), x);
}

7.3push_back与pop_back函数的测试

//在指定的的迭代器位置后插⼊内容val
 #include <iostream>
 #include <vector>
 using namespace std;
int main()
 {
 vector<int> v;
 v.push_back(1);
 v.push_back(2);
 v.push_back(3);
 v.push_back(4);
 for (size_t i = 0; i < v.size(); i++)
  {
 cout << v[i] << " ";
  }
 cout << endl;
 v.insert(v.begin() + 3, 5);
 for (size_t i = 0; i < v.size(); i++)
  {
 cout << v[i] << " ";
  }
 return 0;
 }
输出结果：
1 2 3 4
 1 2 3 5 4

7.4在指定的迭代器位置后开始插⼊n个val

//在指定的迭代器位置后开始插⼊n个val
 #include <iostream>
 #include <vector>
 using namespace std;
 int main()
 {
 vector<int> v;
 v.push_back(1);
 v.push_back(2);
 v.push_back(3);
 v.push_back(4);
 for (size_t i = 0; i < v.size(); i++)
  {
 cout << v[i] << " ";
  }
 cout << endl;
 v.insert(v.begin() + 3, 5, 10);
 for (size_t i = 0; i < v.size(); i++)
  {
 cout << v[i] << " ";
  }
 return 0;
 }
输出结果：
1 2 3 4
 1 2 3 10 10 10 10 10 4

7.5在指定的迭代器位置后开始插⼊⼀个其他对象对应的迭代器区间中的内容

#include <iostream>
 #include <vector>
 using namespace std;
 int main()
 {
 vector<int> v;
 v.push_back(1);
 v.push_back(2);
 v.push_back(3);
 v.push_back(4);
 for (size_t i = 0; i < v.size(); i++)
  {
 cout << v[i] << " ";
  }
 cout << endl;
 vector<double> v1;
 v1.push_back(5.2);
 v1.push_back(6.3);
 v1.push_back(7.4);
 v1.push_back(8.5);
 //根据调⽤对象的类型决定强制转换的类型
v.insert(v.begin() + 3, v1.begin(), v1.end());//将double强制转换成int类型存⼊int类型的vector对象
for (size_t i = 0; i < v.size(); i++)
  {
 cout << v[i] << " ";
  }
 cout << endl;
 v1.insert(v1.begin() + 3, v.begin(), v.end());//将int强制转换成double类型存⼊double类型的vector
对象
}
 for (size_t i = 0; i < v1.size(); i++)
  {
 cout << v1[i] << " ";
  }
 return 0;
输出结果：
1 2 3 4
 1 2 3 5 6 7 8 4
 5.2 6.3 7.4 1 2 3 5 6 7 8 4 8.5

8.删除erase

iterator erase(iterator pos)
{
	assert(pos >= _start);
	assert(pos < _finish);
 
	iterator it = pos + 1;
	while (it != _finish) //从pos + 1开始往前移动
	{
		*(it - 1) = *it;
		++it;
	}
 
	--_finish;
	return pos;
}

erase()之后迭代器失效问题

  • 有可能删除之后缩容
  • 删除最后一个位置会导致越界访问

所以我们认为删除操作之后迭代器也会失效，和插入函数一样通过返回迭代器来更新迭代器使用才行

8.2 删除指定位置的⼀个数据

//删除指定位置的⼀个数据
#include <iostream>
 #include <vector>
 using namespace std;
 int main()
 {
 vector<int> v;
 v.push_back(1);
 v.push_back(2);
 v.push_back(3);
 v.push_back(4);
 for (size_t i = 0; i < v.size(); i++)
  {
 cout << v[i] << " ";
  }
 cout << endl;//1 2 3 4
 vector<int>::iterator it = v.begin() + 1;
 v.erase(it);
 for (size_t i = 0; i < v.size(); i++)
  {
 cout << v[i] << " ";
  }
 cout << endl;//1 3 4
 //不可以再删除迭代器⼀开始指向的位置，存在迭代器失效问题
//v.erase(it);
 //如果还需要删除下标为1的位置需要再将迭代器更新
it = v.begin() + 1;
 v.erase(it);
 for (size_t i = 0; i < v.size(); i++)
  {
 cout << v[i] << " ";//1 4
  }
 return 0;
 }

8.3 删除迭代器区间中的内容

 //删除迭代器区间中的内容
#include <iostream>
 #include <vector>
using namespace std;
 int main()
 {
 vector<int> v;
 v.push_back(1);
 v.push_back(2);
 v.push_back(3);
 v.push_back(4);
 for (size_t i = 0; i < v.size(); i++)
  {
 cout << v[i] << " ";
  }
 cout << endl;//1 2 3 4
 v.erase(v.begin() + 2, v.end());
 for (size_t i = 0; i < v.size(); i++)
  {
 cout << v[i] << " ";
  }
 cout << endl;//1 2
 return 0;
 }

9.swap函数

使⽤swap()函数可以交换调⽤对象和指定对象中的数据

#include <iostream>
 #include <vector>
 using namespace std;
 int main()
 {
 vector<int> v;
 v.push_back(1);
 v.push_back(2);
 v.push_back(3);
 v.push_back(4);
 vector<int>    
v1(5, 1);
 cout << "交换前：\n";
 cout << "v的size：" << v.size() << endl;//4
 cout << "v的capacity：" << v.capacity() << endl;//4
 for (auto num : v)
  {
 cout << num << " ";
  }
 cout << endl;//1 2 3 4
 cout << "v1的size：" << v1.size() << endl;//5
 cout << "v1的capacity：" << v1.capacity() << endl;//5
for (auto num : v1)
  {
 cout << num << " ";
  }
 //1 1 1 1 1
 v.swap(v1);
 cout << "\n交换后：\n";
 cout << "v的size：" << v.size() << endl;//5
 cout << "v的capacity：" << v.capacity() << endl;
 for (auto num : v)
  {
 cout << num << " ";
  }//11111
 cout << endl;
 cout << "v1的size：" << v1.size() << endl;//4
 cout << "v1的capacity：" << v1.capacity() << endl;//4
 for (auto num : v1)
  {
 cout << num << " ";
  }//1234
 return 0;
 }

10.find函数

#include <iostream>
 #include <vector>
 #include <algorithm>
 using namespace std;
 int main()
 {
 vector<int> v;
 v.push_back(1);
 v.push_back(2);
 v.push_back(3);
 v.push_back(4);
 vector<int>::iterator it = find(v.begin(), v.end(), 3);
cout << *it << endl;//3
    return 0;
 }

11.某帅哥做的笔记——pdf

vector

北海有初拥
关注
专栏目录
嵌入式100题（56）：STL底层数据结构实现
SWK_dy的博客
02-26 338
STL底层数据结构实现 vector底层数据结构为数组，支持快速随机访问。 list底层数据结构为双向链表，支持快速增删。 deque底层数据结构为一个中央控制器和多个缓冲区，详细见STL源码剖析P146，支持首尾(中间不能)快速增删，也支持随机访问deque是一个双端队列(double-ended queue)，也是在堆中保存内容的.它的保存形式如下: 　　　　[堆1] --&gt...
C++ STL Vector底层实现分析
qq_51845557的博客
10-01 434
这次我们来分析STL Vector的实现原理。上次对List的分析并不成功，因为直接阅读源码要理解大量繁琐的STL规定的协议或模式，很影响对代码本身的阅读。所以这次我打算直接抛弃那些内容，直接用更简洁更直观的方式编写一个vector。这样虽然没有STL源码那样规范与标准，其结构的精髓也可以得到很好的理解。 基本结构 相比于List，vector是一个简单的顺序表结构。如图可以生动地展示一个vector所占用的存储空间。其中蓝色的部分代表已经赋值的部分。在values指针所...
STL底层实现
古月潇雨
08-17 6868
C++ STL容器底层数据结构总结 wenmingxing 关注 2018.03.19 17:15* 字数 1176 阅读 426评论 0喜欢 5 STL 就是所谓的标准模板库（Standard Template Library），这可能是C++程序员的一大利器。 总的来说，STL包括几个部分：容器，算法（泛型算法），迭代器三个主要部分（当然还包含仿函数，适配器等其他部分），下图说明了...
STL之vector及其底层实现
fjhugjkdsd的博客
07-18 1111
vector相当于一个动态数组，随着元素的加入，它的内部机制会自行扩充空间以容纳元素。因此，vector的运用对于内存的合理运用与运用的灵活性有很大的帮助。
STL之vector容器底层实现
qq_44004011的博客
03-31 795
vector 在向vector插入元素时，空间够，正常插入，如果空间不足则调用insert_aux辅助函数（不只被push_back调用，在实现时不仅仅满足vector需求） insert_aux的实现 保存原来空间的大小，在扩充时以两倍扩充。 8->16；finsh = new_start； 然后将原来的数据拷贝到新vector，原来的vector销毁（涉及到大量的拷贝构造和析构函数，花费大量的开销） vector iterator 概述 vector的数据安排及操作方式，与数组非常相似，但数
STL中vector的底层实现机制及常用操作
Janway-Win
04-22 1025
本文基于SGI STL vector源码分析其底层实现，只关注核心实现，不考虑空间配置器allocator。 一、vector概述 vector的数据安排以及操作方式，与array非常相似。两者的唯一区别在于空间的运用的灵活性。array是静态空间，一旦配置了就不能改变，要换个大（或小）一点的房子，可以，一切琐细得由客户端自己来：首先配置一块新空间，然后将元素从旧址一一搬往新址，再把原来的空间释还...
c++stl之 vector的底层理解及其模拟实现
qq_54626677的博客
11-26 592
示例代码// a copy of third // 下面涉及迭代器初始化的部分，我们学习完迭代器再来看这部分 // the iterator constructor can also be used to construct from arrays: int myints [ ] = {it!return 0;}
【STL源码剖析】第四章 序列式容器 之 vector底层实现
stt2019
05-25 500
第四章 序列式容器（sequence containers）vectorvector概述vector的数据安排以及操作方式，与array非常相似。两者的唯一差别在于空间的运用的灵活性。array是静态空间，一旦配置了就不能改变；vector的动态空间 ，随着元素的加入，它的内部机制会自行扩充空间以容纳新元素。vector的实现技术，关键在于对其大小的控制以及重新配置时的数据移动效率。vector迭...
vector底层实现及应用注意事项
南风fahaxiki
09-17 418
STL 众多容器中，vector 是最常用的容器之一，其底层所采用的数据结构非常简单，就只是一段连续的线性内存空间（泛型的动态类型顺序表）。
《STL系列》之vector原理及实现
11-25
《STL系列》之vector原理及实现
【STL】vector的底层原理及其实现
稻草人敲代码的博客
04-05 1271
vector一共有4个构造函数，分别对应不同的构造场景。1.vector().无参构造2..构造并且初始化n个元素的值为value.3..拷贝构造4..迭代器初始化构造int main()// 无参构造// 构造的同时初始化4个元素都为100// 迭代器初始化构造// 拷贝构造//迭代器初始化构造示例it!
C++STL细节，底层实现
最新发布
qq_42692132的博客
05-09 1057
C++STL细节，底层实现、特点、应用场景、常用函数。
STL 底层实现原理
热爱数据库的小胖
08-07 383
deque底层实现
C++常见STL的底层实现原理
qq_61084129的博客
03-14 509
Unorder_map和unorder_set: 使用哈希表将元素映射到元素中，提供了快速的查找，插入和删除。array:固定大小的数组容器，类似于原生数组，底层采用静态数组作为存储结构，提供了数组的各种操作方法。list:双向链表容器，底层由节点组成，每个节点包含元素值和指向后节点的指针，支持高效的插入和删除操作。vector:动态数组容器，底层使用连续的内存块存储元素，支持动态扩展和缩容，通过指针进行访问。set/map: 使用红黑树作为底层实现，保持元素的有序性，提供快速查找，插入和删除。
面试官都在问 | 请谈谈vector的底层实现
月已满西楼的博客
03-04 4113
名企高频考点之-请谈谈vector的底层实现 0. 概述 STL版本比较多，第一个STL是在惠普实验室完成的，简称HP版本，后序版本STL都是基于HP版本给出来的，大同小异，本文主要基于SGI-STL版本进行探究，linux下采用就是SGI-STL，而且该版本的命名风格以及编码风格，可读性非常高。 1. vector的底层结构 vector底层实际是泛型的动态类型顺序表，因此其底层实际是一段连续的空间。在SGI-STL的vector中，实际在底层使用三个指针指向该段连续空间的，如下： start指向空间的
简单实现STL库中的容器vector
仰望星空
10-06 332
一、简要说明 本篇博客实现的容器仅仅可存放任意基本数据类型的元素，但是还没有实现容器可存放容器类型的元素（类似于多维数组）。 二、代码实现         2.1 数组声明 #define INCREASEMENT 2 //容器满时,扩容为原来的2倍 #define DEFAULTVALUE 100 //容器默认存放100个元素 template&lt;class item&gt; /...
C++ STL容器底层结构及其复杂度分析
qq_44918555的博客
03-18 1428
C++中的STL常用容器，对其底层结构进行分析
C++入门篇(11)之vector的底层实现
m0_51723227的博客
11-17 6326
文章目录前言定义初始结构声明构造函数容量有关操作获取有效数据大小size()获取数据容量capacity()增加容量reserve()重置大小resize()迭代器数据操作尾插push_back()尾删pop_back()某一位置插入 insert()某一位置删除 erase()拷贝构造[]访问操作=赋值操作特别注意!!!! 前言 上一小节,我们讲解了vector的使用,也大概了解了其创建对象,增删改查数据等操作.那么今天,我们就来大致实现一下吧. 定义初始结构 在标准C++中,vector同样是一个模板
STL底层数据结构的实现
05-13
1. vector底层数据结构的实现： vector实际上是一个动态数组，它是通过连续的内存空间来存储元素的。当元素数量超过当前内存容量时，vector会自动扩容并重新分配内存。在扩容时，vector会将原来的元素拷贝到新分配...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

北海有初拥

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

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

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

打赏作者

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

抵扣说明：

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

余额充值