//-----------------------------------------------------------------
// Author:	Zhixiang Chen
// Class:	CSCI/CMPE 2380, Spring 2009
// Lab 7:	Destructor under inheritance vs. virtual destructor
//			Also, watch the chain reaction of constructor/desctructor calling
// Date:	January, 2009
// Comment: The code here is meant to be revised.
//
//----------------------------------------------------------------- 
//
// This lab exercise is practice virtual destructor
//
// Compile and run your program. When everything is fine,
// print your .cpp and .h files and turn them to me or the TA.
// *****************************************************************

#include < iostream >
#include < fstream >
#include < string >
#include < cstring >
#include < cmath > 
#include < cstdlib >
#include < iomanip >
#include < vector >
#include <cassert>

#include "lab2380_7_head.h" 

using namespace std; 

bool fun();					//define function fun

int main()
{	
	bool tag = false; 
	int i=0;
	
	/*****************************************************************************
	 Part One: Test non-virtual destructor
	 *****************************************************************************/
	
	while(i<10)
	{
		tag = fun();				//inside fun, a class D object is created.
									//once outside fun, this object dies and the destructor 
									//is called to deallocated memory 
		i++;
		cout<<"This is the end of iteration "<< i <<endl
			<<"Can you see D's destructor was called? "<<endl<<endl; 
		
		if(!tag)
		{
			cout<<"Test is done. Memory is running out."<<endl; 
			break; 
		}
	}

	/*************************************************************************
	 Part Two: For you to complete.
		When polymorphism comes into the play, you got to be very careful about 
		the destructors to deal with dynamic memeory allocation. 
		The key point is that when a base class pointer is dynamically bound to 
		a derived class object. The destructor of the derived class is not bound
		to the pointer, UNLESS virtual desctructor is used. 

		Try to use virtual destructor to re-do Part One and test whether you can
		see D's destructor.

		How to submit this lab?
		Turn in your code plus the written observations from your practice.

	 *************************************************************************/




	//complete the program 
	return 0; 
}

bool fun()
{
	B* p;					//base class pointer p
	p=new D;				//dynmic binding of p to derived class object
	
	if (p)					//make sure p got memory allocated
	{
		delete p;
		cout<<"Yes, p got memory .... Alive ....." <<endl; 
		return true; 
	}
	else 
	{
		cout<<"Running out memory .... Die...."<<endl; 
		return false; 
	}
}