00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018 #ifndef RAUL_ARRAY_HPP
00019 #define RAUL_ARRAY_HPP
00020
00021 #include <cassert>
00022 #include <cstdlib>
00023 #include "Deletable.hpp"
00024
00025 namespace Raul {
00026
00027
00034 template <class T>
00035 class Array : public Deletable
00036 {
00037 public:
00038 Array(size_t size = 0) : _size(size), _top(0), _elems(NULL) {
00039 if (size > 0)
00040 _elems = new T[size];
00041 }
00042
00043 Array(size_t size, T initial_value) : _size(size), _top(0), _elems(NULL) {
00044 if (size > 0) {
00045 _elems = new T[size];
00046 for (size_t i=0; i < size; ++i)
00047 _elems[i] = initial_value;
00048 }
00049 }
00050
00051 Array(size_t size, const Array<T>& contents) : _size(size), _top(size+1) {
00052 _elems = new T[size];
00053 if (size <= contents.size())
00054 memcpy(_elems, contents._elems, size * sizeof(T));
00055 else
00056 memcpy(_elems, contents._elems, contents.size() * sizeof(T));
00057 }
00058
00059 ~Array() {
00060 delete[] _elems;
00061 }
00062
00063 void alloc(size_t num_elems) {
00064 assert(num_elems > 0);
00065
00066 delete[] _elems;
00067 _size = num_elems;
00068 _top = 0;
00069
00070 _elems = new T[num_elems];
00071 }
00072
00073 void alloc(size_t num_elems, T initial_value) {
00074 assert(num_elems > 0);
00075
00076 delete[] _elems;
00077 _size = num_elems;
00078 _top = 0;
00079
00080 _elems = new T[num_elems];
00081 for (size_t i=0; i < _size; ++i)
00082 _elems[i] = initial_value;
00083 }
00084
00085 void push_back(T n) {
00086 assert(_top < _size);
00087 _elems[_top++] = n;
00088 }
00089
00090 inline size_t size() const { return _size; }
00091
00092 inline T& operator[](size_t i) const { assert(i < _size); return _elems[i]; }
00093
00094 inline T& at(size_t i) const { assert(i < _size); return _elems[i]; }
00095
00096 private:
00097 size_t _size;
00098 size_t _top;
00099 T* _elems;
00100 };
00101
00102
00103 }
00104
00105 #endif // RAUL_ARRAY_HPP