Updated documentation and removed old assert code.

Author: peterpolidoro

Array.cpp

@@ -8,17 +8,3 @@
 #include "Array.h"
 
 
-// handle diagnostic informations given by assertion and abort program execution:
-// void __assert(const char *__func, const char *__file, int __lineno, const char *__sexp)
-// {
-//   // transmit diagnostic informations through serial link.
-//   // Serial.println(__func);
-//   // Serial.println(__file);
-//   // Serial.println(__lineno, DEC);
-//   // Serial.println(__sexp);
-//   Serial.println("Attempted to access out of bounds Array element!");
-//   Serial.println("Check indicies or increase Array size.");
-//   Serial.flush();
-//   // abort program execution.
-//   abort();
-// }

Array.h

@@ -12,39 +12,33 @@
 #else
 #include "WProgram.h"
 #endif
-// #define __ASSERT_USE_STDERR
-// #include <assert.h>
 
-
-// // handle diagnostic informations given by assertion and abort program execution:
-// void __assert(const char *__func, const char *__file, int __lineno, const char *__sexp);
-
-template <typename T, unsigned int max_size_>
+template <typename T, size_t max_size_>
 class Array
 {
 public:
   Array();
   Array(const T &value);
   Array(const T (&values)[max_size_]);
-  T& operator[](const unsigned int i);
-  T& at(const unsigned int i);
+  T& operator[](const size_t i);
+  T& at(const size_t i);
   T& front();
   T& back();
   void clear();
   void fill(const T &value);
   void fill(const T (&values)[max_size_]);
-  void assign(const unsigned int n, const T &value);
-  void assign(const unsigned int n, const T values[]);
+  void assign(const size_t n, const T &value);
+  void assign(const size_t n, const T values[]);
   void push_back(const T &value);
   void pop_back();
-  unsigned int size();
-  unsigned int max_size();
+  size_t size();
+  size_t max_size();
   bool empty();
   bool full();
 
 private:
   T values_[max_size_];
-  unsigned int size_;
+  size_t size_;
 };
 #include "ArrayDefinitions.h"
 

ArrayDefinitions.h

@@ -9,73 +9,70 @@
 #define ARRAY_DEFINITIONS_H
 
 
-template <typename T, unsigned int max_size_>
+template <typename T, size_t max_size_>
 Array<T,max_size_>::Array()
 {
   clear();
 }
 
-template <typename T, unsigned int max_size_>
+template <typename T, size_t max_size_>
 Array<T,max_size_>::Array(const T &value)
 {
   fill(value);
 }
 
-template <typename T, unsigned int max_size_>
+template <typename T, size_t max_size_>
 Array<T, max_size_>::Array(const T (&values)[max_size_])
 {
   fill(values);
 }
 
-template <typename T, unsigned int max_size_>
-T& Array<T, max_size_>::operator[](const unsigned int i)
+template <typename T, size_t max_size_>
+T& Array<T, max_size_>::operator[](const size_t i)
 {
   return values_[i];
 }
 
-template <typename T, unsigned int max_size_>
-T& Array<T, max_size_>::at(const unsigned int i)
+template <typename T, size_t max_size_>
+T& Array<T, max_size_>::at(const size_t i)
 {
-  // assert((i>=0) && (i<size_));
   return values_[i];
 }
 
-template <typename T, unsigned int max_size_>
+template <typename T, size_t max_size_>
 T& Array<T, max_size_>::front()
 {
-  // assert(!empty());
   return values_[0];
 }
 
-template <typename T, unsigned int max_size_>
+template <typename T, size_t max_size_>
 T& Array<T, max_size_>::back()
 {
-  // assert(!empty());
   return values_[size_-1];
 }
 
-template <typename T, unsigned int max_size_>
+template <typename T, size_t max_size_>
 void Array<T, max_size_>::clear()
 {
   size_ = 0;
 }
 
-template <typename T, unsigned int max_size_>
+template <typename T, size_t max_size_>
 void Array<T, max_size_>::fill(const T &value)
 {
   assign(max_size_,value);
 }
 
-template <typename T, unsigned int max_size_>
+template <typename T, size_t max_size_>
 void Array<T, max_size_>::fill(const T (&values)[max_size_])
 {
   assign(max_size_,values);
 }
 
-template <typename T, unsigned int max_size_>
-void Array<T, max_size_>::assign(const unsigned int n, const T &value)
+template <typename T, size_t max_size_>
+void Array<T, max_size_>::assign(const size_t n, const T &value)
 {
-  unsigned int assign_size = n;
+  size_t assign_size = n;
   if ((n > size_) && (n <= max_size_))
   {
     size_ = n;
@@ -85,16 +82,16 @@ void Array<T, max_size_>::assign(const unsigned int n, const T &value)
     size_ = max_size_;
     assign_size = max_size_;
   }
-  for (unsigned int i=0; i<assign_size; i++)
+  for (size_t i=0; i<assign_size; i++)
   {
     values_[i] = value;
   }
 }
 
-template <typename T, unsigned int max_size_>
-void Array<T, max_size_>::assign(const unsigned int n, const T values[])
+template <typename T, size_t max_size_>
+void Array<T, max_size_>::assign(const size_t n, const T values[])
 {
-  unsigned int assign_size = n;
+  size_t assign_size = n;
   if ((n > size_) && (n <= max_size_))
   {
     size_ = n;
@@ -107,7 +104,7 @@ void Array<T, max_size_>::assign(const unsigned int n, const T values[])
   memcpy((void*) values_, (void*) values, assign_size*sizeof(T));
 }
 
-template <typename T, unsigned int max_size_>
+template <typename T, size_t max_size_>
 void Array<T, max_size_>::push_back(const T &value)
 {
   if (size_ < max_size_)
@@ -116,7 +113,7 @@ void Array<T, max_size_>::push_back(const T &value)
   }
 }
 
-template <typename T, unsigned int max_size_>
+template <typename T, size_t max_size_>
 void Array<T, max_size_>::pop_back()
 {
   if (size_ > 0)
@@ -125,25 +122,25 @@ void Array<T, max_size_>::pop_back()
   }
 }
 
-template <typename T, unsigned int max_size_>
-unsigned int Array<T, max_size_>::size()
+template <typename T, size_t max_size_>
+size_t Array<T, max_size_>::size()
 {
   return size_;
 }
 
-template <typename T, unsigned int max_size_>
-unsigned int Array<T, max_size_>::max_size()
+template <typename T, size_t max_size_>
+size_t Array<T, max_size_>::max_size()
 {
   return max_size_;
 }
 
-template <typename T, unsigned int max_size_>
+template <typename T, size_t max_size_>
 bool Array<T, max_size_>::empty()
 {
   return size_ == 0;
 }
 
-template <typename T, unsigned int max_size_>
+template <typename T, size_t max_size_>
 bool Array<T, max_size_>::full()
 {
   return size_ == max_size_;

README.md

@@ -8,8 +8,14 @@ License:
 
     BSD
 
-An array container like the C++
-[std::array](http://en.cppreference.com/w/cpp/container/array).
+An array container similar to the C++
+[std::array](http://www.cplusplus.com/reference/array/array/), with
+some [std::vector](http://www.cplusplus.com/reference/vector/vector/)
+methods added. The maximum size is fixed as a template parameter, but
+the size is variable, like a vector. Values can be pushed and popped
+and the size adjusts accordingly. The data are stored internally as a
+statically allocated c style array. Care must be taken not to
+dereference an empty array or access elements beyond bounds.
 
 [Usage Examples](./examples)