worked some more on vectors

src/test.cc

@@ -10,27 +10,19 @@ int main(void) {
 
   cout << "\n\nTest vecteur\n";
 
-  vector<char> testvec;
-  testvec.push_back('C');
-  testvec.push_back('a');
-  testvec.push_back('r');
-  testvec.push_back('t');
-  testvec.push_back('i');
-  testvec.push_back('e');
-  testvec.push_back('r');
+  vector<char> testvec{'C', 'a', 'r', 't', 'i', 'e', 'r'};
 
-  for(size_t i = 0; i < testvec.size(); ++i) {
+  for (size_t i = 0; i < testvec.size(); ++i) {
     cout << testvec[i] << " ";
   }
   cout << std::endl;
 
-
   cout << "\n\nTest list\n";
 
   list<char> test{'C', 'a', 'r', 't', 'i', 'e', 'r'};
 
   for (auto c : test)
-    cout << c << "  ";
+    cout << c << " ";
 
   cout << "\n";
 

src/vector.hh

@@ -1,3 +1,4 @@
+#include <algorithm>
 #include <cstdio>
 #include <iostream>
 #include <iterator>
@@ -6,7 +7,7 @@
 #include <type_traits>
 
 namespace phundrak {
-using size_type = size_t;
+using size_type = std::size_t;
 
 template <class T, class Allocator = std::allocator<T>> class vector {
 
@@ -25,10 +26,10 @@ private:
     }
   }
 
-  T *data_;
-  size_t size_;
-  size_t capacity_;
-  Allocator alloc_;
+  T *data_ = nullptr;
+  size_t size_ = 0;
+  size_t capacity_ = 0;
+  Allocator alloc_ = Allocator{};
 
 public:
   ///////////////////////////////////////////////////////////////////////////
@@ -37,27 +38,25 @@ public:
 
   // constructor ////////////////////////////////////////////////////////////
 
-  vector() noexcept(noexcept(Allocator()))
-      : vector{Allocator()} {}
+  vector() noexcept(noexcept(Allocator())) {}
 
-  explicit vector(const Allocator &alloc) noexcept
-      : data_{nullptr}, size_{0}, capacity_{0}, alloc_{alloc} {}
+  explicit vector(const Allocator &alloc) noexcept : alloc_{alloc} {}
 
   vector(size_type count, const T &value, const Allocator &alloc = Allocator())
-      : vector{alloc}, data_{nullptr}, size_{0}, capacity_{0} {
+      : vector{alloc} {
     for (size_t i = 0; i < count; ++i)
       push_back(value);
   }
 
   explicit vector(size_type count, const Allocator &alloc = Allocator())
-      : data_{nullptr}, size_{0}, capacity_{0}, alloc_{alloc} {
+      : alloc_{alloc} {
     for (size_type i = 0; i < count; ++i)
       push_back(T{});
   }
 
   template <class InputIt>
   vector(InputIt first, InputIt last, const Allocator &alloc = Allocator())
-      : data_{nullptr}, size_{0}, capacity_{0}, alloc_{alloc} {
+      : alloc_{alloc} {
     for (; first != last; ++first)
       push_back(*first);
   }
@@ -105,13 +104,12 @@ public:
 
   vector(vector &&other, const Allocator &alloc) {
     if (alloc != other.alloc_) {
-      capacity_ = other.capacity_;
-      size_ = other.size_;
+      std::swap(capacity_, other.capacity_);
+      std::swap(size_, other.size_);
       data_ = new T[capacity_];
       alloc_ = alloc;
-      for (size_type i = 0; i < size_; ++i) {
+      for (size_type i = 0; i < size_; ++i)
         data_[i] = std::move(other.data_[i]);
-      }
     } else {
       std::swap(capacity_, other.capacity);
       std::swap(size_, other.size);
@@ -120,28 +118,52 @@ public:
     }
   }
 
-  //! Destructor
+  // Constructor by initializer list //////////////////////////////////////////
+  vector(std::initializer_list<T> init, const Allocator &alloc = Allocator())
+      : vector{alloc} {
+    for (auto &elem : init)
+      push_back(std::move(elem));
+  }
+
+  // Destructor ///////////////////////////////////////////////////////////////
+
   virtual ~vector() noexcept { delete[] data_; }
 
-  //! Copy assignment operator
-  vector &operator=(const vector<T> &other) {
-    vector<T> w{other};
-    std::swap(data_, w.data_);
-    std::swap(size_, w.size_);
-    std::swap(capacity_, w.capacity_);
+  // Copy assignment operator /////////////////////////////////////////////////
+
+  vector &operator=(const vector &other) {
+    delete[] data_;
+    size_ = other.size_;
+    capacity_ = other.capacity_;
+    data_ = new T[capacity_];
+    for (size_type i = 0; i < size_; ++i)
+      data_[i] = other.data_[i];
     return *this;
   }
 
-  //! Move assignment operator
   vector &operator=(vector &&other) noexcept {
-    std::swap(data_, other.data_);
+    std::swap(alloc_, other.alloc_);
     std::swap(size_, other.size_);
     std::swap(capacity_, other.capacity_);
+    std::swap(data_, other.data_);
     return *this;
   }
 
-  T &operator=(size_t pos) { return data_[pos]; }
-  const T &operator=(size_t pos) const { return data_[pos]; }
+  vector &operator=(std::initializer_list<T> ilist) {
+    delete[] data_;
+    size_ = ilist.size();
+    capacity_ = size_;
+    data_ = new T[capacity_];
+    size_type i = 0;
+    std::for_each(std::begin(ilist), std::end(ilist), [&i, this](T &elem) {
+      data_[i] = std::move(elem);
+      ++i;
+    });
+
+    return *this;
+  }
+
+  // assign ///////////////////////////////////////////////////////////////////
 
   void assign(size_t count, const T &value) {
     clear();
@@ -162,7 +184,25 @@ public:
       data_[i] = *first;
   }
 
-  // Element access /////////////////////////////////////////////////////////
+  void assign(std::initializer_list<T> ilist) {
+    delete[] data_;
+    size_ = ilist.size();
+    capacity_ = ilist.size();
+    data_ = new T[size_];
+    size_type i = 0;
+    for (auto pos = ilist.begin(); pos != ilist.end(); ++pos, ++i)
+      data_[i] = std::move(*pos);
+  }
+
+  // get_allocator ////////////////////////////////////////////////////////////
+
+  Allocator get_allocator() const { return alloc_; }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //                              Element access                             //
+  /////////////////////////////////////////////////////////////////////////////
+
+  // at ///////////////////////////////////////////////////////////////////////
 
   T &at(size_t pos) {
     try {
@@ -187,21 +227,31 @@ public:
     return data_[pos];
   }
 
-  T &operator[](size_t pos) { return data_[pos]; }
-  const T &operator[](size_t pos) const { return data_[pos]; }
+  // operator[] ///////////////////////////////////////////////////////////////
+
+  T &operator[](size_type pos) { return data_[pos]; }
+  const T &operator[](size_type pos) const { return data_[pos]; }
+
+  // front ////////////////////////////////////////////////////////////////////
 
   T &front() { return data_[0]; }
   const T &front() const { return data_[0]; }
 
+  // back /////////////////////////////////////////////////////////////////////
+
   T &back() { return data_[size_ - 1]; }
   const T &back() const { return data_[size_ - 1]; }
 
+  // data /////////////////////////////////////////////////////////////////////
+
   T *data() noexcept { return data_; }
   const T *data() const noexcept { return data_; }
 
-  // Iterators //////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////////
+  //                                Iterators                                //
+  /////////////////////////////////////////////////////////////////////////////
 
-  // I don't know how to create custom iterators :(
+  // TODO: iterator functions
 
   // Capacity ///////////////////////////////////////////////////////////////
 
@@ -271,6 +321,140 @@ public:
     std::swap(data_, other.data_);
   }
 
+  /////////////////////////////////////////////////////////////////////////////
+  //                                                                         //
+  //                                                                         //
+  //                              ITERATOR CLASS                             //
+  //                                                                         //
+  //                                                                         //
+  /////////////////////////////////////////////////////////////////////////////
+
+  class iterator {
+
+  protected:
+    T *it;
+
+  public:
+    iterator() : it{nullptr} {}
+    explicit iterator(T *point) : it{point} {}
+
+    iterator(const iterator &other) : it{other.it} {}
+
+    iterator(iterator &&other) { std::swap(it, other.it); }
+
+    iterator &operator=(T *point) {
+      it = point;
+      return *this;
+    }
+    iterator &operator=(const iterator &other) {
+      it = other.it;
+      return *this;
+    }
+    iterator &operator=(iterator &&other) {
+      std::swap(it, other.it);
+      return *this;
+    }
+
+    ~iterator() {
+      // delete it;
+    }
+
+    iterator &operator++() { // ++i
+      ++it;
+      return *this;
+    }
+    iterator operator++(int) { // i++
+      // iterator t;
+      // t.it = it;
+      iterator t{*this};
+      ++it;
+      return t;
+    }
+
+    iterator &operator--() { // --i
+      --it;
+      return *this;
+    }
+
+    iterator operator--(int) { // i--
+      // iterator t;
+      // t.it = it;
+      iterator t{it};
+      --it;
+      return t;
+    }
+
+    bool operator==(T *point) { return point == it; }
+    bool operator==(const iterator &other) { return other.it == it; }
+    bool operator==(iterator &&other) { return other.it == it; }
+
+    bool operator!=(T *point) { return point != it; }
+    bool operator!=(const iterator &other) { return other.it != it; }
+    bool operator!=(iterator &&other) { return other.it != it; }
+
+    T &operator*() { return *it; }
+
+    friend class vector;
+  };
+
+  class const_iterator : public iterator {
+  public:
+    const_iterator() : iterator() {}
+    explicit const_iterator(T *point) : iterator{point} {}
+    explicit const_iterator(const iterator &other) : iterator{other} {}
+    const_iterator(const const_iterator &other) : iterator{other} {}
+    explicit const_iterator(iterator &&other) : iterator{std::move(other)} {}
+    const_iterator(const_iterator &&other) : iterator{std::move(other)} {}
+
+    const T &operator*() { return this->it; }
+  };
+
+  class reverse_iterator : public iterator {
+  public:
+    reverse_iterator() : iterator() {}
+    explicit reverse_iterator(T *point) : iterator(point) {}
+    reverse_iterator(const reverse_iterator &other) : iterator(other) {}
+    reverse_iterator(reverse_iterator &&other) : iterator(std::move(other)) {}
+
+    reverse_iterator &operator++() {
+      ++this->it;
+      return *this;
+    }
+
+    reverse_iterator operator++(int) {
+      reverse_iterator t{*this};
+      ++this->it;
+      ;
+      return t;
+    }
+
+    reverse_iterator &operator--() {
+      --this->it;
+      return *this;
+    }
+
+    reverse_iterator operator--(int) {
+      reverse_iterator t{*this};
+      --this->it;
+      return t;
+    }
+
+    ~reverse_iterator() {}
+  };
+
+  class const_reverse_iterator : public reverse_iterator {
+  public:
+    const_reverse_iterator() : reverse_iterator() {}
+    explicit const_reverse_iterator(T *point) : reverse_iterator{point} {}
+    explicit const_reverse_iterator(const reverse_iterator &other)
+        : reverse_iterator{other} {}
+    const_reverse_iterator(const const_reverse_iterator &other)
+        : reverse_iterator{other} {}
+    explicit const_reverse_iterator(reverse_iterator &&other)
+        : reverse_iterator{other} {}
+    virtual ~const_reverse_iterator() { ~reverse_iterator(); }
+  };
+
 protected:
 };