Создать шаблонный класс-контейнер Array, который представляет собой
массив, позволяющий хранить объекты заданного типа. Класс должен
реализовывать следующие функции:
/*TASK
Создать шаблонный класс-контейнер Array, который представляет собой
массив, позволяющий хранить объекты заданного типа. Класс должен
реализовывать следующие функции:
A) GetSize — получение размера массива (количество элементов, под которые
выделена память);
B) SetSize(int size, int grow = 1) — установка размера массива (если параметр
size больше предыдущего размера массива, то выделяется дополнительный
блок памяти, если нет, то "лишние" элементы теряются и память
освобождается); параметр grow определяет для какого количества элементов
необходимо выделить память, если количество элементов превосходит
текущий размер массива.Например, SetSize(5, 5); означает, что при
добавлении 6-го элемента размер массива становится равным 10, при
добавлении 11-го — 15 и т.д.;50
C) GetUpperBound — получение последнего допустимого индекса в
массиве.Например, если при размере массива 10, вы добавляете в него 4
элемента, то функция вернет 3;
D) IsEmpty — массив пуст?
E) FreeExtra — удалить "лишнюю" память (выше последнего допустимого
индекса);
F) RemoveAll — удалить все;
G) GetAt — получение определенного элемента (по индексу);
H) SetAt — установка нового значения для определенного элемента (индекс
элемента должен быть меньше текущего размера массива);
I) operator [] — для реализации двух предыдущих функций;
J) Add — добавление элемента в массив (при необходимости массив
увеличивается на значение grow функции SetSize);
K) Append — "сложение" двух массивов;
L) operator =;
M) GetData — получения адреса массива с данными;
N) InsertAt — вставка элемента(-ов) в заданную позицию O.RemoveAt —
удаление элемента(-ов) с заданной позиции.
*/
//H.h
#pragma once
#include <iostream>
using namespace std;
#define STOP system("pause");
#define COLOR_GREEN_TEXT system("color 0A");
//Array.h
#pragma once
#include "H.h"
template<class T>
class Array
{
public:
Array(int SIZE);
Array(const Array & other);
~Array();
int getSize();
void setSize(int SIZE, int grow = 1);
void addElement(T element);
int getUpperBound();
bool isEmpty();
void freeExtra();
void removeAll();
T getAt(int index);
void setAt(int index, T element);
T & operator[](int index);
void Append(Array ob);
T * getData();
void insertAt(int index, T element);
void showArray();
Array & operator=(const Array & ob1);
private:
T * arr;
int SIZE;
int preSIZE;
int count;
int grow;
};
// Array.cpp
#pragma once
#include "Array.h"
template<class T>
Array<T>::Array(int SIZE) // CONSTRUCTOR
{
this->grow = 1;
this->SIZE = SIZE + grow;
this->preSIZE = SIZE;
this->count = 0;
this->arr = new T[this->SIZE]();
}
template<class T>
Array<T>::Array(const Array & other) // CONSTRUCTOR COPY
{
this->SIZE = other.SIZE;
this->arr = new T[this->SIZE];
for (size_t i = 0; i < this->SIZE; i++)
{
this->arr[i] = other.arr[i];
}
}
template<class T>
Array<T>::~Array() // DESTRUCTOR
{
delete[] arr;
arr = NULL;
}
template<class T>
int Array<T>::getSize() // GET SIZE
{
return this->SIZE;
}
template<class T>
void Array<T>::setSize(int SIZE, int grow) //SET SIZE
{
if(grow > 0)
this->grow = grow;
this->SIZE = SIZE + this->grow;
if (this->SIZE > this->preSIZE)
{
T * buf = new T[this->SIZE]();
for (size_t i = 0; i < this->preSIZE; i++)
{
buf[i] = arr[i];
}
delete[] arr;
arr = new T[this->SIZE]();
for (size_t i = 0; i < this->SIZE; i++)
{
arr[i] = buf[i];
}
delete[] buf;
this->preSIZE = this->SIZE;
}
else
{
T * buf = new T[this->SIZE]();
for (size_t i = 0; i < this->SIZE - this->grow; i++)
{
buf[i] = arr[i];
}
delete[] arr;
arr = new T[this->SIZE]();
for (size_t i = 0; i < this->SIZE; i++)
{
arr[i] = buf[i];
}
delete[] buf;
this->preSIZE = this->SIZE;
this->count = this->SIZE - this->grow;
}
}
template<class T>
void Array<T>::addElement(T element) // ADD ELEMENT
{
if (count < this->SIZE)
{
this->arr[count] = element;
count++;
}
else
{
this->SIZE = this->SIZE + this->grow + 1;
T * buf = new T[this->SIZE]();
for (size_t i = 0; i < this->SIZE - this->grow; i++)
{
buf[i] = arr[i];
}
delete[] arr;
arr = new T[this->SIZE]();
for (size_t i = 0; i < this->SIZE; i++)
{
arr[i] = buf[i];
}
delete[] buf;
buf = NULL;
arr[count] = element;
count++;
}
}
template<class T>
int Array<T>::getUpperBound() //GET UPPER BOUND
{
return count - 1;
}
template<class T>
bool Array<T>::isEmpty() // CHECK EMPTY NO YES?
{
if (count == 0)
return false;
else
return count;
}
template<class T>
void Array<T>::freeExtra() // FREE EXTRA
{
T * buf = new T[this->SIZE - this->grow]();
for (size_t i = 0; i < this->SIZE - this->grow; i++)
{
buf[i] = arr[i];
}
delete[] arr;
arr = new T[this->SIZE - this->grow]();
for (size_t i = 0; i < this->SIZE - this->grow; i++)
{
arr[i] = buf[i];
}
this->SIZE = this->SIZE - this->grow;
}
template<class T>
void Array<T>::removeAll() // CLEAR ALL
{
delete[] arr;
arr = NULL;
this->SIZE = 0;
this->preSIZE = 0;
this->grow = 0;
this->count = 0;
}
template<class T>
T Array<T>::getAt(int index) // GET AT
{
if (index <= count)
return arr[index - 1];
else
return false;
}
template<class T>
void Array<T>::setAt(int index, T element) // SET AT
{
if (index <= count)
{
int iteration = 0;
bool flag = true;
T * buf = new T[SIZE + 1]();
for (size_t i = 0; i < SIZE; i++)
{
if (i != index)
{
buf[iteration] = arr[i];
iteration++;
}
if(i == index && flag == true)
{
buf[iteration] = element;
iteration++;
buf[iteration] = arr[i];
iteration++;
flag = false;
}
}
delete[] arr;
arr = new T[SIZE + 1]();
this->SIZE++;
count++;
for (size_t i = 0; i < this->SIZE; i++)
{
arr[i] = buf[i];
}
delete[] buf;
}
}
template<class T>
T & Array<T>::operator[](int index) // OVERLOAD OPERATOR []
{
if (index <= count)
return this->arr[index];
else
return this->arr[count];
}
template<class T>
void Array<T>::Append(Array<T> ob) // APPEND
{
int temp = this->SIZE + ob.getSize();
int iteration = 0;
T * buf = new T[temp]();
for (size_t i = 0; i < this->SIZE; i++)
{
buf[i] = arr[i];
iteration++;
}
for (size_t i = 0; i < ob.SIZE; i++)
{
buf[iteration] = ob.arr[i];
iteration++;
}
delete[] this->arr;
this->arr = new T[temp]();
for (size_t i = 0; i < temp; i++)
{
this->arr[i] = buf[i];
}
this->SIZE = temp;
this->count = (this->SIZE - this->grow);
delete[] buf;
}
template<class T>
T * Array<T>::getData() // GET POINTER ARR
{
return arr;
}
template<class T>
void Array<T>::insertAt(int index, T element) // INSERT AT
{
if (index <= count)
{
arr[index] = element;
}
}
template<class T>
void Array<T>::showArray()
{
for (size_t i = 0; i < this->SIZE; i++)
{
cout << arr[i] << "\t";
}
cout << endl;
}
template<class T>
Array<T> & Array<T>::operator=(const Array & ob1) // OVERLOAD OPERATOR =
{
this->SIZE = ob1.SIZE;
delete[] this->arr;
this->arr = new T[this->SIZE];
for (size_t i = 0; i < this->SIZE; i++)
{
this->arr[i] = ob1.arr[i];
}
return *this;
}
