框架
#pragma once
#include <assert.h>
#include <iostream>
#include <string>
namespace bit
{
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
vector();
vector(const vector<T>& v);
template<class InputIterator>
vector(InputIterator first, InputIterator end);
void swap(vector<T>& v);
vector<T>& operator=(vector<T> v);
vector(size_t n, const T& val = T());
vector(int n, const T& val = T());
~vector();
iterator begin();
iterator end();
const iterator begin() const;
const iterator end() const;
size_t size();
size_t capacity();
const size_t size() const;
const size_t capacity() const;
void reserve(size_t n);
void resize(size_t n,const T& val=T());
T& operator[](size_t pos);
const T& operator[](size_t pos) const;
void push_back(const T& val);
void pop_back();
void insert(iterator pos,const T& val);
iterator erase(iterator pos);
bool empty();
private:
iterator _start = nullptr;
iterator _finish = nullptr;
iterator _endofstorage = nullptr;
};
template<class T>
void print_vector(const vector<T>& v);
}
构造函数
vector(){}
//vector的拷贝构造
vector(const vector<T>& v)
{
reserve(v.capacity());
for (auto& e : v)
{
push_back(e);
}
}
//迭代器区间构造
//“一个类模板中可以嵌套函数模板”
template<class InputIterator>
vector(InputIterator first, InputIterator end)
{
while (first != end)
{
push_back(*first);
first++;
}
}
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endofstorage, v._endofstorage);
}
//v3=v1——将v1赋值给v3
vector<T>& operator=(vector<T> v)
//v1传值传参,v是v1的拷贝,不会修改v1本身
{
swap(v);
return *this;
}
//用n个val构造vector
vector(size_t n, const T& val = T())
{
reserve(n);
for (size_t i = 0; i < n; i++)
{
push_back(val);
}
}
vector(int n, const T& val = T())
{
reserve(n);
for (int i = 0; i < n; i++)
{
push_back(val);
}
}
析构函数
~vector()
{
delete[] _start;
_start = _finish = _endofstorage = nullptr;
}
begin()&&end()
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const iterator begin() const
{
return _start;
}
const iterator end() const
{
return _finish;
}
size()&&capacity()
size_t size()
{
return _finish - _start;
}
size_t capacity()
{
return _endofstorage - _start;
}
const size_t size() const
{
return _finish - _start;
}
const size_t capacity() const
{
return _endofstorage - _start;
}
reserve()&&resize()
//预留可以存储n个数据空间
//reserve如果比当前的capacity大,就扩容
//比他小就不扩容
void reserve(size_t n)
{
size_t oldsize = size();
if (n > capacity())
{
//先开辟空间new临时n
T* tmp = new T[n];
//复制数据
//memcpy是浅拷贝
//memcpy(tmp, _start, size() * sizeof(T));
for (size_t i = 0; i < oldsize; i++)
{
tmp[i] = _start[i];
}
//释放旧的空间
delete[] _start;
//更新新的
_start = tmp;
_finish = tmp + oldsize;
_endofstorage = tmp + n;
}
}
void resize(size_t n,const T& val=T())
{
if (n > size())
{
//插入val
reserve(n);
while (_finish < _start + n)
{
*_finish = val;
_finish++;
}
}
else
{
_finish = _start + n;
}
}
operator[]
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos) const
{
assert(pos < size());
return _start[pos];
}
push_back()
void push_back(const T& val)
{
insert(end(), val);
//if (_finish == _endofstorage)
//{
// size_t old_size = size();
// size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
// //扩容
// reserve(newcapacity);
// //T* tmp = new T[newcapacity];
// //memcpy(tmp, _start, size() * sizeof(T));
// //delete[] _start;
// //_start = tmp;
// //_finish = tmp + old_size;//?
// _finish = tmp + size();//?
// 【问题一:此时注意:size是通过start和finish计算的,此时start更新了,所以会导致出现问题】
// //_endofstorage = tmp + newcapacity;
//}
//*_finish = val;
//++_finish;
}
pop_back()
//【pop_back】尾删
void pop_back()
{
iterator pos = end() - 1;
erase(pos);
/*assert(!empty());
--_finish;*/
}
insert()
void insert(iterator pos,const T& val)
//注意这里与string中不同,string中pos用的是下标
//但是vector用的是迭代器——指针(一个一个单位的内存编号是地址,不可能为0)
{
//判断位置是否合法
assert(pos>=_start);
assert(pos <= _finish);
//判断是否需要扩容
if (size() == capacity())
{
size_t len = pos - _start;
size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
reserve(newcapacity);
//【insert迭代器失效】——reserve之后pos的位置没有更新
pos = _start + len;
}
iterator it = _finish - 1;
while (it >= pos)
{
*(it + 1) = *it;
--it;
}
*pos = val;
_finish++;
}
erase()
iterator erase(iterator pos)
{
assert(pos >= _start);
assert(pos < _finish);
iterator it = pos + 1;
while (it <= _finish - 1)
{
*(it - 1) = *it;
*it++;
}
_finish--;
return pos;
}
empty()
bool empty()
{
return _start == _finish;
}
完整代码
#pragma once
#include <assert.h>
#include <iostream>
#include <string>
namespace bit
{
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
vector()
{
}
//vector的拷贝构造
vector(const vector<T>& v)
{
reserve(v.capacity());
for (auto& e : v)
{
push_back(e);
}
}
//迭代器区间构造
//“一个类模板中可以嵌套函数模板”
template<class InputIterator>
vector(InputIterator first, InputIterator end)
{
while (first != end)
{
push_back(*first);
first++;
}
}
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endofstorage, v._endofstorage);
}
//v3=v1——将v1赋值给v3
vector<T>& operator=(vector<T> v)
//v1传值传参,v是v1的拷贝,不会修改v1本身
{
swap(v);
return *this;
}
//用n个val构造vector
vector(size_t n, const T& val = T())
{
reserve(n);
for (size_t i = 0; i < n; i++)
{
push_back(val);
}
}
vector(int n, const T& val = T())
{
reserve(n);
for (int i = 0; i < n; i++)
{
push_back(val);
}
}
//【析构函数】
~vector()
{
delete[] _start;
_start = _finish = _endofstorage = nullptr;
}
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const iterator begin() const
{
return _start;
}
const iterator end() const
{
return _finish;
}
size_t size()
{
return _finish - _start;
}
size_t capacity()
{
return _endofstorage - _start;
}
const size_t size() const
{
return _finish - _start;
}
const size_t capacity() const
{
return _endofstorage - _start;
}
//预留可以存储n个数据空间
//reserve如果比当前的capacity大,就扩容
//比他小就不扩容
void reserve(size_t n)
{
size_t oldsize = size();
if (n > capacity())
{
//先开辟空间new临时n
T* tmp = new T[n];
//复制数据
//memcpy是浅拷贝
//memcpy(tmp, _start, size() * sizeof(T));
for (size_t i = 0; i < oldsize; i++)
{
tmp[i] = _start[i];
}
//释放旧的空间
delete[] _start;
//更新新的
_start = tmp;
_finish = tmp + oldsize;
_endofstorage = tmp + n;
}
}
void resize(size_t n,const T& val=T())
{
if (n > size())
{
//插入val
reserve(n);
while (_finish < _start + n)
{
*_finish = val;
_finish++;
}
}
else
{
_finish = _start + n;
}
}
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos) const
{
assert(pos < size());
return _start[pos];
}
void push_back(const T& val)
{
insert(end(), val);
//if (_finish == _endofstorage)
//{
// size_t old_size = size();
// size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
// //扩容
// reserve(newcapacity);
// //T* tmp = new T[newcapacity];
// //memcpy(tmp, _start, size() * sizeof(T));
// //delete[] _start;
// //_start = tmp;
// //_finish = tmp + old_size;//?
// _finish = tmp + size();//?
// 【问题一:此时注意:size是通过start和finish计算的,此时start更新了,所以会导致出现问题】
// //_endofstorage = tmp + newcapacity;
//}
//*_finish = val;
//++_finish;
}
//【pop_back】尾删
void pop_back()
{
iterator pos = end() - 1;
erase(pos);
/*assert(!empty());
--_finish;*/
}
void insert(iterator pos,const T& val)
//注意这里与string中不同,string中pos用的是下标
//但是vector用的是迭代器——指针(一个一个单位的内存编号是地址,不可能为0)
{
//判断位置是否合法
assert(pos>=_start);
assert(pos <= _finish);
//判断是否需要扩容
if (size() == capacity())
{
size_t len = pos - _start;
size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
reserve(newcapacity);
//【insert迭代器失效】——reserve之后pos的位置没有更新
pos = _start + len;
}
iterator it = _finish - 1;
while (it >= pos)
{
*(it + 1) = *it;
--it;
}
*pos = val;
_finish++;
}
iterator erase(iterator pos)
{
assert(pos >= _start);
assert(pos < _finish);
iterator it = pos + 1;
while (it <= _finish - 1)
{
*(it - 1) = *it;
*it++;
}
_finish--;
return pos;
}
bool empty()
{
return _start == _finish;
}
private:
iterator _start = nullptr;
iterator _finish = nullptr;
iterator _endofstorage = nullptr;
};
template<class T>
void print_vector(const vector<T>& v)
{
for (size_t i = 0; i < v.size(); i++)
{
std::cout << v[i] << " ";
}
std::cout << std::endl;
【错误写法】vector<T>::const_iterator it = v.begin();
【原因】——此时vector<T>还未实例化,所以编译器不敢找const_iterator
【正确写法】typename——也是typename与class之间的唯一区别
//typename vector<T>::const_iterator it = v.begin();
//
【typename vector<T>::const_iterator it = v.begin();】——typename告诉编译器vector<T>::const_iterator是一个类型
先去编译,编译结束之后,实例化之后,再去找
auto it = v.begin();
//while (it != v.end())
//{
// std::cout << *it << " ";
// it++;
//}
//std::cout << std::endl;
//for (auto& e : v)
//{
// std::cout << e << " ";
//}
//std::cout << std::endl;
}
}