[d0nni]

Hi, im working through some online tutorials at the moment and ive gotten stuck when it comes to the pointers/arrays.
i have a Struct called transaction containing

#pragma once

#include <string>
using std::string;

///////////////////////////////////////////////////////////////////////////////
// Stock Buy Transaction                  								     //
///////////////////////////////////////////////////////////////////////////////

/**
 * Stock sell transaction
 */
struct Transaction
{
	string stockSymbol;		// String containing the stock symbol, e.g. "AAPL"
	string buyerName;		// String containing the buyer's name e.g. "Mr Brown"
	int buyerAccount;		// Integer containing an eight digit account code
	int numShares;			// Integer containing the number of sold shares
	int pricePerShare;		// Integer containing the buy price per share
};

im looking to initialize this struct using

Analyser::Analyser(Transaction* transactions, int numTransactions)

problem is i dont have a clue how? />

i have this

	/**
	 * Build a random transaction
	 */	 
	static Transaction* buildTransactions(int numTransactions)
	{
		int maxShareVolume = 100000;
		int maxSharePrice = 1000;

		Transaction *transactions = new Transaction[numTransactions];

		for(int idx = 0; idx < numTransactions; idx++)
		{
			transactions[idx].stockSymbol = pickRandomStockSymbol();

			std::string buyerName = pickRandomBuyer();
			transactions[idx].buyerName = buyerName;
			transactions[idx].buyerAccount = lookupBuyerAccount(buyerName);

			transactions[idx].numShares = 1 + rand() % maxShareVolume;
			transactions[idx].pricePerShare = 1 + rand() % maxSharePrice;		
		}

		return transactions;
	}

within a file they called setup. im not quite sure how relivant this is?

very new to c++ so if anyone could help it would be great.

