C++之序列式容器（vector、list、deque、string）

最新推荐文章于 2024-05-08 12:15:17 发布
最新推荐文章于 2024-05-08 12:15:17 发布
阅读量461 收藏 13
点赞数 2
分类专栏： C++ 文章标签： stl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sheena997/article/details/105948729
版权

一、vector

1.vector的定义及使用

  • 定义： vector是可以改变大小数组的顺序容器。
  • 使用
#include <iostream>
#include <vector>

using namespace std;

void testVector1()
{
	vector<int> vc;
	vc.push_back(1); //尾插
	vc.push_back(2); //尾插
	vc.push_back(3); //尾插
	vc.push_back(4); //尾插
	
	size_t n = vc.size(); //计算vector的大小

						  
    //for循环遍历vector方法一：
	cout << "方法一for循环遍历：" << ' ';
	for (int i = 0; i < n; ++i)
	{
		cout << vc[i] << ' ';
	}
	cout << endl;

	//迭代器遍历vector方法二：
	cout << "方法二迭代器遍历：" << ' ';
	auto it = vc.begin();
	while (it != vc.end())
	{
		cout << *it << ' ';
		++it;
	}
	cout << endl;

	//范围for遍历vector方法三：
	cout << "方法三范围for遍历：" << ' ';
	for (auto e : vc)
	{
		cout << e << ' ';
	}
	cout << endl;

}
void testVector2()
{
	//初始化方法一：创建10个5的数组
	vector<int> vc(10, 5);
	cout << "vc:" << ' ';
	for (auto e : vc)
		cout << e << ' ';
	cout << endl;

	//初始化方法二：用迭代器区间初始化
	vector<int> v1(vc.begin(), vc.end());
	cout << "v1:" << ' ';
	for (auto e : v1)
		cout << e << ' ';
	cout << endl;

	vector<int> v2(++v1.begin(), --v1.end());
	cout << "v2:" << ' ';
	for (auto e : v2)
		cout << e << ' ';
	cout << endl;

}
void testVector3()
{
	vector<int> vc;
	vc.push_back(1); //尾插
	vc.push_back(2); //尾插
	vc.push_back(3); //尾插
	vc.push_back(4); //尾插

	cout << "正向遍历vector：" << ' ';
	for (auto e : vc)
		cout << e << ' ';
	cout << endl;
	//反向遍历vector
	cout << "反向遍历vector：" << ' ';
	vector<int>::reverse_iterator it = vc.rbegin();
	while (it != vc.rend())
	{
		cout << *it << ' ';
		++it;
	}
	cout << endl;

}
void testVector4()
{
	int a[] = { 1, 2, 3, 4 };
	//用迭代器初始化，指针是天然的迭代器
	vector<int> vc(a, a + sizeof(a) / sizeof(int));

	vector<int>::iterator pos = find(vc.begin(), vc.end(), 2);
	cout << "2在数组中的位置：" << pos - vc.begin() << endl;

	cout << "原数组：" << ' ';
	for (auto e : vc)
		cout << e << ' ';
	cout << endl;

	vc.insert(pos, 10);
	cout << "在pos位置插入10：" << ' ';
	for (auto e : vc)
		cout << e << ' ';
	cout << endl;

	pos = find(vc.begin(), vc.end(), 4);
	vc.erase(pos);
	cout << "删除pos位置后：" << ' ';
	for (auto e : vc)
		cout << e << ' ';
	cout << endl;
}
int main()
{
	cout << "testVector1() : " << endl;
	testVector1();
	cout << endl;

	cout << "testVector2() : " << endl;
	testVector2();
	cout << endl;

	cout << "testVector3() : " << endl;
	testVector3();
	cout << endl;

	cout << "testVector4() : " << endl;
	testVector4();
	cout << endl;

	return 0;
}

在这里插入图片描述

2.vector的模拟实现

#include <iostream>
#include <assert.h>

using namespace std;

namespace sheena
{
	template<class T>
	class my_vector
	{
	public:
		typedef T* iterator;
		//构造函数
		my_vector()
			:_start(nullptr)
			,_end(nullptr)
			,_end_of_storage(nullptr)
		{}
		//拷贝构造函数
		my_vector(const my_vector<T>& mv)
		{
			_start = new T[mv.size()];
			memcpy(_start, mv._start, sizeof(T) * mv.size());
			_end = _start + mv.size();
			_end_of_storage = _start + mv.capacity();

		}
		//析构函数
		~my_vector()
		{
			if (_start)
			{
				delete[]_start;
				_start = _end = _end_of_storage = nullptr;
			}
		}



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



