Creating a "push_back" Function for Array - c++

Question

My assignment is to create push_back and pop_back functions for a SimpleVector which have to do basically what you imagine they have to do. I'm trying to add an element to an existing array in this fashion but it isn't working. It adds 0 instead of the number I pass in in main. Any ideas as to why?
SimpleVector.h
// SimpleVector class template
#ifndef SIMPLEVECTOR_H
#define SIMPLEVECTOR_H
#include <iostream>
#include <new> // Needed for bad_alloc exception
#include <cstdlib> // Needed for the exit function
using namespace std;
template<class T>
class SimpleVector
{
private:
T *aptr; // To point to the allocated array
int arraySize; // Number of elements in the array
void memError(); // Handles memory allocation errors
void subError(); // Handles subscripts out of range
public:
// Default constructor
SimpleVector()
{
aptr = 0;
arraySize = 0;
}
// Constructor declaration
SimpleVector(int);
// Copy constructor declaration
SimpleVector(const SimpleVector &);
// Destructor declaration
~SimpleVector();
// Accessor to return the array size
int size() const
{
return arraySize;
}
// Accessor to return a specific element
T getElementAt(int position);
// Overloaded [] operator declaration
T &operator[](const int &);
void push_back(SimpleVector, int);
void pop_back(SimpleVector, int);
};
//***********************************************************
// Constructor for SimpleVector class. Sets the size of the *
// array and allocates memory for it. *
//***********************************************************
template<class T>
SimpleVector<T>::SimpleVector(int s)
{
arraySize = s;
// Allocate memory for the array.
try
{
aptr = new T[s];
}
catch (bad_alloc)
{
memError();
}
// Initialize the array.
for (int count = 0; count < arraySize; count++)
*(aptr + count) = 0;
}
//*******************************************
// Copy Constructor for SimpleVector class. *
//*******************************************
template<class T>
SimpleVector<T>::SimpleVector(const SimpleVector &obj)
{
// Copy the array size.
arraySize = obj.arraySize;
// Allocate memory for the array.
aptr = new T[arraySize];
if (aptr == 0)
memError();
// Copy the elements of obj's array.
for (int count = 0; count < arraySize; count++)
*(aptr + count) = *(obj.aptr + count);
}
//**************************************
// Destructor for SimpleVector class. *
//**************************************
template<class T>
SimpleVector<T>::~SimpleVector()
{
if (arraySize > 0)
delete[] aptr;
}
//*******************************************************
// memError function. Displays an error message and *
// terminates the program when memory allocation fails. *
//*******************************************************
template<class T>
void SimpleVector<T>::memError()
{
cout << "ERROR:Cannot allocate memory.\n";
exit(EXIT_FAILURE);
}
//***********************************************************
// subError function. Displays an error message and *
// terminates the program when a subscript is out of range. *
//***********************************************************
template<class T>
void SimpleVector<T>::subError()
{
cout << "ERROR: Subscript out of range.\n";
exit(EXIT_FAILURE);
}
//*******************************************************
// getElementAt function. The argument is a subscript. *
// This function returns the value stored at the sub- *
// script in the array. *
//*******************************************************
template<class T>
T SimpleVector<T>::getElementAt(int sub)
{
if (sub < 0 || sub >= arraySize)
subError();
return aptr[sub];
}
//*******************************************************
// Overloaded [] operator. The argument is a subscript. *
// This function returns a reference to the element *
// in the array indexed by the subscript. *
//*******************************************************
template<class T>
T &SimpleVector<T>::operator[](const int &sub)
{
if (sub < 0 || sub >= arraySize)
subError();
return aptr[sub];
}
#endif
template<class T>
void SimpleVector<T>::push_back(SimpleVector obj, int newval)
{
arraySize = obj.arraySize + 1;
// Allocate memory for the array.
aptr = new T[arraySize];
if (aptr == 0)
memError();
// Copy the elements of obj's array.
for (int count = 0; count < (arraySize - 1); count++)
*(aptr + count) = *(obj.aptr + count);
obj.aptr[(arraySize)] = newval;
}
main.cpp
// This program demonstrates the SimpleVector template.
#include <iostream>
#include "SimpleVector.h"
using namespace std;
int main()
{
const int SIZE = 10; // Number of elements
int amtToPrnt = 10;
int count; // Loop counter
// Create a SimpleVector of ints.
SimpleVector<int> intTable(SIZE);
// Store values in the two SimpleVectors.
for (count = 0; count < SIZE; count++)
{
intTable[count] = (count * 2);
}
// Display the values in the SimpleVectors.
cout << "These values are in intTable:\n";
for (count = 0; count < amtToPrnt; count++)
cout << intTable[count] << " ";
cout << endl;
intTable.push_back(intTable, 20);
cout << "These values are in intTable after adding one more value:\n";
for (count = 0; count < ++amtToPrnt; count++)
cout << intTable[count] << " ";
cout << endl;
/*
intTable.push_back(intTable, 22);
cout << "These values are in intTable after adding one more value:\n";
for (count = 0; count < ++amtToPrnt; count++)
cout << intTable[count] << " ";
cout << endl;
intTable.push_back(intTable, 24);
cout << "These values are in intTable after adding one more value:\n";
for (count = 0; count < ++amtToPrnt; count++)
cout << intTable[count] << " ";
cout << endl;
*/
return 0;
}

