序文
皆さんお久しぶりです、今日はSTLでベクターコンテナをシミュレーションして実現してみます。
シミュレーション
クラスフレームワーク
物理空間は連続しているため、ネイティブ ポインタをイテレータとして直接使用することを選択し、ベクトル コンテナ全体の容量とサイズは 3 つのイテレータを減算することで表現されます。理解できない場合は、戻って見てください。
namespace teacher
{
template<class T>
class vector
{
public:
//原生指针作为迭代器
typedef T* iterator;
typedef const T* const_iterator;
//容量和大小
int capacity() const
{
return _end_of_storage - _start;
}
int size() const
{
return _finish - _start;
}
//迭代器
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
private:
iterator _start = nullptr;
iterator _finish = nullptr;
iterator _end_of_storage = nullptr;
};
}
建設と破壊
コンストラクタでもコピーコンストラクタでも要素に一つ一つ値を代入する必要があるので、最初にpush_back関数を書いて他のコンストラクタで呼び出します。
さらに、C++ では、テンプレート内の関数でテンプレートを使用できます。
匿名オブジェクトのライフサイクルはその行のみですが、const T& x で変更するとライフサイクルは x の終わりまで延長されることに注意してください。
vector() {
};
vector(size_t n, const T& val = T())
{
reserve(n);
for (int 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);
}
}
template<class InputIterator>
vector(InputIterator first, InputIterator last)
{
while (first != last)
{
push_back(*first);
++first;
}
}
vector(const vector<T>& v)
{
vector<T> tmp(v.begin(),v.end());
swap(tmp);
}
~vector()
{
delete[] _start;
_start = _finish = _end_of_storage = nullptr;
}
void push_back(const T& x)
{
if (_finish == _end_of_storage)
{
reserve(capacity() == 0 ? 4 : capacity() * 2);
}
*_finish = x;
++_finish;
}
ディープコピーとシャローコピーの問題
ベクトル メモリに他の場所へのポインタがある場合、単純なバイト copy( 值拷贝) によって両方のベクトルが同じ場所を指すようになります。この問題は非常に深刻です。同じ場所を指している場合は、複数回破棄する必要があり、プログラムがクラッシュするためです。まず、深いコピーと浅いコピーの問題を解決しましょう。
以下の図に示す展開ロジックでは、ベクトルの各要素のスペースが再び開かれたことがわかります。これにより、浅いコピーの問題を回避できます。
void reserve(size_t n)
{
size_t sz = size();
// 容量不够才进行扩容
if (n > capacity())
{
T* tmp = new T[n];
//拷贝原来的内容
if (_start)
{
for (int i = 0; i < sz; i++)
{
tmp[i] = _start[i];
}
delete[] _start;
}
}
_start = tmp;
_finish = _start + sz;
_end_of_storage = _start + n;
}
しかし、このように書くことには非常に深刻な問題もあります。つまり、tmp[i] = _start[i] このステップは実際には浅いコピーです。つまり、図に示されている問題が発生します
。この問題を解決するには、深いコピーを手動で記述する必要があります。赋值重载。
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_end_of_storage, v._end_of_storage);
}
vector<T> operator=(vector<T> v)
{
//v是临时对象，传过来完成了拷贝构造，走了push back的逻辑，因此再交换是开了新空间的。
swap(v);
return *this;
}
[ ] オーバーロード
データを読み取るために配列の [] に慣れており、ベクトルのメモリは連続しているため、[] をオーバーロードします。
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos) const
{
assert(pos < size());
return _start[pos];
}
挿入して消去する
ここではイテレータがあり、npos の問題を考慮する必要がないため、ロジックは基本的に string のシミュレーション実装と同じです。
ここではイテレータが返されていますが、これら 2 つの関数を使用した後は、pos は無効であると考えて、pos をもう使用しないことをお勧めします。
iterator insert(iterator pos, const T& val)
{
if (_finish == _end_of_storage)
{
size_t len = pos - _start;
reserve(capacity() == 0 ? 4 : capacity() * 20);
pos = _start + len;
//扩容后更新pos 防止pos失效
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--end;
}
*pos = val;
++_finish;
return pos;
}
iterator erase()
{
iterator start = pos + 1;
while (start != _finish)
{
*(start - 1) = *start;
++start;
}
--_finish;
return pos;
}
プッシュポップ、空、サイズ変更
これら 3 つの関数は比較的単純です。
bool empty()
{
return _start == _finish;
}
void pop_back()
{
assert(!empty());
--_finish;
}
void resize(size_t n,T val = T())
{
if (n < size())
{
_finish = _start + n;
}
else
{
if (n > capacity())
{
reserve(n);
}
while (_finish != _start + n)
{
*_finish = val;
++_finish;
}
}
}
エピローグ
以上がこの記事の全内容です。何かを得ることができれば幸いです。また次回お会いしましょう