		T& operator[](size_t pos)
		{
			return _start[pos];
		}
		const T& operator[](size_t pos)const
		{
			return _start[pos];
		}



		void swap(my_vector<T>& mv)
		{
			swap(_start, mv._start);
			swap(_end, mv._end);
			swap(_end_of_storage, mv._end_of_storage);
		}

		my_vector& operator=(my_vector<T> mv)
		{
			swap(mv);

			return *this;
		}

		//不仅修改了size，而且还可能修改capacity
		my_vector resize(size_t n, const T& val = T())
		{
			if (n < size())
			{
				_end = _start + n;
				return;
			}
			if (n > capacity())
				_end_of_storage = n;

			while (_end != _start + n)
			{
				*_end = val;
				++_end;
			}
		}
		//只修改capacity
		void reserve(size_t n)
		{
			if (n > capacity)
			{
				size_t sz = size();
				T* tmp = new T[n];
				for (size_t i = 0; i < sz; ++i)
					tmp[i] = _start[i];
				delete[]_start;
				_start = tmp;
				_end = _start + sz;
				_end_of_storage = _start + n;
			}
		}


		iterator begin()
		{
			return _start;
		}
		iterator end()
		{
			return _end;
		}



		void insert(iterator& pos, const T* x)
		{
			assert(pos < _end && pos >= _start);
			if (_end == _end_of_storage)
			{
				size_t n = pos - _start;
				size_t newcapacity = capacity() == 0 ? 2 : 2 * capacity();
				reserve(newcapacity);
				pos = _start + n;
			}

			iterator end = _end - 1;
			while (end > pos)
			{
				*(end + 1) = *end;
				--end;
			}
			*pos = x;
			++_end;
		}
		void erase(iterator pos)
		{
			assert(pos < _end && pos >= _start);
			iterator begin = pos + 1;
			while (begin < _end)
			{
				*(begin - 1) = *begin;
				++begin;
			}
			--_end;
		}
		void push_back(const T& x)
		{
			insert(end(), x);
		}
		void pop_back()
		{
			assert(_end >= _start);
			erase(--end());
		}


	private:
		iterator _start;
		iterator _end;
		iterator _end_of_storage;
	};
}

二、list

1.list的定义及使用

  • 带头循环链表
#include <iostream>
#include <list>

using namespace std;

//迭代器遍历：
void Print1(list<int> lst)
{
	list<int>::iterator it = lst.begin();
	while (it != lst.end())
	{
		cout << *it << ' ';
		++it;
	}
	cout << endl;
}
//范围for遍历：
void Print2(list<int> lst)
{
	for (auto e : lst)
		cout << e << ' ';
	cout << endl;
}
void testList1()
{
	list<int> lst;
	lst.push_back(1);//尾插
	lst.push_back(2);//尾插
	lst.push_back(3);//尾插
	Print1(lst);
	lst.push_front(9);//头插
	lst.push_front(8);//头插
	lst.push_front(7);//头插
	Print1(lst);

	lst.pop_back();//尾删
	Print2(lst);
	lst.pop_front();//头删
	Print2(lst);

}
void testList2()
{
	list<int> lst(4, 100);//创建4个100的双向链表

	cout << "去重之前的lst：" << ' ';
	Print1(lst);
	lst.unique();//去重
	cout << "去重之后的lst：" << ' ';
	Print2(lst);

	lst.push_back(2);
	lst.push_back(9);
	lst.push_back(99);
	lst.push_front(500);
	lst.push_front(22);
	lst.push_front(500);
	lst.push_back(99);

	//lst.unique();
	cout << "排序之前的lst：" << ' ';
	Print2(lst);
	lst.sort();//排序
	cout << "排序之后的lst：" << ' ';
	Print1(lst);

	cout << "去重之后的lst：" << ' ';
	lst.unique();//去重前提是必须有序
	Print1(lst);
}
//迭代器失效
void testList3()
{
	list<int> lst;
	lst.push_back(2);
	lst.push_back(9);
	lst.push_back(99);
	lst.push_front(500);
	lst.push_front(22);
	Print1(lst);

	list<int>::iterator it = lst.begin();
	while (it != lst.end())
	{
		//迭代器失效
		lst.erase(it);//删除节点
		++it;
	}
	Print2(lst);
}
void testList4()
{
	list<int> lst;
	lst.push_back(2);
	lst.push_back(9);
	lst.push_back(99);
	lst.push_front(500);
	lst.push_front(22);
	cout << "删除lst节点之前：" << ' ';
	Print1(lst);

	list<int>::iterator it = lst.begin();
	while (it != lst.end())
		lst.erase(it++);//删除节点
	cout << "删除lst节点之后：" << ' ';
	Print2(lst);
}
int main()
{
	cout << "testList1：" << endl;
	testList1();
	cout << endl;
	cout << "testList2：" << endl;
	testList2();
	cout << endl;

	cout << "testList4：" << endl;
	testList4();
	cout << endl;

	return 0;
}

