Question

I’m aware that I could use something called std::vector, but I’m afraid it’s not possible because of the course restrictions.

I need to make a dynamic extensible array of objects. The array should grow and grow when new objects need to be stored.

Here is the class that the array belongs to:

class TransactionList
{
    private:
        Transaction *trans;
        int amountTransactions;
        Transaction newTrans;

    public:
        TransactionList();
        ~TransactionList();
        void read( istream &is );
        void write( ostream &os );
        void add( Transaction & newTrans ); 
        double totalExpenses();
        double hasPaid( string namnet );
        double isDebted( string namnet );
        //PersonList FixPersons();
 };

The method “void add ( Transaction & newTrans )” is the one I need. And yes, I seriously have to do it pointer-style.

So far this method is totally incomplete and just not even close to functional. I’ve tried several different ways, but end up with a runtime error or just bollocks result.

void TransactionList::add(Transaction & newTrans)
{
    Transaction* tempArrPtr;

    amountTransactions++;
    trans = new Transaction[amountTransactions]
    trans[amountTransactions - 1] = newTrans;
}

What I want the method to do is to build an array of of Transaction-objects and grow in size while it gets more objects.

I hope I’ve written about my problem clearly and wish someone could give me a good answer.
I tried Googling, but I’m still stuck – otherwise I wouldn’t have bothered asking :p

Also if someone could give some pointers about copy constructors, I’d be very thankful. In our course material they pretty much didn’t even show what a copy constructor should look like. Just like “You need copy constuctors for deep copying, good luck!”

Answer 1

You should add a maxTransactions variable, which would indicate the allocated length of your trans* array, and initialize both ammountTransactions and maxTransactions with 0.

Your array would automatically double its size when we reach the limits of trans

void TransactionList::add(Transaction & newTrans)
{
    if(amountTransactions == maxTransactions){ //we've reached the capacity of trans
        //allocate a new array
        Transaction* nuTrans = new Transaction[maxTransactions*2+1];
        //copy the old values of trans into nuTrans
        memcpy(nuTrans, trans, sizeof(Transaction)*maxTransactions);
        //deallocate the old trans array
        delete []trans;
        //set trans to point at your newly allocated array
        trans = nuTrans;
        //update maxTransactions
        maxTransactions = maxTransactions*2+1;
    }

    trans[amountTransactions] = newTrans;
    amountTransactions++;
}

PS. I wrote it directly here, I didn’t check it if it compiles as a whole or didn’t debug the code. But I present it as an idea you could follow

Edit: Working example @ http://ideone.com/uz1mE