reffactored and recurrent implementation

include/Tools/Array.h

@@ -0,0 +1,80 @@
+#pragma once
+
+namespace Array {
+
+	/**
+	* @author Tomas Cernik (Tom.Cernik@gmail.com)
+	* @brief Template of array for simple usage
+	*/
+
+	template <typename T>
+	class Array {
+		public:
+
+			Array(unsigned long size=0):arr(size==0? nullptr: new T[size]),_size(0) {
+				
+			}
+
+			Array (const Array& r):arr(r.arr),_size(r._size) {
+			}
+
+			~Array() {
+			}
+
+			inline Array& operator=(const Array& r) {
+				arr=r.arr;
+				_size=r._size;
+			}
+
+			inline void resize(unsigned long size) {
+				if(arr==nullptr) {
+					arr=new T[size];
+					_size=size;
+				}else {
+					T* tmp=new T[size];
+					for(unsigned long i=0;i<_size;i++) {
+						tmp[i]=arr[i];
+					}
+					delete[] arr;
+					arr=tmp;
+				}
+			}
+
+			inline void free() {
+				delete[] arr;
+				arr=nullptr;
+				_size=0;
+			}
+
+			inline const T& operator[](unsigned long i) const {
+				return arr[i];
+			}
+
+			inline T& operator[](unsigned long i) {
+				return arr[i];
+			}
+
+			unsigned long size() const {
+				return _size;
+			}
+
+		protected:
+			T* arr;
+			unsigned long _size;
+		private:
+	};
+
+	template <typename T>
+	class DynamicArray: public Array<T> {
+		public:
+			DynamicArray(unsigned long size=0,float _scaleFactor=1):Array<T>(size),scaleFactor(_scaleFactor) {
+				
+			}
+
+			
+
+		protected:
+			float scaleFactor;
+		private:
+	};
+}