在这里插入图片描述

2.list的模拟实现

#include <iostream>

using namespace std;

namespace sheena
{
	template <class T>
	struct _list_node
	{
		_list_node<T>* _next;
		_list_node<T>* _prev;
		T _data;

		_list_node(const T& x = T())
			:_next(nullptr)
			,_prev(nullptr)
			,_data(x)
		{}
	};

	template <class T, class Ref, class Ptr>
	struct _list_iterator
	{
		typedef _list_node<T> node;
		typedef _list_iterator<T, Ref, Ptr> Self;
		node* _node;

		_list_iterator(node* node)
			:_node(node)
		{}
		//内置类型
		Ref operator*()
		{
			return _node->_data;
		}
		//自定义类型
		Ptr operator->()
		{
			return &_node->_data;
		}

		//前置++
		Self& operator++()
		{
			_node = _node->_next;
			return *this;
		}
		//后置++
		Self operator++()
		{
			Self tmp(*this);
			_node = _node->_next;
			return tmp;
		}

		//前置--
		Self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}
		//后置--
		Self operator--(int)
		{
			Self tmp(*this);
			_node = _node->_prev;
			return tmp;
		}

		//it1 ！= it2
		bool operato!=(const Self& it)
		{
			return _node != it._node;
		}
		bool operator==(const Self& it)
		{
			return _node == it._node;
		}
	};

	template <class T>
	class my_list
	{
		typedef _list_node<T> node;
	public:
		typedef _list_iterator<T, T&, T*> iterator;
		typedef _list_iterator<const T, const T&, const T*> const_iterator;
		const_iterator begin()const
		{
			return const_iterator(_head->_next);
		}
		const_iterator end()const
		{
			return const_iterator(_head);
		}
		iterator begin()
		{
			return iterator(_head->_next);
		}
		iterator end()
		{
			return iterator(_head);
		}

		my_list()//构造函数
		{
			_head = new node<T>();
			_head->_next = _head;
			_head->_prev = _head;
		}
		my_list(const my_list<T>& ls)//拷贝构造函数
		{
			if (_head != ls._head)
			{
				_head->_next = _head;
				_head->_prev = _head;
				auto it = ls.begin();
				while (it != ls.end())
				{
					push_back(*it);
					++it;
				}
			}
		}
		my_list<T>& operator=(my_list<T> ls)//赋值函数
		{
			swap(_head, ls._head);
			return *this;
		}
		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}
		~my_list()//析构函数
		{
			clear();
			delete _head;
			_head = nullptr;
		}


		void insert(iterator pos, const T& x)
		{
			node* cur = pos._node;
			node* prev = pos._node->_prev;

			node* newnode = new node(x);

			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
		}
		void push_back(const T& x)
		{
			insert(end(), x);
		}
		void push_front(const T& x)
		{
			insert(begin(), x);
		}
		

		iterator erase(iterator pos)
		{
			node* cur = pos->_node;
			node* prev = cur->_prev;
			node* next = cur->_next;

			prev->_next = next;
			next->_prev = prev;

			delete cur;
			cur = nullptr;

			return iterator(next);
		}
		void pop_back()
		{
			erase(--end());
		}
		void pop_front()
		{
			erase(begin());
		}

	private:
		node* _head;
	};
}

3.vector和list对比

