[jason999x]

I have been able to find things on how to do these things iteratively, but I need to know how to do it recursively... couldn't find any such thing.

prototype from .h:

Item* FindR(string name, ListNode* node);
Item* InsertSortR(string name, ListNode* &node);

prototype of Portfolio.h based on this project I'm doing

class Portfolio
{
    private:
       // there may or may not be private members, not sure yet
       // unless this list of stocks counts
       struct StockListNode
       {
          Stock item;
          StockListNode *next;
       };
       StockListNode* head;

   public:
       void Buy(ifstream& in);
       void Sell(ifstream& in);
    
       Stock* FindR(string name, StockListNode* node);
       Stock* InsertSortR(string name, StockListNode* &node);
       void ReportR(StockListNode *node);
}

I will also show all the code I have written so far on this. There are a total of three classes: Portfolio, Stock, and Transaction. The Portfolio contains a linked list of Stocks. Each Stock contains a linked list of all the Transactions on it. Note that there are also two kinds of transaction methods on Stock class... I don't get why there needs to be a recursive method there too (in other words, why two add transaction functions)?

// Portfolio.h

#ifndef "Portfolio.h"
#define "Portfolio.h"

using namespace std;

class Portfolio
{
    public:

        Portfolio();
        ~Portfolio();

        void Buy(ifstream& in);
        void Sell(ifstream& in);
        Stock* FindR(string name, StockListNode* node);
        Stock* InsertSortR(string name, StockListNode* &node);
        void ReportR(StockListNode *node);

    // don't know any of this part yet...
    // private:
    //  struct StockListNode;
}

// Portfolio.cpp

#include "Portfolio.h"

using namespace std;

Portfolio::Portfolio()
{
    // blank constructor
}

Portfolio::~Portfolio()
{
    // now what do I delete here?
    // in this destructor?
    // my guess: delete *StockListNode;
    // probably some variant of that
}

void Portfolio::Buy(ifstream& in)
{
    // question for myself: why the hell do we use
    // "ifstream& in" and not "ifstream in"...?
    // seriously what the hell is the point of that?

    // uses FindR - find the stock in the first place

    // uses InsertSortR - insert a new stock with
    // whatever information if FindR fails
    // (no such stock is already in list?)

    // FindR(stock);
    // if !FindR(stock)
    // {
    //  InsertSortR(newstock);
    // }
    // stock->tickerSymbol = tickerSymbol;
    // stock->price = price;
    // // etc....
}

/*
okay NOW i get how this mechanism works...
buy:    if stock not there, create it
    if stock there, buy MORE OF IT
sell:   if stock there, sell it
    if stock not there, error
*/

void Portfolio::Sell(ifstream& in)
{
    // FindR(stock);
    // if !FindR(stock)
    // {
    //  cerr << "Stock not found."
    // }
}

Stock* FindR(string name, StockListNode* node)
{
    // returns a POINTER to a Stock,
    
    // this is supposed to be RECURSIVE
    // Mean Kong supplies an ITERATIVE
    // version of this function, but it's up to
    // me to make a recursive version of this

    // question for myself: how do I implement
    // this recursively?
}

Stock* InsertSortR(string name, StockListNode* &node)
{
    // question for myself: how do I implement
    // this recursively?
}

void ReportR(StockListNode *node)
{
    // this involves the recursive
    // "transverse a list"
}

// so there a total of three recursive things
// to implement in this program... four
// if you count the separate transverse
// method in the later Transaction class 
 

// Stock.h

class Stock
{
    public:
        void addTransaction(Transaction *transaction);
        void addTransactionR(Transaction *transaction, TransactionListNode* &node);

    private:
        string tickerSymbol;
        string date;
        // int shares;
          // does int shares go here?
        // or in "Transaction"?
        double currentPrice;

    /* possible here...
        struct TransactionListNode
        {
            Transaction whatever;
            Transaction *next;
        }
    */
}

// Stock.cpp

#include "Stock.h"

using namespace std;

Stock::Stock()
{
}

Stock::~Stock()
{
}

void Stock::addTransaction(Transaction *transaction)
{
}

void Stock::addTransactionR(Transaction *transaction, TransactionListNode* &node)
{
}

// Transaction.h

#ifndef "Transaction.h"
#define "Transaction.h"

class Transaction
{
    public:

}

// Transaction.cpp

#include "Transaction.h"

using namespace std;

// main.cpp

#include <iostream>
#include <fstream>

using namespace std;
// seriously, I am doing it this way...
// that way we all know that every file in this program
// uses namespace std

int main(int argc, char* argv[])
{
    // open file, I guess here...
    // filename = argv[1]
    // if argc < 2, print out:
    // Usage: main <inputfile>

    return 0;
}

/* 
    question to ask:
    does the file handling still go on here in main?
*/