//freestore.cpp
//how to use the freestore
#include<iostream>
  //cout, cin, endl
  //istream, ostream
using namespace std;

#include<iomanip>
  //setw

class Pairs {
  public:
    Pairs()
      {cout << "Making a pair.\n";
       set();}
    ~Pairs()
      {cout << "destroying the pair "
            << *this << endl;}

    void set (int xval=0, int yval=0)  //default parameters
      {x=xval; y=yval;}
  private:
    int x,y;

    //friends aren't member functions
    //but are given the key to private
    //data and private functions.
    friend istream&
      operator>>(istream& infile, Pairs& p);
    friend ostream&
      operator<<(ostream& outfile, Pairs & p);
  }; //end pairs


//implementation of pairs friend functions
//Since not members, don't start with
//Pairs::

istream& operator>>(istream& infile, Pairs& p)
  {
  char dummy; 
  infile >> dummy >> p.x >> dummy  >> p.y >> dummy;
  return infile;
  }

ostream& operator<<(ostream& outfile, Pairs & p)
    //Pairs & p keeps it from making another p,
    //whose destructor will be called, etc...
  {
    outfile << '(' << p.x << ',' << p.y << ')';
  return outfile;
  }

int main()
  {
  int * pInt=0;
  pInt=new int;  //one int on the freestore
  *pInt=7;
  cout << "the nameless int is " << *pInt
    << endl;
  delete pInt;
    //doesn't delete the pointer (which is on the stack)
    //but deletes what the pointer is pointing to
    
  //cout << *pInt;  //dereferencing a dangling pointer - bad
  pInt=0;  //do this when you delete so you can test it.
  //cout << *pInt;  //dereferencing a null pointer - bad
  if (pInt!=0)  //testing for a null pointer - good
    cout << *pInt;
  
  int arraysize=4;
  pInt=new int[arraysize];  
     //Notice you can use a variable for
     //the array size here. 
  pInt[0]=5;
  pInt[1]=10;
  cout << "Good stuff from the freestore: ";
  cout << setw(5) << pInt[0] << setw(5) <<pInt[1] << endl;
  cout << "Junk from the freestore: ";
  cout << setw(5) << pInt[2] << endl;
  int * pList=0;
  pList=pInt; //Now the array has two names.
    //This does NOT copy the array, even though
    //it appears to.
  cout << "Good stuff from the freestore: ";
  cout << setw(5) << pList[0] << setw(5) <<pList[1] << endl;
  //Beware:  the list was not copied
  pList[1]=-89;
  cout << "pList[1]= " << pList[1];
  cout << " pInt[1]= " << pInt[1] << endl;
  if (pInt!=0)
    delete[ ] pInt;  //deletes the entire array
  //cout << pList[1];  //dangling pointer - bad
  //if (pList!=0)
    //delete[ ] pList;  //can't delete a dangling pointer
                           //even testing for 0 doesn't help here
  pInt=0;
  pList=0;

  int step;
  pInt=new int[6]; //now a different size
  pList=new int[6];  //two different arrays
  pInt[0]=1;
  for (step=1; step<6; step++)
     pInt[step]=pInt[step-1]*3;
  for (step=0; step<6; step++)
     pList[step]=pInt[step];
  //Now there are two arrays with identical data;
  cout << setw(10) << "step" << setw(15) << "pList" 
     << setw(15) << "pInt" << endl;
  for (step=0; step<6; step++)
    cout << setw(10) << step << setw(15) << pList[step]
         << setw(15) << pInt[step] << endl;
  //Both now need to be deleted separately
  if (pInt!=0)
     delete[ ] pInt;
  pInt=0;
  cout << "pList[1]= " << pList[1] << endl;
  if (pList!=0)
     delete[ ] pList;
  pList=0;

  Pairs * pPairs = 0;
  pPairs=new Pairs;
  cout << "default pair: " << *pPairs << endl;
  pPairs->set(5);  //use -> for (* ).
    //who gets the 5, x or y?  ans: x, leftmost parameter
  cout << "partially set pair: " << *pPairs << endl;
  pPairs->set(10,20);
  cout << "set pair: " << *pPairs << endl;
  //We should delete pPairs, but don't.
  //We are about to get a memory leak.
  
  pPairs = new Pairs[3];
    //an array of 3 pairs on the freestore
  cout << "Default values used: \t" << pPairs[0] << '\t'
    << pPairs[1] << '\t' << pPairs[2] << endl;
        //which of the above << are Pairs::operator<<?
  cout << "Enter 3 pairs. (#,#)";
  cin >> pPairs[0] >> pPairs[1]  >> pPairs[2];
  cout << "The pairs are\n";
  int i;
  for (i=0;i<3;i++)
    cout << pPairs[i] << endl;
 
  delete [ ] pPairs;
  pPairs=0;
  
  pPairs=new Pairs[5];
  pPairs[0].set(3,4);
  pPairs[1].set(9,8);
  //delete pPairs;  //Left out the [ ]
  //Deletes only pPairs[0].
  //Cuts off access to rest of the array,
  //creating a memory leak - bad.
  //Will crash some systems.

  return 0;
  }