Answer 1

SimpleVector.h
void push_back(int);
I remove SimpleVector to reduce memory usage.
template <class T>
void SimpleVector<T>::push_back(int newval){
// Allocate memory for the array in the temporary array.
T * tmpArray = new T [arraySize + 1];
// Copy the elements of old array.
for(int count = 0; count < arraySize; count++)
*(tmpArray + count) = *(aptr + count);
// Push new value
*(tmpArray + arraySize) = newval;
// Delete old array
delete[] aptr;
// Copy array
aptr = tmpArray;
// Increase size
arraySize++;
}
main.cpp
intTable.push_back(20);
amtToPrnt++;
cout << "These values are in intTable after adding one more value:\n";
for (count = 0; count < amtToPrnt; count++)
cout << intTable[count] << " ";
cout << endl;
Result :
Side note:
You should refactor your SimpleVector. Don't use pass by value if you didn't need it. And I suggest to made the arraySize public to know how many data are in your vector.

Answer 2

SimpleVector<T>::push_backis a bit of a wreck. Let's take a look, shall we?
void SimpleVector<T>::push_back(SimpleVector obj, int newval)
SimpleVector obj is passed by value, so the obj operated on is a copy. Recommend passing by reference. But why do this in the first place? What use is a push_back that pushes back a SimpleVector AND a new value? Recommend rethinking this approach.
{
arraySize = obj.arraySize + 1;
// Allocate memory for the array.
aptr = new T[arraySize];
OK. That's all good. Except, what if aptr already pointed at memory? You'd have to delete[] that first, but then what would you copy? Recommend working with a temporary variable here and assigning the temporary after the copying and deleting is finished.
if (aptr == 0)
memError();
This will never happen. new throws bad_alloc on allocation errors so the program will never get here if new failed. Earlier the program did this:
try
{
aptr = new T[s];
}
catch (bad_alloc)
{
memError();
}
It's very likely you want to do it again.
It is also bad form to use 0 in place of nullptr. 0 is a magic number AND it's not a pointer.
// Copy the elements of obj's array.
for (int count = 0; count < (arraySize - 1); count++)
*(aptr + count) = *(obj.aptr + count);
All groovy. Nothing to see here other than clunky-looking pointer arithmetic where aptr[count] would have sufficed. However as outlined above, this is unexpected behaviour for a push_back function.
obj.aptr[(arraySize)] = newval;
obj is still obj.arraySize sized and arraySize is one bigger. Next, the array is indexed 0..obj.arraySize-1, so this writes not one, but two elements past the end of the array and invokes undefined behaviour. Who knows what will result from doing this? I sure don't.
Next, it modifies obj which is a copy that is about to be destroyed. I suspect *(aptr + arraySize - 1) = newval; would be more useful.
}
While I was writing this a perfectly serviceable what to do answer went up. Refer to it.
Optimization: Instead of always increasing by 1, why not save yourself a lot of resizing and copying and increase the size by a factor of two?

Answer 3

When you call push_back, the first parameter is passed by value. In other words, a temporary copy is created. Then you allocate a new array (without deleting the original - memory leak!) and change the ptr in this to the new array. Fine, but then you put the new value into the temporary vector, which is destroyed after returning from the function.