（1）vector底层是动态顺序表，一段连续的空间。而list底层是带头结点的双向循环链表
（2）vector支持随机访问，访问某个元素的效率是O(1)。而list不支持随机访问，放入元素的效率是O(N)。
（3）vector尾插尾删的效率是O(1)，任意位置插入和删除的效率低，时间复杂度为O(N)，插入时可能需要增容（开辟新空间，拷贝元素，释放旧空，代价大）。而list尾插尾删、头插头删、任意位置的插入、删除效率都是O(1)，不支持随机访问。
（4）vector底层是连续的空间，不容易造成内存碎片，空间利用率高，缓存利用率高。list底层是节点的动态开辟，小节点容易造成内存碎片，空间利用率低，缓存利用率低。
（5）vector的迭代器是原生态指针。而list的迭代器是对原生态指针进行的封装。
（6）vector在插入元素时，要给所有迭代器重新赋值，因为插入元素可能会导致重新扩容，导致原来的迭代器失效，删除时，当前迭代器需要重新赋值否则会失效。而list插入元素不会导致迭代器失效，删除元素时，只会导致当前迭代器失效，其他迭代器不会受影响。
（7）如果需要随机访问时，不关心插入、删除效率时就是用vector。如果有大量插入和删除操作，不需要随机访问时就用list。

三、deque

1.deque的定义及接口

  • deque是双端队列，底层是一段假象的连续空间，实际是分段连续的空间，而deque的迭代器维护了假象的连续。（其迭代器包含cur、first、last、node。有start迭代器和finish迭代器）
函数声明接口说明
size()返回deque的有效元素的个数
empty()返回deque是否为空，若是空，返回true；若不空，返回false
operator[]随机访问deque元素
front()返回deque首元素的引用
back()返回deque最后一个元素的引用
push_front(val)deque的头插
push_back(val)deque的尾插
insert(pos, val)在deque中pos位置插入val
pop_front()deque的头删
pop_back()deque的尾删
erase(pos)删除deque中pos位置的值
swap()交换deque中的内容
clear()将deque的元素清空

2.接口的使用

#include <iostream>
#include <deque>

using namespace std;

