代码实现
/*vector类简单实现*/
#if 1
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
#include <vector>
#include <algorithm>
#include <crtdbg.h>
#include <assert.h>
#include <string.h>
namespace MyVector {
template<class T>
class vector {
public:
typedef T* itertor;
public:
vector()
: _start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{}
vector(int n, const T& val = T())
: _start(new T[n]) {
//memset(_start, val, sizeof(T)*n);
for (int i = 0; i < n; ++i) {
_start[i] = val;
}
_finish = _start + n;
_endofstorage = _finish;
}
template<class Iterator>
vector(Iterator first, Iterator last) {
// size_t n = last - first; //注意：一定不能减
Iterator it = first;
size_t n = 0;
while (it != last) {
n++;
++it;
}
_start = new T[n];
_finish = _start;
while (first != last) {
*_finish++ = *first++;
// _finish++;
// first++;
}
_endofstorage = _finish;
}
vector(const vector<T>& v)
: _start(new T[v.size()]) {
size_t n = v.size();
for (size_t i = 0; i < n; ++i) {
_start[i] = v[i];
}
_finish = _start + n;
_endofstorage = _finish;
}
vector<T>& operator=(vector<T> v) {
swap(v);
return *this;
}
~vector() {
if (_start) {
delete[] _start;
_start = _finish = _endofstorage = nullptr;
}
}
/
// 迭代器
itertor begin() {
return _start;
}
itertor end() {
return _finish;
}
itertor rbegin() {
return end();
}
itertor rend() {
return begin();
}
// 容量
size_t size()const {
return _finish - _start;
}
size_t capacity()const {
return _endofstorage - _start;
}
bool empty()const {
return _start == _finish;
}
void resize(size_t newsize, const T& val = T()) {
size_t oldsize = size();
if (newsize > oldsize) {
size_t oldcap = capacity();
if (newsize > oldcap)
reserve(newsize);
for (size_t i = oldsize; i < newsize; ++i) {
_start[i] = val;
}
}
_finish = _start + newsize;
}
void reserve(size_t newcap) {
size_t oldcap = capacity();
size_t count = size();
if (newcap > oldcap) {
// 1. 申请新空间
T* temp = new T[newcap];
if (_start) {
// 2. 拷贝元素
// 浅拷贝
// memcpy(temp, _start, sizeof(T)*count);
for (size_t i = 0; i < count; ++i) {
temp[i] = _start[i];
}
// 3. 释放旧空间
delete[] _start;
}
_start = temp;
_finish = _start + count;
_endofstorage = _start + newcap;
}
}
// 元素访问
T& front() {
// return *begin();
return _start[0];
}
const T& front()const {
return _start[0];
}
T& back() {
return *(_finish - 1);
}
const T& back()const {
return *(_finish - 1);
}
T& operator[](size_t index) {
assert(index < size());
return _start[index];
}
const T& operator[](size_t index)const {
assert(index < size());
return _start[index];
}
//
// 修改
void push_back(const T& value) {
if (_finish == _endofstorage) {
reserve(size() * 2 + 3);
}
*_finish = value;
++_finish;
}
void pop_back() {
if (empty())
return;
--_finish;
}
itertor insert(itertor pos, const T& value) {
if (pos < _start || pos > _finish)
return end();
if (_finish == _endofstorage)
reserve(2 * size());
// 将pos及其后续所有的元素整体往后搬移
itertor it = _finish;
while (it != pos) {
*it = *(it - 1);
--it;
}
*pos = value;
++_finish;
return pos;
}
itertor erase(itertor pos) {
if (pos < _start || pos >= _finish)
return end();
itertor it = pos + 1;
while (it != _finish) {
*(it - 1) = *it;
++it;
}
--_finish;
return pos;
}
void clear() {
_finish = _start;
}
void swap(vector<T>& v) {
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endofstorage, v._endofstorage);
}
//vector成员变量
private:
itertor _start;
itertor _finish;
itertor _endofstorage;
};
}
void TestVector1() {
MyVector::vector<int> v1;
// int int
MyVector::vector<int> v2(10, 5);
for (size_t i = 0; i < v2.size(); ++i)
cout << v2[i] << " ";
cout << endl;
int array[] = { 1, 2, 3, 4, 5 };
MyVector::vector<int> v3(array, array + 3);
for (auto e : v3)
cout << e << " ";
cout << endl;
MyVector::vector<int> v4(v3);
auto it = v4.begin();
while (it != v4.end()) {
cout << *it << " ";
++it;
}
cout << endl;
}
void TestVector4() {
MyVector::vector<int> v(10, 5);
for (auto e : v)
cout << e << " ";
cout << endl;
cout << "size=" << v.size() << endl;
cout << "capacity=" << v.capacity() << endl;
v.resize(20, 8);
for (auto e : v)
cout << e << " ";
cout << endl;
cout << "size=" << v.size() << endl;
cout << "capacity=" << v.capacity() << endl;
v.resize(30, 6);
for (auto e : v)
cout << e << " ";
cout << endl;
cout << "size=" << v.size() << endl;
cout << "capacity=" << v.capacity() << endl;
v.resize(10);
for (auto e : v)
cout << e << " ";
cout << endl;
cout << "size=" << v.size() << endl;
cout << "capacity=" << v.capacity() << endl;
v.resize(15, 0);
for (auto e : v)
cout << e << " ";
cout << endl;
cout << "size=" << v.size() << endl;
cout << "capacity=" << v.capacity() << endl;
}
void TestVector2() {
MyVector::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
cout << v.size() << endl;
cout << v.capacity() << endl;
for (auto e : v)
cout << e << " ";
cout << endl;
v.push_back(4);
cout << v.size() << endl;
cout << v.capacity() << endl;
for (auto e : v)
cout << e << " ";
cout << endl;
cout << v.front() << endl;
cout << v.back() << endl;
v.pop_back();
cout << v.front() << endl;
cout << v.back() << endl;
}
void TestVector3() {
MyVector::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
v.push_back(6);
for (auto e : v)
cout << e << " ";
cout << endl;
v.insert(v.begin(), 0);
for (auto e : v)
cout << e << " ";
cout << endl;
v.insert(v.begin() + 2, 22);
for (auto e : v)
cout << e << " ";
cout << endl;
auto it = v.begin();
while (it != v.end()) {
it = v.erase(it);
++it;
}
}
#include <list>
class String {
public:
String(const char* str = "") {
if (nullptr == str)
str = "";
_str = new char[strlen(str) + 1];
strcpy(_str, str);
}
String(const String& s)
: _str(new char[strlen(s._str) + 1]) {
strcpy(_str, s._str);
}
String& operator=(const String& s) {
if (this != &s) {
char* temp = new char[strlen(s._str) + 1];
strcpy(temp, s._str);
delete[] _str;
_str = temp;
}
return *this;
}
~String() {
if (_str) {
delete[] _str;
_str = nullptr;
}
}
private:
char* _str;
};
void Teststdvector() {
vector<String> v;
v.push_back("1111");
v.push_back("1111");
v.push_back("2222");
v.push_back("3333");
}
void TestMyvector() {
MyVector::vector<String> v;
v.push_back("1111");
v.push_back("2222");
v.push_back("3333");
v.push_back("4444");
}
int main() {
//int array[10];
//memset(array, 5, sizeof(array));
/*int array[] = { 1, 2, 3, 4 };
vector<int> v1(array, array + sizeof(array) / sizeof(array[0]));
list<int> L{ 1, 2, 3 };
vector<int> v2(L.begin(), L.end());*/
// TestVector1();
// TestVector2();
// TestVector3();
// TestVector4();
// Teststdvector();
Testvector();
_CrtDumpMemoryLeaks();
return 0;
}
#endif
这段代码是一个简化版的 vector 类的实现，模拟了 C++ 标准库中 std::vector 的核心功能。vector 是一个模板类，用于存储元素的动态数组，可以根据需要动态地增加或减少其大小。下面是对代码中每个部分的简要解释：
类模板声明
template<class T>
class vector {
这里定义了一个模板类 vector，T 是元素类型的占位符，允许 vector 存储任意类型的元素。
成员变量
typedef T* itertor;
itertor _start; // 指向数组首元素的指针
itertor _finish; // 指向数组最后一个元素的下一个位置的指针
itertor _endofstorage; // 指向数组分配的存储空间尾部的下一个位置的指针
vector内的迭代器底层是T类型的指针类型。
_start相当于string类的字符指针。
_finish相当于string类的size。
_endofstorage相当于string类的capacity。
构造函数
默认构造函数、带参数的构造函数、范围构造函数、拷贝构造函数和析构函数用于初始化 vector 实例和清理资源。
范围构造函数特别注意不直接使用迭代器相减来确定元素数量，以支持不支持随机访问的迭代器。
默认构造函数
vector()
: _start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{}
所有的指针都指向空。
带参数的构造函数
vector(int n, const T& val = T())
: _start(new T[n]) {
for (int i = 0; i < n; ++i) {
_start[i] = val;
}
_finish = _start + n;
_endofstorage = _finish;
}
使用默认的构造器给_start开辟空间，再依次赋值为val，接着修正_finish和_endofstorage。
可以理解为，_start相当于string类的字符指针。
_finish相当于string类的size。
_endofstorage相当于string类的capacity。
范围构造函数
template<class Iterator>
vector(Iterator first, Iterator last) {
// size_t n = last - first; //注意：一定不能减
Iterator it = first;
size_t n = 0;
while (it != last) {
n++;
++it;
}
_start = new T[n];
_finish = _start;
while (first != last) {
*_finish++ = *first++;
// _finish++;
// first++;
}
_endofstorage = _finish;
}
注意，对于 vector 的构造函数，使用了模板来允许接受任意类型的迭代器 Iterator 作为参数。这里不支持迭代器相减计算距离，原因是并不是所有的迭代器类型都支持相减计算距离。
随机访问迭代器（Random Access Iterator）：支持直接相减操作，因为它们可以在常数时间内访问序列中的任何元素。vector 和 deque 容器提供的迭代器就是随机访问迭代器。
双向迭代器（Bidirectional Iterator）、前向迭代器（Forward Iterator）、输入迭代器（Input Iterator） 和 输出迭代器（Output Iterator）：不支持相减操作，因为它们只能单向移动（或者在双向迭代器的情况下，前后移动），无法直接计算两个迭代器之间的距离。
根据迭代器范围来构造对象，首先计算迭代器范围内有多少个元素，计算的方法是迭代器依次++。计算好元素个数之后先开辟对应的空间大小。接着通过迭代器依次赋值。修正_finish和_endofstorage。
拷贝构造函数
vector(const vector<T>& v)
: _start(new T[v.size()]) {
size_t n = v.size();
for (size_t i = 0; i < n; ++i) {
_start[i] = v[i];
}
_finish = _start + n;
_endofstorage = _finish;
}
std::vector<int> vec6(vec4)括号里面传入的是vector类型，属于拷贝构造函数。如上述代码所示，利用vec4构造vec6对象。此时vec6对象元素的数据类型是int类型，这个int类型就是上面代码的T类型，当然，和vec4里面的数据类型是相同的。
析构函数
~vector() {
if (_start) {
delete[] _start;
_start = _finish = _endofstorage = nullptr;
}
}
赋值操作符
vector<T>& operator=(vector<T> v) {
swap(v);
return *this;
}
通过拷贝-交换技巧实现赋值操作符，确保异常安全和自赋值安全。swap函数是vector类内部定义的函数。
迭代器相关方法
提供 begin() 和 end() 方法返回指向首元素和尾后位置的迭代器。
rbegin() 和 rend() 方法在此实现中不是反向迭代器的正确实现，它们只是简单地返回了 end() 和 begin()。
// 迭代器
itertor begin() {
return _start;
}
itertor end() {
return _finish;
}
itertor rbegin() {
return end();
}
itertor rend() {
return begin();
}end()函数返回的是_finish迭代器，_finish迭代器指向最后一个元素的下一个位置。
容量相关方法
size(), capacity(), empty(), resize(), reserve() 方法用于查询和修改 vector 的大小和容量。
// 容量
size_t size()const {
return _finish - _start;
}
size_t capacity()const {
return _endofstorage - _start;
}
bool empty()const {
return _start == _finish;
}随机访问迭代器（Random Access Iterator）：支持直接相减操作，因为它们可以在常数时间内访问序列中的任何元素。vector 和 deque 容器提供的迭代器就是随机访问迭代器。
因此在vector内部可以直接对指针进行相减操作，计算出来的就是指针之间的元素个数。
void resize(size_t newsize, const T& val = T()) {
size_t oldsize = size();
if (newsize > oldsize) {
size_t oldcap = capacity();
if (newsize > oldcap)
reserve(newsize);
for (size_t i = oldsize; i < newsize; ++i) {
_start[i] = val;
}
}
_finish = _start + newsize;
}
计算当前大小：首先通过 size() 方法获取当前容器中元素的数量。
比较新旧大小：
如果 newsize 大于 oldsize（当前容器的大小），则需要扩展容器。
如果 newsize 小于或等于 oldsize，代码当前版本中没有显式处理这种情况，实际上通过设置 _finish = _start + newsize; 来减少容器的大小，多余的元素虽在逻辑上被“丢弃”，但它们并没有被销毁。
扩展容器（如果需要）：
首先检查是否需要扩展底层存储空间，即 newsize 是否大于当前容器的容量（oldcap）。如果是，调用 reserve(newsize) 来分配更大的存储空间。
然后，使用循环从 oldsize 开始，直到 newsize 结束，为新添加的位置赋予 val 值。这确保了扩展部分的元素被初始化。
更新 _finish：最后，无论容器是被扩展还是缩小，都通过设置 _finish = _start + newsize; 来更新指向容器中最后一个有效元素之后位置的指针。这样，容器的大小被改变为 newsize。
void reserve(size_t newcap) {
size_t oldcap = capacity();
size_t count = size();
if (newcap > oldcap) {
// 1. 申请新空间
T* temp = new T[newcap];
if (_start) {
// 2. 拷贝元素
// 浅拷贝
// memcpy(temp, _start, sizeof(T)*count);
for (size_t i = 0; i < count; ++i) {
temp[i] = _start[i];
}
// 3. 释放旧空间
delete[] _start;
}
_start = temp;
_finish = _start + count;
_endofstorage = _start + newcap;
}
}这段代码是 vector 类中 reserve 方法的实现，它的主要目的是确保 vector 拥有至少 newcap 个元素的容量。如果当前容量小于请求的新容量，则会分配更大的存储空间并移动现有元素到新空间。
获取当前容量和元素数量：
oldcap 存储当前容量，通过 capacity() 方法获取。
count 存储当前元素的数量，通过 size() 方法获取。
检查是否需要扩容：
如果 newcap 大于 oldcap，则需要进行扩容。如果不是，什么都不做，即函数直接返回，保持现状。
申请新空间：
使用 new T[newcap] 申请一个新的元素数组，大小为请求的新容量 newcap。
拷贝现有元素到新空间：
如果 _start 不是 nullptr（即当前容器非空），则需要将现有元素从旧空间复制到新空间。
使用循环遍历当前所有元素，对每个元素使用拷贝赋值操作进行复制。这里的复制保证了如果类型 T 有特殊的拷贝语义（例如深拷贝需要的操作），那么这些语义会被正确处理。
注释中提到的“浅拷贝”和 memcpy 是不正确的选择。对于类类型 T，应使用循环拷贝来确保正确的语义。
释放旧空间：
使用 delete[] _start 释放原有的存储空间。
更新内部指针以反映新状态：
_start 更新为指向新分配的存储空间的开始。
_finish 更新为新空间中最后一个元素之后的位置，即 _start + count。
_endofstorage 更新为新空间的末尾，即 _start + newcap。
元素访问方法
front(), back(), operator[] 提供对 vector 元素的访问。
// 元素访问
T& front() {
// return *begin();
return _start[0];
}
const T& front()const {
return _start[0];
}
T& back() {
return *(_finish - 1);
}
const T& back()const {
return *(_finish - 1);
}
T& operator[](size_t index) {
assert(index < size());
return _start[index];
}
const T& operator[](size_t index)const {
assert(index < size());
return _start[index];
}
修改方法
包括 push_back(), pop_back(), insert(), erase(), clear() 等方法，用于修改 vector 的内容。
swap() 方法用于交换两个 vector 实例的内容。
// 修改
void push_back(const T& value) {
if (_finish == _endofstorage) {
reserve(size() * 2 + 3);
}
*_finish = value;
++_finish;
}
void pop_back() {
if (empty())
return;
--_finish;
}
itertor insert(itertor pos, const T& value) {
if (pos < _start || pos > _finish)
return end();
if (_finish == _endofstorage)
reserve(2 * size());
// 将pos及其后续所有的元素整体往后搬移
itertor it = _finish;
while (it != pos) {
*it = *(it - 1);
--it;
}
*pos = value;
++_finish;
return pos;
}
itertor erase(itertor pos) {
if (pos < _start || pos >= _finish)
return end();
itertor it = pos + 1;
while (it != _finish) {
*(it - 1) = *it;
++it;
}
--_finish;
return pos;
}
void clear() {
_finish = _start;
}
void swap(vector<T>& v) {
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endofstorage, v._endofstorage);
}push_back：
向 vector 的末尾添加一个新元素。如果当前没有足够的存储空间（即 _finish == _endofstorage），则通过调用 reserve 来扩展容量，保证有足够的空间存储新元素。新元素被复制到 _finish 指向的位置，然后 _finish 自增以指向新的末尾。
pop_back：
从 vector 的末尾移除一个元素。这是通过简单地将 _finish 指针递减实现的。如果 vector 为空（即 _start == _finish），则不执行任何操作。
insert：
在指定位置 pos 前面插入一个新元素。首先检查 pos 是否在合法范围内。如果容量不足以插入新元素，则通过调用 reserve 扩展容量。然后，从 vector 的末尾开始，将元素向后移动一位，直到达到插入位置，最后在 pos 位置放入新元素并更新 _finish。
erase：
从 vector 中移除位于 pos 的元素。该操作通过将从 pos + 1 开始的所有元素向前移动一位来实现，并递减 _finish 指针。如果 pos 不在合法范围内，函数返回 end()，即 _finish。
clear：
清空 vector 中的所有元素，实现上通过将 _finish 设置为 _start 实现，逻辑上移除所有元素。这不会释放已分配的内存。
swap：
交换当前 vector 与另一个 vector 的内容。这是通过对 _start、_finish 和 _endofstorage 使用 std::swap 函数实现的。这个操作是非常高效的，因为它只涉及指针的交换，而不需要元素的逐个复制或移动。
反向迭代器探究
/*vector反向迭代器探究*/
#if 1
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
#include <vector>
#include <algorithm>
#include <crtdbg.h>
void TestVector14() {
vector<int> v={1,2,3,4,5};
auto it=v.rbegin();
while(it!=v.rend()){
cout<<*it<<endl;
it++;
}
}
int main() {
TestVector14();
return 0;
}
#endif
反向迭代器中rbegin指向的是最后一个元素后一个位置，但是解引用的时候，它能够输出最后一个元素的位置，我认为这是编译器做出的自动优化，在反向迭代器中，解引用相当于调用迭代器++后的解引用。
针对于自定义类型的解引用
class Date{
private:
int _year;
int _month;
int _day;
public:
Date()
:_year(2024)
,_month(1)
,_day(1)
{}
void Show(){
cout<<_year<<"-"<<_month<<"-"<<_day<<endl;
}
};
int main() {
MyVector::vector<Date>v;
v.push_back(Date());
v.push_back(Date());
v.push_back(Date());
v.push_back(Date());
auto it=v.begin();
while(it!=v.end()){
it->Show();
it++;
}
return 0;
}
#endif
我们定义的vector类中并没有重载->的实现，但我们依旧可以通过迭代器->的解引用访问对象的成员属性。
结尾
最后，感谢您阅读我的文章，希望这些内容能够对您有所启发和帮助。如果您有任何问题或想要分享您的观点，请随时在评论区留言。
同时，不要忘记订阅我的博客以获取更多有趣的内容。在未来的文章中，我将继续探讨这个话题的不同方面，为您呈现更多深度和见解。
谢谢您的支持，期待与您在下一篇文章中再次相遇！
