明天面试，半夜睡不着复习下STL底层实现

序列容器

1.string

class string{
  string(const char* str = ""){
    if(str == nulptr){
      assert(false);
      return;
    }
    _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* pstr = new char[strlen(s._str)+1];
        strcpy(pstr,s._str);
        delete[] _str;
        _str = pstr;
      }
      return *this;
    }

    ~string()
    {
      if(_str)
      {
        delete[] _str;
        _str = nullptr;
      }
    }

private:
  char* _str;
}

2.vector

是可变大小的数组

template<class T>
class vector
{
private:
iterator _start;
iterator _finish;
iterator _endofstorage;
public:
typedef T* iterator;
typedef const T* const_iterator;

iterator begin(){return _begin;}
iterator end(){return _finish;}
const_iterator cbegin()const{return _begin};
const_iterator cend()const{return _finish;}

vector()
  :_start(nullptr)
  ,_finish(nullptr)
  ,endofstorage(nullptr)
{}

vector(int n,const T& value = T())
  :_start(nullptr)
  ,_finish(nullptr)
  ,endofstorage(nullptr)
{
  reserve(n);
  while(n--)
  {
    push_back(value);
  }
}

vector(iterator first,iterator last)
{
  reserve(last - first);
  while(first != last)
  {
    push_back(*first);
    ++first;
  }
}

vector(const vector<T>& v)
  :_start(nullptr)
  ,_finish(nullptr)
  ,endofstorage(nullptr)
{
  reserve(v.capacity());
  iterator it = begin();
  const_iterator vit = v.cbegin();
  while(vit != v.cend())
  {
    *it++ = *vit++;
  }
}
vector<T>& operator=(vector<T>v)
{
  swap(v);
  return *this;
}

~vector()
{
  delete[] _start;
  _start = _finish = _endofstrage;
}

size_t size()const{return _finish - _start;}
size_t capacity()const{return _endofstrage - _start;}
bool empty()const{return _first = _finish;}

void reserve(size_t n)
{
  if(n>capacity())
  {
    

  }
}





};

3.list

底层是双向链表结构

template<class T>
struct ListNode
{
ListNode(const T& val)
  :_val(val)
  ,pPre(nullptr)
  ,_pNext(nullptr)
{}


T _val;
ListNode<T>* _pPre;
ListNode<T>* _pNext;
};

4.stack 

栈

template<class T>
class stack
{
public:
stack(){}
void push(const T& x) {_c.push_back(x);}
void pop() {_c.pop_back();}
T& top() {return _c.back();}
const T& top()const {return _c.back();}
size_t size()const {return _c.size();}
bool empty()const {return _c.empty();}
  
private:
std::vector<T>_c;
};

5.queue队列

队列

template<class T>
class queue
{
public:
queue() {}
void push(const T& x) {_c.push_back(x);}
void pop() {_c.pop_front();}
T& back() {return _c.back();}
const T& back()const {return _c.back();}
T& front() {return _c.front();}
const T& front()const {return _c.front();}
size_t size()const {return _c.size();}
bool empty()const {return _c.empty();}
private:
std::list<T> _c;
};

关联式容器

待续。。。