Refactored Vector.

Author: jfjlaros

src/vector.tcc

@@ -2,127 +2,224 @@
 
 #include <Arduino.h>
 
+
+template <class T>
+void swap_(T& a, T& b) noexcept {
+  T tmp {a};
+  a = b;
+  b = tmp;
+}
+
+
 /*!
  * Generic Vector.
  */
 template <class T>
 class Vector {
 public:
-  Vector() {}
+  Vector() = default;
+  Vector(Vector const& v);
 
   /*! Create a Vector with `size` elements.
    *
-   * \param size Size of the Vector.
+   * \param size Vector size.
    */
   Vector(size_t const);
 
   /*!
    * Create a Vector with `size` elements from a C array.
    *
-   * \param size Size of the Vector.
-   * \param data Pointer to data.
+   * \param data C array.
    */
-  Vector(size_t const, T* const);
+  template <size_t n>
+    Vector(T const (&)[n]);
 
-  Vector(Vector const& v);
+  /*!
+   * Create a Vector with `size` elements from a block of raw memory.
+   *
+   * \param data Pointer to data, Vector takes ownership.
+   * \param size Vector size.
+   */
+  Vector(T* const, size_t const);
 
   ~Vector();
 
   Vector& operator=(Vector);
+  T& operator[](size_t const);
+  T const& operator [](size_t const) const;
 
+  T* begin();
+  T* end();
+  T const* begin() const;
+  T const* end() const;
 
   /*!
-   * Get a reference to an element.
+   * Get the underlying data.
    *
-   * This can be used for both retrieval as well as assignment.
+   * \return data.
+   */
+  T* data() const;
+
+  /*!
+   * Get the number of elements.
    *
-   * \param index Index.
+   * \return Vector size.
+   */
+  size_t size() const;
+
+  /*!
+   * Set the number of elements.
    *
-   * \return Reference to element at index `index`.
+   * \param size Vector size.
    */
-  T& operator[](size_t) const;
+  void resize(size_t const);
+
+  /*! Clear the contents. */
+  void clear();
 
-  size_t size() const {
-    return size_;
-  }
   /*!
-   * Resize the Vector.
+   * Add an element to the back.
    *
-   * \param size New size of the Vector.
+   * \param el Element.
    */
-  void resize(size_t);
+  void push_back(T const&);
+
+  /*!
+   * Remove an element from the back.
+   *
+   * \return Element.
+   */
+  T pop_back();
 
   template <class U>
     friend void swap(Vector<U>&, Vector<U>&) noexcept;
 
-  //T* begin();
-  //T* end();
-  //T const* begin() const;
-  //T const* end() const;
-
 private:
+  void copy_(T const* const);
+
   size_t size_ {0};
   T* data_ {nullptr};
 };
 
+
 template <class T>
-void swap_(T& a, T& b) noexcept {
-  T tmp {a};
-  a = b;
-  b = tmp;
+Vector<T>::Vector(Vector const& other)
+    : size_ {other.size_}, data_ {new T[other.size_]} {
+  copy_(other.data_);
 }
 
-template <class U>
-void swap(Vector<U>& a, Vector<U>& b) noexcept {
-  swap_(a.size_, b.size_);
-  swap_(a.data_, b.data_);
+template <class T>
+Vector<T>::Vector(size_t const size)
+    : size_ {size}, data_ {new T[size]} {}
+
+template <class T>
+Vector<T>::Vector(T* const data, size_t const size)
+    : size_ {size}, data_ {data} {}
+
+template <class T>
+template <size_t n>
+Vector<T>::Vector(T const (&data)[n])
+    : size_ {n}, data_ {new T[n]} {
+  copy_(data);
+}
+
+template <class T>
+Vector<T>::~Vector() {
+  delete[] data_;
 }
 
 
 template <class T>
-Vector<T>::Vector(size_t const size) {
-  resize(size);
+Vector<T>& Vector<T>::operator=(Vector<T> other) {
+  swap(*this, other);
+  return *this;
 }
 
 template <class T>
-Vector<T>::Vector(size_t const size, T* const data) {
-  this->size_ = size;
-  data_ = data;
+T& Vector<T>::operator[](size_t const idx) {
+  return data_[idx];
 }
 
 template <class T>
-Vector<T>::Vector(Vector const& v) : size_ {v.size_} {
-  data_ = new T[size_];
-  for (size_t i {0}; i < size_; i++) {
-    data_[i] = v.data_[i];
-  }
+T const& Vector<T>::operator[](size_t const idx) const {
+  return data_[idx];
 }
 
+
 template <class T>
-Vector<T>::~Vector() {
-  delete[] data_;
+T* Vector<T>::begin() {
+  return data_;
 }
 
 template <class T>
-Vector<T>& Vector<T>::operator=(Vector v) {
-  swap(*this, v);
-  return *this;
+T* Vector<T>::end() {
+  return data_ + size_;
+}
+
+template <class T>
+T const* Vector<T>::begin() const {
+  return data_;
+}
+
+template <class T>
+T const* Vector<T>::end() const {
+  return data_ + size_;
 }
 
 
 template <class T>
-T& Vector<T>::operator[](size_t const index) const {
-  return data_[index];
+T* Vector<T>::data() const {
+  return data_;
+}
+
+template <class T>
+size_t Vector<T>::size() const {
+  return size_;
 }
 
 template <class T>
 void Vector<T>::resize(size_t const size) {
-  T* newData {new T[size]};
-  for (size_t i {0}; i < min(this->size_, size); i++) {
-    newData[i] = data_[i];
-  }
+  size_ = min(size_, size);
+
+  T* data {new T[size]};
+  swap_(data_, data);
+  copy_(data);
+  delete[] data;
+
+  size_ = size;
+}
+
+template <class T>
+void Vector<T>::clear() {
+  size_ = 0;
   delete[] data_;
-  data_ = newData;
+  data_ = nullptr;
+}
+
+template <class T>
+void Vector<T>::push_back(T const& el) {
+  resize(++size_);
+  data_[size_ - 1] = el;
+}
+
+template <class T>
+T Vector<T>::pop_back() {
+  T el {data_[size_ - 1]};
+  resize(--size_);
+  return el;
+}
 
-  this->size_ = size;
+
+template <class T>
+void Vector<T>::copy_(T const* const data) {
+  for (size_t i {0}; i < size_; ++i) {
+    data_[i] = data[i];
+  }
+}
+
+
+template <class U>
+void swap(Vector<U>& a, Vector<U>& b) noexcept {
+  swap_(a.size_, b.size_);
+  swap_(a.data_, b.data_);
 }