void Print(deque<int> dq)
{
	for (auto e : dq)
		cout << e << " ";
	cout << endl;
}
void Print2(deque<int> dq)
{
	deque<int>::iterator it = dq.begin();
	while (it != dq.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}
void Print3(deque<int> dq)
{
	deque<int>::reverse_iterator rit = dq.rbegin();
	while (rit != dq.rend())
	{
		cout << *rit << " ";
		++rit;
	}
	cout << endl;
}
void testDeque1()
{
	cout << "用10个6构造deque：" << " ";
	deque<int> dq1(10, 6);
	Print2(dq1);

	cout << "用数组构造deque：" << " ";
	int arr[] = { 0,1,2,3,4,5,6,7,8,9 };
	deque<int> dq2(arr, arr + sizeof(arr) / sizeof(arr[0]));
	Print(dq2);

	cout << "用dq2拷贝构造dq3：" << " ";
	deque<int> dq3(dq2);
	Print(dq3);

	cout << "pop_front()：" << " ";
	dq3.pop_front();
	Print(dq3);

	cout << "pop_back()：" << " ";
	dq3.pop_back();
	Print(dq3);

	cout << "push_back(val)：" << " ";
	dq3.push_back(50);
	Print(dq3);

	cout << "push_front(val)：" << " ";
	dq3.push_front(122);
	Print(dq3);

	cout << "insert(pos, val)：" << " ";
	dq3.insert(dq3.begin () + 5, 500);
	Print(dq3);

	cout << "erase(pos)：" << " ";
	dq3.erase(dq3.begin() + 3);
	Print2(dq3);


	cout << "size()：" << " ";
	cout << dq3.size() << endl;

	cout << "front()：" << " ";
	cout << dq3.front() << endl;

	cout << "back()：" << " ";
	cout << dq3.back() << endl;

	cout << "clear()清空后dq3的size是：" << " ";
	dq3.clear();
	cout << dq3.size() << endl;
}
void testDeque2()
{
	int arr[] = {1,2,3,4,5,6,7,8,9 };
	deque<int> dq(arr, arr + sizeof(arr) / sizeof(arr[0]));

	cout << "operator[]访问：" << " ";
	cout << "dq[3] = " << dq[3] << endl;

	deque<int> dq2(10, 6);
	cout << "swap()之前的dq和dq2：" << endl;
	cout << "dq ：" << " ";
	Print2(dq);
	cout << "dq2 ：" << " ";
	Print(dq2);
	cout << "swap()之后的dq和dq2：" << endl;
	dq.swap(dq2);
	cout << "dq ：" << " ";
	Print2(dq);
	cout << "dq2 ：" << " ";
	Print(dq2);

	cout << "反向打印deque：" << " ";
	Print3(dq2);

}
int main()
{
	cout << "testDeque1：" << endl;
	testDeque1();
	cout << endl;

	cout << "testDeque2：" << endl;
	testDeque2();
	cout << endl;

	return 0;
}

在这里插入图片描述

  • swap()是交换两个deque。
  • insert(pos, val)和erase(pos)中的pos是迭代器。

3.deque的总结

  • 在序列式容器中，如果只是简单的存储元素，使用vector即可，如果对任意位置的插入、删除比较多，使用list即可。而deque的最大的应用就是作为标准库中的stack和queue的底层结构。

四、string

1.string的定义及使用

#include <iostream>
#include <string>

using namespace std;

void testString1()
{
	string s1;//无参数初始化
	string s2("hello");//带参初始化
	cout << "带参初始化s2：" << s2 << endl;
	string s3(s2);//拷贝构造
	cout << "拷贝构造s3：" << s3 << endl;

	cout << "s2的size为：    " << s2.size() << endl;
	cout << "s2的length为：  " << s2.length() << endl;
	cout << "s2的capacity为：" << s2.capacity() << endl;

	cout << "clear()清空s2之后的size为：    " << " ";
	s2.clear();
	cout << s2.size() << endl;
	cout << "clear()清空s2之后的capacity为：" << " ";
	cout << s2.capacity() << endl;
}
void testString2()
{
	string s = "hello sheena";
	cout << "初始状态：" << endl;
	cout << "size：    " << s.size() << endl;
	cout << "capacity：" << s.capacity() << endl;
	cout << endl;
	cout << "resize(n)之后状态（增容）：" << endl;
	string s1(s);
	s1.resize(20);
	cout << "s1：      " << s1 << endl;
	cout << "size：    " << s1.size() << endl;
	cout << "capacity：" << s1.capacity() << endl;
	cout << endl;
	string s2(s);
	s2.resize(20, 'q');
	cout << "resize(n, c)之后状态（增容）：" << endl;
	cout << "s2：      " << s2 << endl;
	cout << "size：    " << s2.size() << endl;
	cout << "capacity：" << s2.capacity() << endl;
	cout << endl;
	cout << "resize(n)之后状态（缩容）：" << endl;
	string s3(s);
	s3.resize(10);
	cout << "s3：     " << s3 << endl;
	cout << "size：   " << s3.size() << endl;
	cout << "capacity：" << s3.capacity() << endl;
	cout << endl;

}
void Print1(const string s)
{
	for (int i = 0; i < s.size(); ++i)
		cout << s[i] << " ";
	cout << endl;
}
void Print2(const string s)
{
	cout << endl;
	cout << "遍历字符串方法二顺序遍历：" << " ";
	auto it = s.begin();
	while (it != s.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	cout << "遍历字符串方法二逆序遍历：" << " ";
	auto rit = s.rbegin();
	while (rit != s.rend())
	{
		cout << *rit << " ";
		++rit;
	}
	cout << endl;
}
void Print3(const string s)
{
	for (auto& e : s)
		cout << e << " ";
	cout << endl;
}
int main()
{
	cout << "testString1：" << endl;
	testString1();
	string s = "hello sheena!";
	cout << "遍历字符串方法一for循环：" << " ";
	Print1(s);
	cout << endl;
	cout << "遍历字符串方法二迭代器： " << " ";
	Print2(s);
	cout << endl;
	cout << "遍历字符串方法三范围for：" << " ";
	Print3(s);
	cout << endl;
	cout << endl;
	cout << "testString2：" << endl;
	testString2();

	return 0;
}

在这里插入图片描述

  • size()和length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一致。一般情况下基本都是用size()。
  • clear()知识将string中有效字符清空，不改变底层空间大小。（上面的样例中clear()之后，size变成了0，而capacity依旧是15）
  • resize(size_t n)与resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时。resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。注意：resize在改变元素个数时。如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。（如上面的样例所示，缩容之后capacity不变，改变的是size）
  • reserve(size_t res_arg = 0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserve不会改变容量大小。

2.string的模拟实现

//模拟实现一个简单的string类

#include <iostream>

using namespace std;

namespace sheena
{
	class my_string
	{
	public:
		//构造函数
		my_string(const char* str = "")//字符串""中有一个'\0'
			:_str(new char[strlen(str) + 1])//+1是为了加'\0'
		{
			if (nullptr == str)
				str = "";
			strcpy(_str, str);//strcpy可以拷贝'\0'
		}
		//拷贝构造函数
		my_string(const my_string& s)
			:_str(nullptr)
		{
			my_string tmp(s._str);
			swap(tmp._str, _str);
		}
		//赋值函数
		my_string& operator=(my_string s)
		{
			swap(s._str, _str);
			return *this;
		}
		//析构函数
		~my_string()
		{
			if (_str)
			{
				delete[]_str;
				_str = nullptr;
			}
		}
	private:
		char* _str;
	};
}

3.string和vector对比

（1）string中有’\0’，vector< char >中没有’\0’。
（2）string常要比较大小，vector< char >没必要比较大小。
（3）string重载输入输出，vector< char >用push_back等。

五、resize和reverse的区别

  • resize既分配了空间，也创建了对象。reserve只修改capacity大小，不修改size大小，resize既修改了size大小，也可以修改capacity的大小（当resize(n)中的n < capacity时）。
  • resever：仅仅改变空间（capacity）（如果已经知道需要多少空间直接开空间），提高效率，只有增容没有缩容（开空间时避免增容）。
  • resize：开空间+初始化。不仅改变空间（capacity），而且放了n个值进去（即改变了size）,size可以缩小也可以放大。
Sheena爽
关注
  • 2
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C++11 STL 序列式容器 vector、list、string、deque...
身在边城 心在编程
08-23 440
底层结构 是动态数组，在堆中分配内存，元素连续存放，有保留内存，如果减少大小后，内存也不会释放；如果新值大于当前大小时才会重新分配内存。 vector 具有以下特性： O(1)时间的快速访问 顺序存储，所以插入到非尾结点位置所需时间复杂度为O(n)，删除也一样； 扩容规则： 当我们新建一个 vector 的时候，会首先分配给他一片连续的内存空间，如std::vector vec，当通过push...
集合（二）List，ArrayList,LinekList,Vector
weixin_38108266的博客
09-03 540
ArrayList,LinkedList,Vector List，Queue中的元素有序可重复 ArrayList,LinekList,Vector 均为可伸缩数组，即就是可以动态改变长度的数组。 1.ArrayList： 数组实现，查询速度快，插入慢,非线程安全。ArrayList底层维护了一个Object[]用于存储对象，默认数组的长度是10。可以通过new ArrayList(20)...
C++——list和string
最新发布
mdjsmg的博客
05-08 617
C++容器的学习开始啦！大家先来学习list！紧接着string和vector也会一一呈现！大家继续加油吧！这次的模拟实现就到这里啦这些只是建议的模拟，目的是让大家更充分的了解容器的使用如果对于里面一些知识不了解的话，可以看看前面的博客哟大家继续加油吧！
C++学习：list容器详解（一）
热门推荐
mazidao2008的专栏
11-12 7万+
 list容器详解      首先说说STL       STL就是Standard Template Library，标准模板库。这可能是一个历史上最令人兴奋的工具的最无聊的术语。从根本上说，STL是一些“容器”的集合，这些“容器”有list,vector,set,map等，STL也是算法和其他一些组件的集合。这里的“容器”和算法的集合指的是世界上很多聪明人很多年的杰作。    
c++ 容器（list学习总结）
weixin_30505225的博客
02-03 144
list是一个线性双向链表结构，它的数据由若干个节点构成，每一个节点都包括一个信息块（即实际存储的数据）、一个前驱指针和一个后驱指针。它无需分配指定的内存大小且可以任意伸缩，这是因为它存储在非连续的内存空间中，并且由指针将有序的元素链接起来。由于其结构的原因，list随机检索的性能非常的不好，因为它不像vector那样直接找到元素的地址，而是要从头一个一个的顺序查找，这样目标元素越靠...
C++ List
柯拉的博客
04-21 525
#include <iostream> #include <list> using namespace std; int main() { list<int> li = { 1,2,3 }; li.push_front(4); //在 list开端进行插入 li.push_back(5);//在list末尾进行插入 auto ...
标准C++的StringList
08-08
标准C++写的,仿VCL中的TStringList类
C++ list用法
u010248077的博客
05-02 206
// TestList.cpp : 定义控制台应用程序的入口点。//#include "stdafx.h"#include &lt;iostream&gt;#include &lt;list&gt;#include &lt;algorithm&gt;#include &lt;string&gt;using namespace std;template&lt;class T&gt; void pri...
C++中的STL中list用法
halazi100
03-04 7847
1.关于list容器 list是一种序列式容器。 list容器完成的功能实际上和数据结构中的双向链表是极其相似的，list中的数据元素是通过链表指针串连成逻辑意义上的线性表，也就是list也具有链表的主要优点，即：在链表的任一位置进行元素的插入、删除操作都是快速的。 list的实现大概是这样的：list的每个节点有三个域：前驱元素指针域、数据域和后继元素指针域。 前驱元素指针域保存了前驱元素的首...
c++中list的基本用法
Hello，小高同学
03-21 2294
#include <iostream> #include <list> #include <string> using namespace std; template <typename T> void Showlist(list<T> v) { for(typename list<T>::iterator it =...
序列式容器vector、list、deque比较
hblhly的专栏
07-02 294
vector ： vector拥有一段连续的内存空间，能非常好的支持随即存取，即[]操作符，但由于它的内存空间是连续的，所以在中间进行插入和删除会造成内存块的拷贝，另外，当插入较多的元素后，预留内存空间可能不够，需要重新申请一块足够大的内存并把原来的数据拷贝到新的内存空间。这些影响了vector的效率，但是实际上用的最多的还是vector容器，建议大多数时候使用vector效率一般是不错的。lis...
c++ list判断是否包含_【Java必修课】判断String是否包含子串的四种方法及性能对比
weixin_39804059的博客
11-26 406
1 简介判断一个字符串是否包含某个特定子串是常见的场景，比如判断一篇文章是否包含敏感词汇、判断日志是否有ERROR信息等。本文将介绍四种方法并进行性能测试。2 四种方法2.1 JDK原生方法String.indexOf在String的函数中，提供了indexOf（subStr）方法，返回子串subStr第一次出现的位置，如果不存在则返回-1。例子如下：assertEquals2.2 JDK原生方法...
C++中list的用法详细介绍
weixin_63246738的博客
07-21 1202
c++中的list
STL（十七）string基本字符序列容器
Just for fun的专栏
09-01 338
一、string技术原理        字符串由一个个字符组成，字符分为单字节char和双字节wchar_t两种。因此，构造泛型的字符串类，必须适用于以上两种类型的字符。 单字节的字符串类型string和双字节的字符串类型wstring 二、string应用基础 #include 1、创建string对象 2、字符的添加 3、字符的遍历访问       iterator  beg
一文详解c++的stl库中string、vector、list的使用和模拟实现
qq_64872625的博客
01-18 927
一文详解c++的stl库中string、vector、list的使用和模拟实现
C++中常用的容器String、vector、list、map（学习笔记）
ssz__的博客
05-05 968
这里主要讲C++中经常用到的一些保存数据的容器，其中也会介绍string。在C++11中提到了很多容器，这里主要介绍：vector、list、map。还有一些其他的容器就不做介绍了。
C++ STL标准模板库——list
qq_43587345的博客
04-04 663
C++ STL标准模板库——list 基本概念 链表(list)的组成：有一系列的结点组成 结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域 由于链表的存储方式并不是连续的内存空间，因此链表中的迭代器只支持前移和后移，属于双向迭代器 list优点： 采用动态存储分配，不会造成内存浪费和溢出 链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素 list缺...
【C++】STL容器之list
DanteKing的博客
02-08 1211
stl之list的详解和模拟实现
C++ list 的使用
小牧在一直在学习,在前进的道路上大家一起学习，进步。
08-17 3746
list 简介 c++ 中list 是 双向链表容器,不支持随机访问,不过list 的插入和删除动作很快, list 初始化的方法 #include <iostream> #include <string> using namespace std; #include <list> int main() { // 创建一个空的list list<int> a; cout << a.size() << en
"STL笔记1：探索序列式容器与string迭代器
在STL中，序列式容器包括vector、list、deque、array、string等，每种容器都有其特定的优势和适用场景。 1. string string是C++标准库中提供的一种字符串容器，它封装了字符串的基本操作和处理函数，可以方便地...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值