vector 的使用
vector就是数据结构中学习的顺序表
要用的头文件和命名空间
#include <iostream>
#include <string>
#include <vector>
#include <initializer_list>
using namespace std;
构造 + 遍历
int main()
{
// 构造
// vector<变量类型> 变量名
// 变量类型就是vector中存储的元素的类型
vector<int> v1;
// push_back 尾插
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
// vector 的 n 个 val 的构造
vector<int> v2(10, 1);
// 迭代器构造
vector<int> v3(v2.begin(), v2.end());
// 遍历
// v1.size() 返回v1变量中元素的个数
for (size_t i = 0; i < v1.size(); i++)
{
cout << v1[i];
}
cout << endl;
// 范围for遍历 C++11引入
for (auto e : v2)
{
cout << e;
}
cout << endl;
//迭代器遍历
vector<int>::iterator it1 = v3.begin();
while (it1 != v3.end())
{
cout << *it1;
it1++;
}
cout << endl;
return 0;
}
vector 中的成员函数
int main()
{
vector<int> v1;
// reserve 扩容
v1.reserve(100);
// capacity 返回当前变量的容量
size_t old = v1.capacity();
cout << "capacity:" << old << endl;
for (int i = 0; i < 100; i++)
{
v1.push_back(i);
if (v1.capacity() != old)
{
cout << "capacity:" << v1.capacity() << endl;
old = v1.capacity();
// VS编译器对于vector容器时1.5倍扩容
}
}
// insert 任意迭代器位置之前插入元素
v1.insert(v1.begin(), 111);
v1.insert(v1.begin() + 4, 112);
v1.insert(v1.begin(), 10, 999);
// 算法库中的find,vector没有实现，没有必要
auto it = find(v1.begin(), v1.end(), 5);
if (it != v1.end())// 找不到就返回end迭代器
{
v1.insert(it, 50);
}
for (size_t i = 0; i < v1.size(); i++)
{
cout << v1[i] << " ";
}
cout << endl << endl;
// erase 删除任意迭代器位置的元素
// 删除任意迭代器位置的元素
v1.erase(v1.begin());
// 删除迭代器区间的元素，左闭右开
v1.erase(v1.begin() + 4, v1.begin() + 10);
for (size_t i = 0; i < v1.size(); i++)
{
cout << v1[i] << " ";
}
cout << endl << endl;
int x;
cin >> x;
it = find(v1.begin(), v1.end(), x);
if (it != v1.end())
{
v1.erase(it);
}
for (size_t i = 0; i < v1.size(); i++)
{
cout << v1[i] << " ";
}
cout << endl << endl;
//vector不支持流插入和流提取
return 0;
}
int main()
{
// string 和 vector<char> 的区别：末尾是否有\0
string s1;
vector<char> v1;
vector<string> v2;
// v2中存放string类型的数据
string s2("李四");
v2.push_back(s2);
// 单参数构造函数的隐式类型转换
// const char* -> string 中间会产生临时对象
v2.push_back("王五");
// 不加引用要拷贝构造string类型的对象给e，消耗大，内置类型可以不加
// 加引用如果不改变内容，尽量加const
for (const auto& e : v2)
{
cout << e << " ";
}
cout << endl;
// initializer_list
// 需要头文件#include <initializer_list>
// 本质上il1和il2是在栈上开了一个数组然后用首尾指针指向它
int a[] = { 10, 20, 30 };
auto il1 = { 10, 20, 30 };
auto il2 = { 1, 2, 3, 4, 5, 6, 7 };
// 输出il1的类型的名字
cout << typeid(il1).name() << endl;
//打印 a 和 il1 的首地址，地址相近，说明都在栈上
cout << a << endl;
cout << il1.begin() << endl;
// initializer_list 支持迭代器
for (auto e : il1)
{
cout << e << " ";
}
cout << endl;
for (auto e : il2)
{
cout << e << " ";
}
cout << endl;
// 引入initializer_list是想支持下面的东西
// 构造
// vector<int> v3({ 10, 20, 30 });
// vector<int> v4({ 1, 2, 3, 4, 5, 6, 7 });
// 构造+拷贝构造 编译器优化-> 构造
// 实际中都喜欢这样写
vector<int> v3 = { 10, 20, 30 };
vector<int> v4 = { 1, 2, 3, 4, 5, 6, 7 };
// C++11还允许这样写，把 = 省略了
// vector<int> v3{ 10, 20, 30 };
// vector<int> v4{ 1, 2, 3, 4, 5, 6, 7 };
for (const auto& e : v3)
{
cout << e << " ";
}
cout << endl;
for (const auto& e : v4)
{
cout << e << " ";
}
cout << endl;
return 0;
}
struct A
{
A(int a1, int a2)
:_a1(a1)
,_a2(a2)
{
cout << "A(int a1, int a2)" << endl;
}
A(const A& aa)
:_a1(aa._a1)
,_a2(aa._a2)
{
cout << "A(const A& aa)" << endl;
}
int _a1;
int _a2;
};
int main()
{
// emplace 和 insert 类似
// emplace_back 和 push_back 类似
// 在内置类型下可以认为他们是没有区别的
vector<int> v1 = { 10, 20, 30 };
v1.push_back(1);
v1.emplace_back(2);
for (const auto& e : v1)
{
cout << e << " ";
}
cout << endl;
// 在自定义类型情况下是有区别的
vector<A> v2;
A aa1(1, 1);
// 有名对象
v2.push_back(aa1);
// 匿名对象
v2.push_back(A(2, 2));
// 多参数构造函数的隐式类型转换
v2.push_back({3, 3});
cout << "******************************" << endl;
v2.emplace_back(aa1); // 有名
v2.emplace_back(A(2, 2)); // 匿名
//v2.emplace_back({ 3, 3 }); // 不支持
// 模板的可变参数
// 支持传构造A的参数
v2.emplace_back(3, 3); // 这样写，效率更高一些
vector<A>::iterator it2 = v2.begin();
while (it2 != v2.end())
{
//cout << *it2 << " "; // error
//cout << (*it2)._a1 << ":" << (*it2)._a2 << endl;
cout << it2->_a1 << ":" << it2->_a2 << endl;
it2++;
}
cout << endl;
// 范围for C++11
for (auto& aa : v2)
{
cout << aa._a1 << ":" << aa._a2 << endl;
}
cout << endl;
// C++17 结构化绑定
//auto [x, y] = aa1;
//cout << x << " " << y << endl;
//for (auto [x, y] : v2)
for (auto& [x, y] : v2) // 不加引用会拷贝构造
{
cout << x << ":" << y << endl;
}
cout << endl;
return 0;
}
vector 的模拟实现
// 我们以为vector应该是这样写的
template<class T>
struct vector
{
private:
T* _a;
size_t _size;
size_t _capacity;
};
// 但VS实现的vector对于成员变量作了一点改变
template<class T>
struct vector
{
private:
iterator _start = nullptr; // 起始位置的迭代器
iterator _finish = nullptr; // 就是_start + _size
iterator _endofstorage = nullptr; // 就是 _start + _capacity
};
vector.h
vector.h 就是vector的模拟实现
#pragma once
#include <iostream>
#include <string>
#include <vector>
#include <initializer_list>
#include <cassert>
#include <cstdlib>
#include "ReverseIterator.h" // 反向迭代器
namespace bs
{
//模板的声明和定义不能分离在两个文件 .h .cpp 有链接错误
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endofstorage, v._endofstorage);
}
//赋值运算符重载
//v7(v3)
vector<T>& operator=(vector<T> v)
{
swap(v);
return *this;
}
//构造
//vector()
//{}
//C++11引入 强制编译器生成默认构造
vector() = default;
//C++11引入
vector(initializer_list<T> il)
{
reserve(il.size());
for (auto& e : il)
{
push_back(e);
}
}
//函数模板
//只要数据类型匹配就可以用任意类型容器迭代器去初始化
//不是迭代器就不会实例化这个函数模板
template <class InputIterator, enable_if_t<_Is_iterator_v<InputIterator>, int> = 0>
vector(InputIterator first, InputIterator last)
{
while (first != last)
{
push_back(*first);
++first;
}
}
////只能用我们自己写的vector类型迭代器去初始化
//vector(iterator first, iterator last)
//{
// while (first != last)
// {
// push_back(*first);
// ++first;
// }
//}
//n个val构造
vector(size_t n, const T& val = T())
{
resize(n, val);
}
//拷贝构造
//v2(v1)
vector(const vector<T>& v)
{
//给v2开跟v1一样的空间
reserve(v.capacity());
//将v1中的数据拷贝到v2中
for (auto& e : v)
{
push_back(e);
}
}
//析构
~vector()
{
if (_start)
{
delete[] _start;
_start = _finish = _endofstorage = nullptr;
}
}
//扩容
void reserve(size_t n)
{
if (n > capacity())
{
size_t old_size = size();
//申请新空间
T* tmp = new T[n];
//将旧空间数据拷贝到新空间
if (_start)//如果没有旧空间就不需要拷贝
{
//如果是vector<string>，memcpy对string是浅拷贝
//memcpy(tmp, _start, old_size * sizeof(T));//error
for (size_t i = 0; i < old_size; ++i)
{
//赋值对于string这样的类型，会调用它自己的operator=进行深拷贝
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
_finish = _start + old_size;
_endofstorage = _start + n;
}
}
//改变大小
//val的缺省值给模板的匿名对象
//自定义类型和内置类型都有默认构造
void resize(size_t n, T val = T())
{
if (n > size())
{
reserve(n);
while (_finish != _start + n)
{
*_finish = val;
++_finish;
}
}
else
{
_finish = _start + n;
}
}
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 clear()
{
_finish = _start;
}
//大小
size_t size() const
{
return _finish - _start;
}
//容量
size_t capacity() const
{
return _endofstorage - _start;
}
//尾插
void push_back(const T& x)
{
//检查是否需要扩容
if (_finish == _endofstorage)
{
reserve(capacity() == 0 ? 4 : 2 * capacity());
}
*_finish = x;
++_finish;
}
//尾删
void pop_back()
{
assert(!empty());
--_finish;
}
//任意位置之前插
iterator insert(iterator pos, const T& x)
{
//保证pos合法
assert(pos >= _start && pos <= _finish);
//检查是否需要扩容
if (_finish == _endofstorage)
{
//记录pos和_start的相对距离
size_t len = pos - _start;
//扩容
reserve(capacity() == 0 ? 4 : 2 * capacity());
//更新pos，因为扩容是异地扩容
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 && pos < _finish);
//挪动数据
iterator it = pos + 1;
while (it != _finish)
{
*(it - 1) = *it;
++it;
}
--_finish;
//返回删除位置的下一个位置的迭代器
//由于数据挪动，所以pos迭代器就是指向下一个位置
return pos;
}
//判空
bool empty() const
{
return _start == _finish;
}
private:
iterator _start = nullptr;
iterator _finish = nullptr;
iterator _endofstorage = nullptr;
};
}
test.cpp
test.cpp 是对模拟实现的测试
#include "vector.h"
// 针对单一类型的打印
//void Print(const bs::vector<int> v)
//{
// for (auto& e : v)
// {
// cout << e << " ";
// }
// cout << endl;
//}
//泛型打印 函数模板
template<class Container>
void Print(const Container& ch)
{
for (auto& e : ch)
{
cout << e << " ";
}
cout << endl;
}
void test_vector1()
{
bs::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
for (size_t i = 0; i < v.size(); i++)
{
cout << v[i] << " ";
}
cout << endl;
for (auto& e : v)
{
cout << e << " ";
}
cout << endl;
Print(v);
}
void test_vector2()
{
bs::vector<int> v;
v.push_back(1);
v.push_back(2);
Print(v);
v.pop_back();
v.pop_back();
v.pop_back();
}
void test_vector3()
{
bs::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
Print(v);
v.insert(v.begin(), 0);
Print(v);
v.insert(v.begin() + 3, 0);
Print(v);
int x;
cin >> x;
auto it = find(v.begin(), v.end(), x);
if (it != v.end())
{
//v.insert(it, x * 10);
////it在后面不能使用
////因为vector可能扩容进而导致it失效
////*it = 100;
//insert会返回新插入数据位置的迭代器，以解决迭代器失效
it = v.insert(it, x * 10);
*it = 100;
}
Print(v);
}
void test_vector4()
{
bs::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
Print(v);
v.erase(v.begin());
Print(v);
int x;
cin >> x;
auto it = find(v.begin(), v.end(), x);
if (it != v.end())
{
v.erase(it);
//it失效了，涉及数据的挪动，it被迫指向下一个数据
//VS对于vector失效的迭代器访问进行严格检查控制
//*it = 100;
}
Print(v);
}
void test_vector5()
{
//std::vector<int> v;
bs::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(4);
v.push_back(4);
v.push_back(5);
v.push_back(4);
Print(v);
//删除所有的偶数
auto it = v.begin();
while (it != v.end())
{
//if (*it % 2 == 0)
//{
// v.erase(it);
//}
////感觉写的没啥问题，但程序直接崩溃了
////因为it失效了
////VS对于vector失效的迭代器访问进行严格检查控制
//++it;
if (*it % 2 == 0)
{
//erase会返回下一个位置的迭代器
//解决了此处it失效的问题
it = v.erase(it);
}
else
{
++it;
}
}
Print(v);
//总结：insert和erase都会导致迭代器失效
}
void test_vector6()
{
bs::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
Print(v);
v.resize(8);
Print(v);
v.resize(20, 9);
Print(v);
v.resize(4);
Print(v);
}
void test_vector7()
{
bs::vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
v1.push_back(5);
Print(v1);
bs::vector<int> v2(v1);
Print(v2);
bs::vector<int> v3 = { 1, 2, 3, 4 ,5, 6 };
Print(v3);
bs::vector<int> v4(v3.begin() + 1, v3.end() - 1);
Print(v4);
string s("hello world");
bs::vector<int> v5(s.begin(), s.end());
Print(v5);
bs::vector<int> v6(10, 1); // 拿两个int的值构造
Print(v6);
bs::vector<int> v7(10u, 1u); // 拿两个size_t的值构造
Print(v7);
bs::vector<size_t> v8(10, 1); // 拿两个int的值构造
Print(v8);
bs::vector<size_t> v9(10u, 1u); // 拿两个size_t的值构造
Print(v9);
bs::vector<int> v10 = v3;
Print(v10);
}
void test_vector8()
{
bs::vector<string> v1;
v1.push_back("11111111111111111");
v1.push_back("11111111111111111");
v1.push_back("11111111111111111");
v1.push_back("11111111111111111");
v1.push_back("11111111111111111");
Print(v1);
}
int main()
{
test_vector7();
//cout << typeid(std::vector<int>::iterator).name() << endl;
//cout << typeid(bs::vector<int>::iterator).name() << endl;
//C++为了适应模板，对内置类型也设置了构造
//int i = 1;
//int j(2);
//int m = int();
//int n = int(3);
return 0;
}
ReverseIterator.h(反向迭代器)
template<class Iterator, class Ref, class Ptr>
struct ReverseIterator
{
typedef ReverseIterator<Iterator, Ref, Ptr> Self;
ReverseIterator(Iterator it)
:_it(it)
{}
Ref operator*()
{
Iterator tmp = _it;
--tmp;
return *tmp;
}
Ptr operator->()
{
&(operator*());
}
Self& operator++()
{
--_it;
return *this;
}
Self operator++(int)
{
Iterator tmp = _it;
--_it;
return tmp;
}
Self& operator--()
{
++_it;
return *this;
}
Self operator--(int)
{
Iterator tmp = _it;
++_it;
return tmp;
}
bool operator!=(const Self& s) const
{
return _it != s._it;
}
bool operator==(const Self& s) const
{
return _it == s._it;
}
Iterator _it;
};
反向迭代器的遍历
#include <iostream>
using namespace std;
#include "vector.h"
void test_vector()
{
bs::vector<int> v = { 1, 2, 3, 4 };
bs::vector<int>::reverse_iterator rit = v.rbegin();
while (rit != v.rend())
{
*rit += 1;
cout << *rit << " ";
++rit;
}
cout << endl;
const bs::vector<int> v1(v);
bs::vector<int>::const_reverse_iterator rit1 = v1.rbegin();
while (rit1 != v1.rend())
{
//*rit1 += 1;
cout << *rit1 << " ";
++rit1;
}
cout << endl;
}
int main()
{
test_vector();
return 0;
}
扫一扫
1377
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
