322 lines
8.2 KiB
C++
322 lines
8.2 KiB
C++
/*#############################################################################
|
|
## Author: Shaun Reed ##
|
|
## Legal: All Content (c) 2020 Shaun Reed, all rights reserved ##
|
|
## About: An example of a vector implementation using templates ##
|
|
## ##
|
|
## Contact: shaunrd0@gmail.com | URL: www.shaunreed.com | GitHub: shaunrd0 ##
|
|
##############################################################################
|
|
## vector.cpp
|
|
*/
|
|
|
|
#include "vector.h"
|
|
|
|
|
|
/******************************************************************************
|
|
* Constructors, Destructors, Operators
|
|
*****************************************************************************/
|
|
|
|
/** copy constructor
|
|
* @brief Construct a new Vector::Vector object from an existing one
|
|
* Creates a new deep copy of a given Vector
|
|
*
|
|
* @param rhs Vector<T> object
|
|
*/
|
|
template<typename T>
|
|
Vector<T>::Vector(const Vector<T>& rhs)
|
|
{
|
|
if (rhs.getIndex() >= 0) {
|
|
curIndex = rhs.getIndex();
|
|
// Avoid copying over unused indices from parent Vector
|
|
maxSize = rhs.getSize();
|
|
data = new T[curIndex+1];
|
|
for (int i = 0; i <= rhs.getIndex(); i++) {
|
|
data[i] = rhs.getValue(i);
|
|
}
|
|
}
|
|
else {
|
|
curIndex = -1;
|
|
maxSize = 0;
|
|
data = NULL;
|
|
}
|
|
}
|
|
|
|
/** operator=
|
|
* @brief Assign two Vector objects equal using copy constr and class destr
|
|
* Pass the rhs by value to create local copy, swap its contents
|
|
* Destructor called on previous Vector data at the end of this scope
|
|
*
|
|
* @param rhs Vector object passed by value, creating a local variable
|
|
* @return Vector<T> A deep copy of the rhs Vector object
|
|
*/
|
|
template<typename T>
|
|
Vector<T> Vector<T>::operator=(Vector<T> rhs)
|
|
{
|
|
if (this == &rhs) return *this;
|
|
// Swap the pointers, moving the previous head data to the local variable rhs
|
|
std::swap(data, rhs.data);
|
|
curIndex = rhs.getIndex();
|
|
// Use the current size of the vector we are equal to
|
|
// Avoids copying over unused indices
|
|
maxSize = rhs.getSize();
|
|
return *this;
|
|
}
|
|
|
|
/** destructor
|
|
* @brief Destroy the Vector::Vector object
|
|
*/
|
|
template<typename T>
|
|
Vector<T>::~Vector()
|
|
{
|
|
if (!isEmpty()) makeEmpty();
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* Public Member Functions
|
|
*****************************************************************************/
|
|
|
|
/** push
|
|
* @brief Push a value to the end of our Vector
|
|
*
|
|
* @param val The value to be inserted
|
|
*/
|
|
template<typename T>
|
|
bool Vector<T>::push(T val)
|
|
{
|
|
bool inserted = push(val, data);
|
|
if (inserted)
|
|
std::cout << "[" << val << "] was inserted into the vector\n";
|
|
else std::cout << "[" << val << "] could not be inserted into the vector\n";
|
|
return inserted;
|
|
}
|
|
|
|
/** pop
|
|
* @brief returns the value at the Vector::data[curIndex] if it exists
|
|
* Once returned, the curIndex is decremented via data[curIndex--]
|
|
* If the vector is empty, returns INT32_MIN
|
|
*
|
|
* @return T The value held at the Node pointed to by Vector::data[index]
|
|
*/
|
|
template<typename T>
|
|
T Vector<T>::pop()
|
|
{
|
|
T val;
|
|
if (!isEmpty()) {
|
|
val = pop(data);
|
|
std::cout << "[" << val << "] has been popped from our Vector\n";
|
|
}
|
|
else std::cout << "Nothing to pop, our Vector is empty...\n";
|
|
return val;
|
|
}
|
|
|
|
/** makeEmpty
|
|
* @brief Empty this Vector object, deleting all associated data
|
|
*/
|
|
template<typename T>
|
|
void Vector<T>::makeEmpty()
|
|
{
|
|
if (isEmpty()) {
|
|
std::cout << "Cannot makeEmpty, our Vector is already empty...\n";
|
|
return;
|
|
}
|
|
else makeEmpty(data);
|
|
}
|
|
|
|
/** peek
|
|
* @brief returns the value at the end of the vector
|
|
* If the vector is empty, returns INT32_MIN
|
|
*
|
|
* @return T The value held at the current data[index] of the vector
|
|
*/
|
|
template<typename T>
|
|
T Vector<T>::peek() const
|
|
{
|
|
T val;
|
|
if (!isEmpty()) {
|
|
val = peek(data);
|
|
std::cout << "[" << peek(data) << "] is at the end of our vector\n";
|
|
}
|
|
else std::cout << "Nothing to peek, our vector is empty...\n";
|
|
return val;
|
|
}
|
|
|
|
/** isEmpty
|
|
* @brief Determine if the Vector is empty
|
|
*
|
|
* @return true If the Vector::data is NULL
|
|
* @return false If the Vector::data contains any values
|
|
*/
|
|
template<typename T>
|
|
bool Vector<T>::isEmpty() const
|
|
{
|
|
return data == NULL;
|
|
}
|
|
|
|
/** isFull
|
|
* @brief Determine if the Vector is full
|
|
*
|
|
* @return true If the Vector::size is equal to the current index
|
|
* @return false If the Vector::size is greater than the current index
|
|
*/
|
|
template<typename T>
|
|
bool Vector<T>::isFull() const
|
|
{
|
|
return getSize() == getMax() || data == NULL;
|
|
}
|
|
|
|
/** print
|
|
* @brief Output the data held by the Vector object
|
|
* Calls to the private print()
|
|
*/
|
|
template<typename T>
|
|
void Vector<T>::print() const
|
|
{
|
|
if(!isEmpty()) print(data);
|
|
else std::cout << "Nothing to print, our vector is empty...\n";
|
|
}
|
|
|
|
/** getMax
|
|
* @brief Returns the literal maximum size of the vector
|
|
* Not offset to match any index - Vector with max size 3 has indices 0-2
|
|
*
|
|
* @return int at this->maxSize
|
|
*/
|
|
template<typename T>
|
|
int Vector<T>::getMax() const
|
|
{
|
|
return maxSize;
|
|
}
|
|
|
|
/** getSize
|
|
* @brief Returns the current size of the vector
|
|
* AKA the current number of indices being used, NOT the max indices
|
|
*
|
|
* @return int at this->curIndex + 1
|
|
*/
|
|
template<typename T>
|
|
int Vector<T>::getSize() const
|
|
{
|
|
return curIndex + 1;
|
|
}
|
|
|
|
/** getIndex
|
|
* @brief Returns the current index of the vector
|
|
* AKA the last index the vector wrote to
|
|
*
|
|
* @return int at this->curIndex
|
|
*/
|
|
template<typename T>
|
|
int Vector<T>::getIndex() const
|
|
{
|
|
return curIndex;
|
|
}
|
|
|
|
// TODO: use operator[](){...} instead
|
|
|
|
/** getValue
|
|
* @brief Get the value stored at a given index within the vector
|
|
*
|
|
* @param index The index containing the value to be returned
|
|
* @return T The value held at the index given
|
|
*/
|
|
template<typename T>
|
|
T Vector<T>::getValue(int index) const
|
|
{
|
|
return data[index];
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* Private Member Functions
|
|
*****************************************************************************/
|
|
|
|
/** push
|
|
* @brief Private member to handle inserting value into the vector
|
|
*
|
|
* @param val Value to be inserted
|
|
* @param data The data of the vector to push the value into
|
|
*
|
|
* @return true If the value was inserted
|
|
* @return false If the value could not be inserted
|
|
*/
|
|
template<typename T>
|
|
bool Vector<T>::push(T val, T *&data)
|
|
{
|
|
T *temp;
|
|
if (isFull()) {
|
|
if (maxSize <= 0) maxSize = 1;
|
|
else maxSize *= 2;
|
|
temp = new T[maxSize];
|
|
for (int i = 0; i <= curIndex; i++) {
|
|
temp[i] = data[i];
|
|
}
|
|
std::swap(data, temp);
|
|
}
|
|
curIndex += 1;
|
|
data[curIndex] = val;
|
|
return data[curIndex] == val;
|
|
}
|
|
|
|
/** pop
|
|
* @brief Returns the value held at the last index within the Vector
|
|
* Decrements the curIndex after storing the value to be returned
|
|
*
|
|
* @param data The Vector data to modify
|
|
* @return T The value stored at the index removed from the end of the Vector
|
|
*/
|
|
template<typename T>
|
|
T Vector<T>::pop(T *&data)
|
|
{
|
|
// We already know the vector is not empty from public pop()
|
|
T val = data[curIndex--];
|
|
if (curIndex < 0) makeEmpty(data);
|
|
return val;
|
|
}
|
|
|
|
/** makeEmpty
|
|
* @brief Private member to empty Vector object, deleting all associated data
|
|
*
|
|
* @param data The data of the Vector to be deleted
|
|
*/
|
|
template<typename T>
|
|
void Vector<T>::makeEmpty(T *&data)
|
|
{
|
|
delete[] data;
|
|
maxSize = 0;
|
|
curIndex = -1;
|
|
data = NULL;
|
|
}
|
|
|
|
/** peek
|
|
* @brief Private member to display the value at the end of our Vector
|
|
*
|
|
* @param data The Vector data to peek
|
|
* @return T The value stored at the end of the Vector
|
|
*/
|
|
template<typename T>
|
|
T Vector<T>::peek(T *data) const
|
|
{
|
|
// We already know the vector is not empty from public peek()
|
|
return data[curIndex];
|
|
}
|
|
|
|
/** print
|
|
* @brief Output the contents of a Vector from the beginning to the end
|
|
*
|
|
* @param data The data within the Vector to output
|
|
*/
|
|
template<typename T>
|
|
void Vector<T>::print(T *data) const
|
|
{
|
|
std::cout << "Vector Contents: ";
|
|
for (int i = 0; i <= curIndex; i++) {
|
|
std::cout << data[i] << " | ";
|
|
}
|
|
std::cout << std::endl;
|
|
}
|
|
|
|
// Instantiate relevant type templates for this class
|
|
template class Vector<int>;
|
|
template class Vector<float>;
|
|
template class Vector<std::string>;
|