[#define]

The buildTransactions builds an dynamic array with numTransactions elements.

04  static Transaction* buildTransactions(int numTransactions)

The dynamic array

09    Transaction *transactions = new Transaction[numTransactions];

It inserts some data into the array as well.


You can create a Transaction pointer in a calling function, to point to the array. The array can then be passed to your Analyser variable/object at construction.

  const int NUMBER = 3;

  Transaction *transactions;

  transactions = buildTransactions(NUMBER);

  Analyser analyser(transactions, NUMBER);

  ...

  delete[] transactions;

[d0nni]

I had a feeling if it was to initialize the array it would have to be in the form of a loop and not a constant int?

how would i write this if it was to initialize it within the

Analyser::Analyser(Transaction* transactions, int numTransactions)

constructor?

i think what the pointer is to do is to point to the first of the array and run thought it? that was my understanding of it anyway?

I emailed the author of the problem and they replied with this "As to the constructor, it basically accepts an array of Transaction instances. They are been passed to the constructor using a pointer – which points to the start of the array (i.e the first element in the array) and a counter which tells you the size of the array. By incrementing the pointer you can pointer to the other elements in the array."

[#define]

d0nni, on 18 March 2013 - 09:16 PM, said:

I had a feeling if it was to initialize the array it would have to be in the form of a loop and not a constant int?

If you look at the function buildTransactions it creates an array of size = numTransactions. I used a constant it doesn't have to be a constant, it makes some sense though. In the function the array is also initialized with some random data.

d0nni, on 18 March 2013 - 09:16 PM, said:

how would i write this if it was to initialize it within the

Analyser::Analyser(Transaction* transactions, int numTransactions)

constructor?

Do you you mean in the call to the constructor or in the constructor function?
Do you mean create the array or initializing the array, or both?
Why would you want to that? That limits the use of the Analyse class.

d0nni, on 18 March 2013 - 09:16 PM, said:

i think what the pointer is to do is to point to the first of the array and run thought it? that was my understanding of it anyway?

Just as easy to use [] as in buildTransactions :

11	    for(int idx = 0; idx < numTransactions; idx++)
12	    {
13	        transactions[idx].stockSymbol = pickRandomStockSymbol();

d0nni, on 18 March 2013 - 09:16 PM, said:

I emailed the author of the problem and they replied with this "As to the constructor, it basically accepts an array of Transaction instances. They are been passed to the constructor using a pointer – which points to the start of the array (i.e the first element in the array) and a counter which tells you the size of the array. By incrementing the pointer you can pointer to the other elements in the array."

If you are determined to use a pointer something like :

Analyser::Analyser(Transaction* transactions, int numTransactions)
{
  for(int idx = 0; idx < numTransactions; idx++, transactions++)
  {
    cout << transactions->stockSymbol << endl;
  }  
}

[d0nni]

see the question is based on pointers and arrays, thats why trying to stick to that.

"
Analyser(Transaction* transactions, int numTransactions);

Constructor that accepts a pointer to an array of Transaction instances. The size of the array is specified. The function can assume that a validly sized array will be passed."

thats the first part of the question being asked. i just dont really understand what they are asking. i had figured it would have been constructed similar to the build transactions.

i had

Analyser::Analyser(Transaction* transactions, int numTransactions)
{
  for(int idx = 0; idx < numTransactions; idx++, transactions++) 

but its what to throw into it which i dont understand, i donno if its just me or its the wording of the question.

[#define]

It depends what you want to do with your Analyse class.

You could just store the pointer address to the array and the number of elements, then use them later in the class.

[d0nni]

i think thats all i have to do at the moment in the analyse class, cause there are two other classes after which are setTransaction and addTransaction. the set transaction completely replaces any transactions with the new transactions placed. and the addTransaction just adds a new transaction onto the array.

[d0nni]

what way would the analyse class be if it was to just store the pointer address to the array and the number of elements?

[#define]

Have a go at writing some of the class and adding in the member variables.

Classes

[d0nni]

im just so confused lol. The way im reading the guideline "As to the constructor, it basically accepts an array of Transaction instances. They are been passed to the constructor using a pointer – which points to the start of the array (i.e the first element in the array) and a counter which tells you the size of the array. By incrementing the pointer you can pointer to the other elements in the array."

if i was to break it down this is my understanding of it.

Analyser::Analyser(Transaction* transactions, int numTransactions) <-- that is the class accepting the array of transaction instances, being passed using the pointer.

for(int idx = 0; idx < numTransactions; idx++, transactions++) <-- this is it pointing to the start of the array, and incrementing the pointer as it goes through the array.

{ } after the for. i donno what im supposed to throw in. my immediate thought would be to collect the variables from the transaction struct, and throw them here. sort of like this:

string stockSym = stockSymbol; // String containing the stock symbol, e.g. "AAPL"
string buyerNM = buyerName; // String containing the buyer's name e.g. "Mr Brown"
int buyerACC = buyerAccount; // Integer containing an eight digit account code
int numShar = numShares; // Integer containing the number of sold shares
int PPS = pricePerShare; // Integer containing the buy price per share

assuming that by doing so that would allow me to edit the array from the analyser.cpp class?

[d0nni]

Analyser::Analyser(Transaction* transactions, int numTransactions)
{
	string stoSym;
	string buyNm;
	int buyAcc;
	int numShare;
	int PPS;

	 for(int idx = 0; idx < numTransactions; idx++, transactions++)
  {

	transactions[idx].stockSymbol = stoSym;
	transactions[idx].buyerName = buyNm;		// String containing the buyer's name e.g. "Mr Brown"
	transactions[idx].buyerAccount = buyAcc;		// Integer containing an eight digit account code
	transactions[idx].numShares = numShare;			// Integer containing the number of sold shares
	transactions[idx].pricePerShare = PPS;

  } 
}

??? lol

[#define]

The array of transactions stays outside of the class, but the pointer allows access to the array.

class Analyser 
{
  private:
    Transaction* m_transactions;
    int m_numTransactions;

  public:
    Analyser::Analyser(Transaction* transactions, int numTransactions);

    void display();

};


// constructor : 
//   copy pointer to array 
//   copy number of elements in the array
Analyser::Analyser(Transaction* transactions, int numTransactions) 
{
  m_transactions = transactions;
  m_numTransactions = numTransactions;
}

I imagine you would only need to edit one element/transaction at a time.

How do you want to indicate which transaction to edit? By an index value to the array?

[d0nni]

i would imagine so, kinda have like have a cout << "Enter the Transaction you would like to edit: "; with a cin of the transaction number so would be like transaction[idx+1] to index it to that transaction?

[jjl]

You should look at the differences between deep copy and shallow copy and see which one applies to your assignment.

#define shows an example of a shallow copy, a deep copy involves physically coping the memory rather than just copying the pointer address. Deep copying is probably what the assignment requires to preserve encapsulation.

[#define]

I would have a function in the class something like :

  void edit(int index);

So you can ask for the index outside of the class and pass it to the function. This gives you an option to use the function after searching for a stock perhaps.

If you display the transactions you could display an index value.