Construct, fill, and assign with arrays of different sizes and types.

Author: peterpolidoro

Array.h

@@ -24,16 +24,26 @@ class Array
 public:
   Array();
   Array(const T &value);
-  Array(const T (&values)[MAX_SIZE]);
+  template <typename U, size_t N>
+  Array(const U (&values)[N]);
+  template <typename U, size_t N>
+  Array(const Array<U,N> &values);
   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 size_t n, const T &value);
-  void assign(const size_t n, const T values[]);
+  template <typename U, size_t N>
+  void fill(const U (&values)[N]);
+  template <typename U, size_t N>
+  void fill(const Array<U,N> &values);
+  template <typename U>
+  void assign(const size_t n, const U &value);
+  template <typename U, size_t N>
+  void assign(const size_t n, const U (&values)[N]);
+  template <typename U, size_t N>
+  void assign(const size_t n, const Array<U,N> &values);
   void push_back(const T &value);
   void pop_back();
   size_t size();

ArrayDefinitions.h

@@ -26,7 +26,16 @@ Array<T, MAX_SIZE>::Array(const T &value)
 }
 
 template <typename T, size_t MAX_SIZE>
-Array<T, MAX_SIZE>::Array(const T (&values)[MAX_SIZE])
+template <typename U, size_t N>
+Array<T, MAX_SIZE>::Array(const U (&values)[N])
+{
+  size_ = 0;
+  fill(values);
+}
+
+template <typename T, size_t MAX_SIZE>
+template <typename U, size_t N>
+Array<T, MAX_SIZE>::Array(const Array<U,N> &values)
 {
   size_ = 0;
   fill(values);
@@ -69,44 +78,55 @@ void Array<T, MAX_SIZE>::fill(const T &value)
 }
 
 template <typename T, size_t MAX_SIZE>
-void Array<T, MAX_SIZE>::fill(const T (&values)[MAX_SIZE])
+template <typename U, size_t N>
+void Array<T, MAX_SIZE>::fill(const U (&values)[N])
 {
-  assign(MAX_SIZE,values);
+  assign(N,values);
 }
 
 template <typename T, size_t MAX_SIZE>
-void Array<T, MAX_SIZE>::assign(const size_t n, const T &value)
+template <typename U, size_t N>
+void Array<T, MAX_SIZE>::fill(const Array<U,N> &values)
 {
-  size_t assign_size = n;
-  if ((n > size_) && (n <= MAX_SIZE))
-  {
-    size_ = n;
-  }
-  else if (n > MAX_SIZE)
-  {
-    size_ = MAX_SIZE;
-    assign_size = MAX_SIZE;
-  }
+  assign(N,values);
+}
+
+template <typename T, size_t MAX_SIZE>
+template <typename U>
+void Array<T, MAX_SIZE>::assign(const size_t n, const U &value)
+{
+  size_t assign_size = ((n < MAX_SIZE) ? n : MAX_SIZE);
+  size_ = assign_size;
   for (size_t i=0; i<assign_size; i++)
   {
     values_[i] = value;
   }
 }
 
 template <typename T, size_t MAX_SIZE>
-void Array<T, MAX_SIZE>::assign(const size_t n, const T values[])
+template <typename U, size_t N>
+void Array<T, MAX_SIZE>::assign(const size_t n, const U (&values)[N])
 {
-  size_t assign_size = n;
-  if ((n > size_) && (n <= MAX_SIZE))
+  size_t n_smallest = ((n < N) ? n : N);
+  size_t assign_size = ((n_smallest < MAX_SIZE) ? n_smallest : MAX_SIZE);
+  size_ = assign_size;
+  for (size_t i=0; i<assign_size; i++)
   {
-    size_ = n;
+    values_[i] = values[i];
   }
-  else if (n > MAX_SIZE)
+}
+
+template <typename T, size_t MAX_SIZE>
+template <typename U, size_t N>
+void Array<T, MAX_SIZE>::assign(const size_t n, const Array<U,N> &values)
+{
+  size_t n_smallest = ((n < values.size()) ? n : values.size());
+  size_t assign_size = ((n_smallest < MAX_SIZE) ? n_smallest : MAX_SIZE);
+  size_ = assign_size;
+  for (size_t i=0; i<assign_size; i++)
   {
-    size_ = MAX_SIZE;
-    assign_size = MAX_SIZE;
+    values_[i] = values[i];
   }
-  memcpy((void*) values_, (void*) values, assign_size*sizeof(T));
 }
 
 template <typename T, size_t MAX_SIZE>

examples/ArrayTester/ArrayTester.ino

@@ -86,6 +86,21 @@ void setup()
 
   out_of_bounds = array_doubled.at(ELEMENT_COUNT+1);
   Serial << "out_of_bounds:" << out_of_bounds << endl;
+
+  // initialize with array of different size and type
+  Array<long,ELEMENT_COUNT*2> array_copy2(array_simple);
+  Serial << "array_copy2:" << endl;
+  Serial << array_copy2 << endl;
+  Serial << "array_copy2.max_size():" << endl;
+  Serial << array_copy2.max_size() << endl;
+
+  // initialize with another array instance
+  Array<size_t,ELEMENT_COUNT*3> array_copy3(array_copy2);
+  Serial << "array_copy3:" << endl;
+  Serial << array_copy3 << endl;
+  Serial << "array_copy3.max_size():" << endl;
+  Serial << array_copy3.max_size() << endl;
+
 }