不韋 呂 / Array_Matrix

Generic class libraries for 1D array and 2D array: Array and Matrix. 1次元および2次元配列用の汎用クラスライブラリ: Array と Matrix.

Dependents:   F746_SD_WavPlayer CW_Decoder_using_FFT_on_F446 F446_MySoundMachine F446_ADF_Nlms ... more

Array.hpp@3:d9dea7748b27, 2019-11-19 (annotated)

Committer:
MikamiUitOpen
Date:
Tue Nov 19 05:44:54 2019 +0000
Revision:
3:d9dea7748b27
Parent:
2:a25dba17218c
Child:
4:d3aa1ddb57e1
4

Who changed what in which revision?

UserRevisionLine numberNew contents of line
MikamiUitOpen 0:efe9b1f01090 1 //-----------------------------------------------------------------------
MikamiUitOpen 0:efe9b1f01090 2 // Generic Array class
MikamiUitOpen 3:d9dea7748b27 3 // Macro definition "DEBUG_ARRAY_CHECK" enables to check
MikamiUitOpen 3:d9dea7748b27 4 // range of index.
MikamiUitOpen 0:efe9b1f01090 5 //
MikamiUitOpen 3:d9dea7748b27 6 // 2019/11/19, Copyright (c) 2019 MIKAMI, Naoki
MikamiUitOpen 0:efe9b1f01090 7 //-----------------------------------------------------------------------
MikamiUitOpen 0:efe9b1f01090 8
MikamiUitOpen 0:efe9b1f01090 9 #include "mbed.h"
MikamiUitOpen 3:d9dea7748b27 10 #include <new> // for Rev.122 or before revision of Mbed official library
MikamiUitOpen 0:efe9b1f01090 11
MikamiUitOpen 0:efe9b1f01090 12 #ifndef MIKAMI_ARRAY_HPP
MikamiUitOpen 0:efe9b1f01090 13 #define MIKAMI_ARRAY_HPP
MikamiUitOpen 0:efe9b1f01090 14
MikamiUitOpen 0:efe9b1f01090 15 namespace Mikami
MikamiUitOpen 0:efe9b1f01090 16 {
MikamiUitOpen 0:efe9b1f01090 17 template <class T> class Array
MikamiUitOpen 0:efe9b1f01090 18 {
MikamiUitOpen 0:efe9b1f01090 19 public:
MikamiUitOpen 3:d9dea7748b27 20 explicit Array(int n = 1) { ArrayNew(n); } // default constructor
MikamiUitOpen 0:efe9b1f01090 21 Array(const Array<T>& a) { Copy(a); } // copy constructor
MikamiUitOpen 3:d9dea7748b27 22 Array(int n, T initialValue); // constructor with initialization
MikamiUitOpen 3:d9dea7748b27 23 Array(int n, const T val[]); // constructor with assignment built-in array
MikamiUitOpen 0:efe9b1f01090 24 ~Array() { delete[] v_; } // destructor
MikamiUitOpen 3:d9dea7748b27 25 void Fill(T val); // fill with same value
MikamiUitOpen 3:d9dea7748b27 26 void Assign(const T val[]); // assign built-in array
MikamiUitOpen 3:d9dea7748b27 27 void SetSize(int n); // setting size
MikamiUitOpen 0:efe9b1f01090 28 int Length() const { return size_; } // get size of array
MikamiUitOpen 0:efe9b1f01090 29 Array<T>& operator=(const Array<T>& a); // assignment
MikamiUitOpen 3:d9dea7748b27 30 T& operator[](int n); // non-const [] operator
MikamiUitOpen 3:d9dea7748b27 31 const T& operator[](int n) const; // const [] operator
MikamiUitOpen 3:d9dea7748b27 32 operator T* () const { return v_; } // non-const type conversion
MikamiUitOpen 3:d9dea7748b27 33 operator const T* () const { return v_; } // const type conversion
MikamiUitOpen 0:efe9b1f01090 34
MikamiUitOpen 0:efe9b1f01090 35 private:
MikamiUitOpen 0:efe9b1f01090 36 T *v_;
MikamiUitOpen 3:d9dea7748b27 37 int size_; // size of array
MikamiUitOpen 0:efe9b1f01090 38
MikamiUitOpen 3:d9dea7748b27 39 void Range(int pos) const; // range checking for Array
MikamiUitOpen 3:d9dea7748b27 40 void Copy(const Array<T>& v_src); // copy of object
MikamiUitOpen 3:d9dea7748b27 41 void ArrayNew(const int n); // routine for constructor
MikamiUitOpen 0:efe9b1f01090 42 };
MikamiUitOpen 0:efe9b1f01090 43
MikamiUitOpen 0:efe9b1f01090 44 //-----------------------------------------------------------------------
MikamiUitOpen 0:efe9b1f01090 45 // implementation of generic array class
MikamiUitOpen 0:efe9b1f01090 46 //-----------------------------------------------------------------------
MikamiUitOpen 0:efe9b1f01090 47
MikamiUitOpen 0:efe9b1f01090 48 // constructor with initialization
MikamiUitOpen 3:d9dea7748b27 49 template <class T> inline Array<T>::Array(int n, T initialValue)
MikamiUitOpen 0:efe9b1f01090 50 {
MikamiUitOpen 3:d9dea7748b27 51 ArrayNew(n);
MikamiUitOpen 0:efe9b1f01090 52 Fill(initialValue);
MikamiUitOpen 0:efe9b1f01090 53 }
MikamiUitOpen 1:54b07f0d5ba1 54
MikamiUitOpen 1:54b07f0d5ba1 55 // constructor with assignment built-in array
MikamiUitOpen 3:d9dea7748b27 56 template <class T> inline Array<T>::Array(int n, const T val[])
MikamiUitOpen 1:54b07f0d5ba1 57 {
MikamiUitOpen 3:d9dea7748b27 58 ArrayNew(n);
MikamiUitOpen 1:54b07f0d5ba1 59 Assign(val);
MikamiUitOpen 1:54b07f0d5ba1 60 }
MikamiUitOpen 0:efe9b1f01090 61
MikamiUitOpen 3:d9dea7748b27 62 template <class T> inline void Array<T>::SetSize(int n)
MikamiUitOpen 0:efe9b1f01090 63 {
MikamiUitOpen 0:efe9b1f01090 64 delete[] v_;
MikamiUitOpen 3:d9dea7748b27 65 v_ = new T[size_ = n];
MikamiUitOpen 0:efe9b1f01090 66 }
MikamiUitOpen 0:efe9b1f01090 67
MikamiUitOpen 0:efe9b1f01090 68 // fill with same value
MikamiUitOpen 3:d9dea7748b27 69 template <class T> inline void Array<T>::Fill(T val)
MikamiUitOpen 0:efe9b1f01090 70 {
MikamiUitOpen 0:efe9b1f01090 71 for (int n=0; n<size_; n++) v_[n] = val;
MikamiUitOpen 0:efe9b1f01090 72 }
MikamiUitOpen 1:54b07f0d5ba1 73
MikamiUitOpen 2:a25dba17218c 74 // assign built-in array
MikamiUitOpen 3:d9dea7748b27 75 template <class T> inline void Array<T>::Assign(const T val[])
MikamiUitOpen 1:54b07f0d5ba1 76 {
MikamiUitOpen 1:54b07f0d5ba1 77 for (int n=0; n<size_; n++) v_[n] = val[n];
MikamiUitOpen 1:54b07f0d5ba1 78 }
MikamiUitOpen 1:54b07f0d5ba1 79
MikamiUitOpen 3:d9dea7748b27 80 template <class T> inline Array<T>& Array<T>::operator=(const Array<T>& a)
MikamiUitOpen 0:efe9b1f01090 81 {
MikamiUitOpen 1:54b07f0d5ba1 82 if (this != &a) // prohibition of self-assignment
MikamiUitOpen 0:efe9b1f01090 83 {
MikamiUitOpen 0:efe9b1f01090 84 delete [] v_;
MikamiUitOpen 0:efe9b1f01090 85 Copy(a);
MikamiUitOpen 0:efe9b1f01090 86 }
MikamiUitOpen 0:efe9b1f01090 87 return *this;
MikamiUitOpen 0:efe9b1f01090 88 }
MikamiUitOpen 0:efe9b1f01090 89
MikamiUitOpen 3:d9dea7748b27 90 template <class T> inline T& Array<T>::operator[](int n)
MikamiUitOpen 0:efe9b1f01090 91 {
MikamiUitOpen 0:efe9b1f01090 92 #ifdef DEBUG_ARRAY_CHECK
MikamiUitOpen 3:d9dea7748b27 93 Range(n); // out of bound ?
MikamiUitOpen 0:efe9b1f01090 94 #endif
MikamiUitOpen 3:d9dea7748b27 95 return v_[n];
MikamiUitOpen 0:efe9b1f01090 96 }
MikamiUitOpen 0:efe9b1f01090 97
MikamiUitOpen 3:d9dea7748b27 98 template <class T> inline const T& Array<T>::operator[](int n) const
MikamiUitOpen 0:efe9b1f01090 99 {
MikamiUitOpen 0:efe9b1f01090 100 #ifdef DEBUG_ARRAY_CHECK
MikamiUitOpen 3:d9dea7748b27 101 Range(n); // out of bounds ?
MikamiUitOpen 0:efe9b1f01090 102 #endif
MikamiUitOpen 3:d9dea7748b27 103 return v_[n];
MikamiUitOpen 0:efe9b1f01090 104 }
MikamiUitOpen 0:efe9b1f01090 105
MikamiUitOpen 0:efe9b1f01090 106 template <class T> void Array<T>::Range(int pos) const
MikamiUitOpen 0:efe9b1f01090 107 {
MikamiUitOpen 0:efe9b1f01090 108 if ((pos < 0) || (pos >= size_))
MikamiUitOpen 3:d9dea7748b27 109 mbed_assert_internal("Out of range", __FILE__, __LINE__); // mbed_assert.h
MikamiUitOpen 0:efe9b1f01090 110 }
MikamiUitOpen 0:efe9b1f01090 111
MikamiUitOpen 3:d9dea7748b27 112 template <class T> inline void Array<T>::Copy(const Array<T>& v_src)
MikamiUitOpen 0:efe9b1f01090 113 {
MikamiUitOpen 0:efe9b1f01090 114 v_ = new T[size_ = v_src.size_];
MikamiUitOpen 1:54b07f0d5ba1 115 for (int n=0; n<size_; n++) v_[n] = v_src.v_[n];
MikamiUitOpen 0:efe9b1f01090 116 }
MikamiUitOpen 0:efe9b1f01090 117
MikamiUitOpen 0:efe9b1f01090 118 // routine for constructor
MikamiUitOpen 3:d9dea7748b27 119 template <class T> inline void Array<T>::ArrayNew(int n)
MikamiUitOpen 0:efe9b1f01090 120 {
MikamiUitOpen 3:d9dea7748b27 121 v_ = new T[size_ = n];
MikamiUitOpen 0:efe9b1f01090 122 }
MikamiUitOpen 0:efe9b1f01090 123 }
MikamiUitOpen 3:d9dea7748b27 124 #endif // MIKAMI_ARRAY_HPP