本文主讲C++ STL中的vector和list,介绍了部分接口函数,分析这连两个数据结构的优劣。
其实者两个就类似于之前C语言阶段的顺序表和双向链表。
vector
vector介绍
vector是表示可变大小数组的序列容器, 就像数组一样,vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问,和数组一样高效。但是又不像数组,它的大小是可以动态改变的,而且它的大小会被容器自动处理。
vector接口
vector capacity
函数 | 功能 |
---|---|
size() | 返回实际元素个数。 |
resize() | 改变实际元素的个数。 |
capacity() | 返回当前容量。 |
empty() | 判断容器中是否有元素,若无元素,则返回 true ;反之,返回 false 。 |
reserve() | 修改容器的容量 |
list modifiers
函数 | 功能 |
---|---|
push_back() | 在序列的尾部添加一个元素。 |
pop_back() | 移出序列尾部的元素。 |
insert() | 在指定的位置插入一个或多个元素。 |
erase() | 移出一个元素或一段元素。 |
clear() | 移出所有的元素,容器大小变为 0 。 |
swap() | 交换两个容器的所有元素。 |
operator[ ] | 重载了 [ ] 运算符,可以向访问数组中元素那样,通过下标即可访问甚至修改 vector 容器中的元素。 |
vector iterator
函数 | 功能 |
---|---|
begin() | 返回指向容器中第一个元素的迭代器。 |
end() | 返回指向容器最后一个元素所在位置后一个位置的迭代器,通常和 begin() 结合使用。 |
rbegin() | 返回指向最后一个元素的迭代器。 |
rend() | 返回指向第一个元素所在位置前一个位置的迭代器。 |
vector优劣
优:
- 支持高效随机访问。
劣:
- 空间不够需要增容,就可能导致频繁增容和空间浪费的问题
- 头部和中部插入数据时效率较低(因为需要挪动数据)
vector实现
#pragma once
#include <iostream>
#include <assert.h>
#include <algorithm>
//using namespace std;
namespace hw
{
using std::swap;
template <class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
vector()
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{}
传统写法
// //v2(v1)
//vector(const vector<T>& v)
//{
// _start = new T[v.capacity()];
// _finish = _start + v.size();
// _endofstorage = _start + v.capacity();
// memcpy(_start, v._start, v.size() * sizeof(T));
//}
//迭代器初始化
//vector<int> v2(++v1.begin(), --v1.end());
template <class InputIeterator>
vector(InputIeterator first, InputIeterator last)
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
while (first != last)
{
push_back(*first);
++first;
}
}
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endofstorage, v._endofstorage);
}
//现代写法
//v2(v1)
vector(const vector<T>& v)
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
vector<T> tmp(v.begin(), v.end());
swap(tmp);
}
//v1 = v2
vector<T>& operator=(vector<T>& v)
{
swap(v);
return *this;
}
~vector()
{
if (_start)
{
delete[] _start;
_start = _finish = _endofstorage = nullptr;
}
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
T& operator[](size_t i)
{
assert(i <= size());
return _start[i];
}
size_t size() const
{
return _finish - _start;
}
size_t capacity() const
{
return _endofstorage - _start;
}
void reserve(size_t n)
{
if (n > capacity())
{
//扩容
size_t sz = size();
T* tmp = new T[n];
if (_start)
{
//memcpy(tmp, _start, sizeof(T) * size());
for (size_t i = 0; i < sz; i++)
{
//T是int没问题
//T是string, 调用了T的深赋值拷贝
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
_finish = _start + sz;
_endofstorage = _start + n;
}
}
//cosnt T& val = 0; 不合适(因为有些类型不适合),这里给的是 T()匿名对象 缺省
//并且内置类型也是可以这样的,C++对内置类型进行升级,也可以使用构造函数
//必须使用 const + 引用,并且 const + 引用 会延长匿名对象生命周期
void resize(size_t n, const T& val = T())
{
if (n < size())
{
_finish = _start + n;
}
else
{
if (n > capacity())
{
reserve(n);
}
while (_finish != _start + n)
{
*_finish = val;
++_finish;
}
}
}
void push_back(const T& x)
{
if (_finish == _endofstorage)
{
//扩容
reserve(capacity() == 0 ? 4 : capacity() * 2);
}
*_finish = x;
++_finish;
}
iterator insert(iterator pos, const T& x)
{
assert(pos >= _start);
assert(pos <= _finish);
if (_finish == _endofstorage)
{
//扩容导致pos迭代器失效,扩容需要更新一下pos
size_t len = pos - _start;
reserve(capacity() == 0 ? 4 : capacity() * 2);
pos = _start + len;
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *(end);
--end;
}
*pos = x;
++_finish;
return pos;
}
iterator erase(iterator pos)
{
assert(pos >= _start);
assert(pos < _finish);
iterator begin = pos + 1;
while (begin < _finish)
{
*(begin - 1) = *(begin);
++begin;
}
--_finish;
return pos;
}
void pop_back()
{
assert(_finish > _start);
--_finish;
}
private:
iterator _start;
iterator _finish;
iterator _endofstorage;
};
}
list
list介绍
STL list 容器,又称双向链表容器,即该容器的底层是以双向链表的形式实现的。这意味着,list 容器中的元素可以分散存储在内存空间里,而不是必须存储在一整块连续的内存空间中。
list接口
这里只展示常用的
list capacity
函数 | 功能 |
---|---|
empty() | 判断容器中是否有元素,若无元素,则返回 true;反之,返回 false。 |
size() | 返回当前容器实际包含的元素个数。 |
resize() | 调整容器的大小。 |
list element access
函数 | 功能 |
---|---|
front() | 返回第一个元素的引用。 |
back() | 返回最后一个元素的引用。 |
list modifiers
函数 | 功能 |
---|---|
push_front() | 在容器头部插入一个元素。 |
pop_front() | 删除容器头部的一个元素。 |
push_back() | 在容器尾部插入一个元素。 |
pop_back() | 删除容器尾部的一个元素。 |
insert() | 在容器中的指定位置插入元素。 |
erase() | 删除容器中一个或某区域内的元素。 |
swap() | 交换两个容器中的元素,必须保证这两个容器中存储的元素类型是相同的。 |
clear() | 删除容器存储的所有元素。 |
list Iterator
函数 | 功能 |
---|---|
begin() | 返回指向容器中第一个元素的双向迭代器。 |
end() | 返回指向容器中最后一个元素所在位置的下一个位置的双向迭代器。 |
rbegin() | 返回指向最后一个元素的反向双向迭代器。 |
rend() | 返回指向第一个元素所在位置前一个位置的反向双向迭代器。 |
cbegin() | 和 begin() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改元素。 |
cend() | 和 end() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改元素。 |
crbegin() | 和 rbegin() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改元素。 |
crend() | 和 rend() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改元素。 |
list优劣
优:
- 按需申请空间
- 支持任意位置 O(1) 插入,删除
劣:
- 不支持随机读取,访问后面的元素需要用一个指针从前往后访问。
其实看完这两个数据结构的优劣,不难看出这其实是两个互补的数据结构。
实现迭代器时可能出现的问题
如果我们想要实现对其他复杂一点的自定义类型的访问,例如日期类Date
class Date
{
public:
Date(int year = 1, int _month = 1, int day = 1)
{}
private:
int _year;
int _month;
int _day;
};
可能需要重载->
这样的运算符在我们访问可能就会这样it -> -> _year
使用了两次->
其实这里我们编译器有一些优化。
为了增强可读性,编译器帮我们省略了一个->
,所以我们就只需要写一个
->
void test_list2()
{
my_list<Date> lt;
lt.push_back(Date(2022, 8, 12));
lt.push_back(Date(2022, 7, 13));
lt.push_back(Date(2022, 6, 14));
my_list<Date>::iterator it = lt.begin();
while (it != lt.end())
{
//cout << (*it)._year << "/" << (*it)._month << "/" << (*it)._day << endl;
cout << it->_year << "/" << it->_month << "/" << it->_day << endl;
++it;
}
cout << endl;
}