I have tried changing the transactionVector to contain doubles instead of transaction objects and I get the same error message. There doesn't seem to be anything wrong with the push_back function itself because I have tried declaring it in main and using push_back on it and it works fine. The SimpleVector is something I got from a book and I added push_back to it.
When I try to push_back a transaction onto the transaction vector in my makeWithdrawal function in Account.cpp, that is where I get a red squiggly line
#ifndef ACCOUNT_H
#define ACCOUNT_H
#include <string>
#include <iomanip>
#include <iostream>
//forward declared dependencies
class Withdrawal;
class Transaction; //need this to have SimpleVector of Transactions as a member
//included dependencies
#include "SimpleVector.h"
usingnamespace std;
class Account
{
private:
string firstName;
string lastName;
//can't have a static int as account number because all the accounts
//read from the file will have the same account number as the last account read from the file
staticint accountNumberIncrementor; //starts at 100000000 and is incremented every time an account is made
int accountNumber;
string password;
double balance;
int numTransactions;
SimpleVector<Account>transactionVector();
public:
//constructor
Account(void);
//member functions
void makeWithdrawal();
void makeDeposit();
void writeCheck();
double getTransactionAmount(int transactionNumber);
bool validateLogin(int givenAccountNumber, string givenAccountPassword);
void displayUserInfo();
void showTransactions();
//destructor
~Account(void);
};
#endif
// 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
usingnamespace 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
//int back; // holds index of last array element
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[](constint &);
//calling paramater dataItem instead of value (like in the stl vector) so that
//in comments I won't have to say weird things like "the value of value"
void push_back(T dataItem);
};
//***********************************************************
// 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.
//This code is causing problems with making a vector of acounts
//because an account object can't be set to zero
//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- *
// cript 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[](constint &sub)
{
if (sub < 0 || sub >= arraySize)
subError();
return aptr[sub];
}
template <class T>
void SimpleVector<T>::push_back(T dataItem)
{
// Copy the array size and add 1 to hold the new element
int newArraySize = this->arraySize + 1;
T* newTempArrayPtr;
// Allocate memory for the new array.
newTempArrayPtr = new T [newArraySize];
if (aptr == 0)
{
memError();
}
//copy elements of original array to new temporary array
for (int i = 0; i < arraySize; i++)
{
newTempArrayPtr[i] = aptr[i];
}
//set value in last index of newTempArrayPtr to be value of dataItem
newTempArrayPtr[newArraySize - 1] = dataItem;
//change SimpleVector's member variable arraySize to be the size of the new array
arraySize = newArraySize;
//make aptr point to address of the array that newTempArrayPtr points to
aptr = newTempArrayPtr;
}
#endif
