myvector.h
#pragma once
#include<assert.h>
#include<iostream>
#include<vector>
using namespace std;
namespace bit {
template<class T>
//必须使用typename场景\
template<typename T>与template<class T>一般情况下这两个通用,但有一个特例,就是当 T 是一个类,而这个类又有子类(假设名为 innerClass) 时,应该用 template<typename>:\
typename T::innerClass myInnerObject; 这里的 typename 告诉编译器,T::innerClass 是一个类,程序要声明一个 T::innerClass 类的对象,而不是声明 T 的静态成员,而 typename 如果换成 class 则语法错误。
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
//const指针得到const迭代器,非const得非const迭代器
const_iterator begin()const
{
return _start;
}
const_iterator end()const
{
return _end;
}
iterator begin()
{
return _start;
}
iterator end()
{
return _end;
}
// 类模板的成员函数
// 函数模板 -- 目的支持任意容器的迭代器区间初始化
template<class InputIterator>
vector(InputIterator it_begin, InputIterator it_end)
{
while (it_begin != it_end)
{
push_back(*(it_begin++));
}
}
vector() = default;
vector(size_t n, const T& val = T())
{
reserve(n);//尽量一次性开空间
for (size_t i = 0; i < n; i++)//和n同一类型大小
push_back(val);
}
vector(initializer_list<T> il)
{
reserve(il.size());//要push_back,insert等频繁插入数据就想优化一次插入
for (auto& e : il)//初始列表支持迭代器就支持范围for从头往后
{
push_back(e);
}
}
vector(int n, const T& val = T())//要有int版本的不然传两个数字为int与迭代器模板函数混淆
{
reserve(n);//尽量一次性开空间
for (int i = 0; i < n; i++)//和n同一类型大小
push_back(val);
}
vector(const vector<T>& v)
{
//拷贝构造实现深度拷贝
reserve(v.capacity());
for (auto& e : v)
{
push_back(e);
}
}
void swap(vector<T>&v)
{
std::swap(this->_start, v._start);
std::swap(this->_end, v._end);
std::swap(this->_end_of_storage, v._end_of_storage);
}
vector<T>& operator=(vector<T> v)//现代写法,可以传参的拷贝实参,深拷贝再交换自动析构
{
swap(v);
return *this;//可以连续运算的返回其值
}
~vector()
{
if (_start)
{
delete[] _start;
_start = _end_of_storage = _end = nullptr;
}
}
void reserve(size_t n)//size_t
{
//不能用memcpy拷贝新旧空间,浅拷贝的空间会析构两次
if (n > capacity())
{
size_t oldsizes = size();
iterator new_start = new T[n];
for (size_t i = 0; i < oldsizes; i++)
{
new_start[i] = _start[i];
}
delete[] _start;
_start = new_start;
_end = _start + oldsizes;
_end_of_storage = _start+n;
}
}
size_t capacity()const //仅访问的允许常this指针
{
return _end_of_storage - _start;
}
size_t size()const
{
return _end - _start;
}
T& operator[](size_t n)
{
assert(n < size());//访问越界检查
return _start[n];
}
const T& operator[](size_t n)const//常指针访问返回常引用[]
{
assert(n < this->size());
return _start[n];
}
void push_back(const T& val)
{
//if (_end == _end_of_storage)
//{
// size_t capacity = capacity() == 0 ? 4 : 2 * capacity();
// reserve(capacity);
//}
//*_end++ = val;//后置++优先级大于解引用
insert(end(), val);
}
void popback()
{
assert(size());
--_end;
}
iterator insert(iterator pos, const T& val)//pos迭代器不能传引用,不然外部不能拷贝传参临时变量引用,insert(t.begin()->传的临时变量不能传普通引用
{//这里形参如果是引用的话,则编译时会报错,因为v.begin()返回的是一个临时变量,自定义类型传值拷贝返回,返回临时变量再拷贝给接收的,是一个右值,它不能赋值给一个非const的引用:
assert(pos <= _end);
assert(pos >= _start);
if (_end == _end_of_storage)
{
size_t len = pos - _start;
size_t capacity = this->capacity() == 0 ? 4 : this->capacity() * 2;
reserve(capacity);
pos = _start + len;//内部迭代器更新
}
iterator end = _end-1;
while (end >= pos)
{
*(end + 1)=*end;
end--;
}
_end++;
*pos = val;
return pos;
}
iterator erase(iterator pos)
{
assert(pos < _end);
assert(pos >= _start);
iterator pos_i = pos+1;
while (pos_i < _end)
*(pos_i - 1) = *pos_i++;
--_end;
return pos;
}
private://在类型定义后写
iterator _start = nullptr;
iterator _end = nullptr;
iterator _end_of_storage = nullptr;
};
}
void test01()
{
bit::vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
v1.push_back(5);
size_t size = v1.size();
for (int i = 0; i < size; i++)
cout << v1[i] << endl;
for (const auto& e : v1)
cout << e << endl;
bit::vector<int>::iterator it_begin = v1.begin();
bit::vector<int>::iterator it_end = v1.end();
for (; it_begin < it_end; it_begin++)
cout << *it_begin << endl;
}
void test02()
{
bit::vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
v1.push_back(5);
v1.insert(v1.begin(), 0);
size_t size = v1.size();
for (int i = 0; i < size; i++)
cout << v1[i] << " ";
cout << endl;
for (const auto& e : v1)
cout << e << " ";
cout << endl;
v1.erase(v1.end() - 1);
bit::vector<int>::iterator it_begin = v1.begin();
bit::vector<int>::iterator it_end = v1.end();
for (; it_begin < it_end; it_begin++)
cout << *it_begin << " ";
cout << endl;
int x;
cin >> x;
bit::vector<int>::iterator pos_x = find(v1.begin(), v1.end(), x);//模板实例化才能找类域
if (pos_x != v1.end())
{
pos_x =v1.insert(pos_x, 1000);// 建议失效后迭代器不要访问。除非赋值 更新 一下这个失效的迭代器
cout << *pos_x << endl;
}
for (const auto& e : v1)
cout << e << " ";
cout << endl;
}
void test03()
{
std::vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
v1.push_back(5);
int x;
cin >> x;
std::vector<int>::iterator it = find(v1.begin(), v1.end(), x);
if (it != v1.end())
{
// erase it以后,it是否失效呢?失效
it = v1.erase(it);
if (it != v1.end())
cout << *it << endl;
}
cout << typeid(it).name() << endl;
}
void test_vector4()
{
std::vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
v1.push_back(5);
std::vector<int>::iterator it = v1.begin();
while (it < v1.end())//用迭代器遍历并删除偶数
{
if (*it % 2 == 0)
{
it = v1.erase(it);
}
else
++it;
}
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
}
void test_vector5()
{
bit::vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
v1.push_back(5);
bit::vector<int> v2(v1);
for (auto e : v2)
{
cout << e << " ";
}
cout << endl;
bit::vector<int> v3;
v3.push_back(10);
v3.push_back(20);
v3.push_back(30);
v1 = v3;
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
}
void test_vector07()
{
int i = int();
int k(2);
int f = { 3 };
int h = int(7);
int j{ 1 };
}
C++vector部分实现及感悟
于 2024-06-04 09:01:09 首次发布