Midterm Assignment Morgan Stanley C++ Part II

Your assignment for the midterm is to create several exception classes, derived from a base exception class. While you may have seen examples of this before, one important difference between this and previous examples is that this class will automatically maintain an exception stack.

An exception stack is a data structure that maintains a list of all exceptions that have occurred in succession. In otherwords, when a high-level operation fails, it usually fails because a function it called failed. The function that was called, may have failed because a function that it called failed, and so on. The goal of the exception stack is to keep all of the exceptions (failures) in an exception stack, so that they can be reviewed if the user wishes.

The exception stack will give a program the ability to simply inform the user that the program is unable to perform an operation, without cryptic messages. But it also gives a programmer more detailed information about exactly what chain of events caused the operation to fail.

Your test program for your exception classes should be the following:

int Prompt( char* Prompt, char* AllowedResponses )
{
char Ch;
do {
cout << Prompt;
cout.flush();
cin >> Ch;
Ch = toupper(Ch);
} while( strchr( AllowedResponses, Ch ) == 0 );
return( Ch );
}

void FuncB()
{
throw new MSCUMemExcept( __LINE__, __FILE__);
}
void FuncA()
{
try {
FuncB();
}
catch(...) {
throw new MSCUFileExcept( __LINE__, __FILE__, "Can't open", "bogus.txt" );
}
}

void main()
{
try {
FuncA();
}
catch( MSCUExcept* E ) {
if( Prompt( "Unable to perform operation. Want details?", "YN" )=='Y')
MSCUExcept::Dump( cout, false );
//E = 0; // To satisfy compiler
}
catch( ... ) {
cout << "Unexpected exception?" << endl;
}
}

If this program is run, and the user replies 'Y' to the 'Want Details' prompt, then a list of every exception (two, in our demo) which has occured should be displayed. The output of this program, on my demo program, was:
Unable to perform operation. Want details?Y
C:\Work\MS\cpp2\midexcp\midexcp.cpp: 121
Can't open[bogus.txt]

C:\Work\MS\cpp2\midexcp\midexcp.cpp: 111
Out of memory

The Base Exception class: MSCUExcept
The base exception class serves two primary purposes:

• To store a message, line number, and source filename for an exception
• To maintain, and give access to the exception stack
  

Storing Exception information
The MSCUExcept class should have data members that make it possible to store the following items:

• A message string, describing the error
• The line number that an exception was raised on
• The filename that an exception was raised in
• A pointer to the previous MSCUExcept that occured

You will find that the line number and filename are parameters to the MSCUExcept constructor.

The pointer follows the design of a linked list. While it is termed an Exception Stack, it should be implemented similar to how linked list is maintained, but without many of the functions for list management. This pointer is needed to maintain the exception stack.

The data definition for the data members described above should be:
string Message; // Holds message for exception
MSCUExcept * PrevException; // Address of previous exception
char* Filename; // Source code filename of where exception was thrown
int Line; // Source code line number of where exception was thrown


Maintaining an exception stack
Each exception must be placed on the exception stack. There is only one exception stack. You should write the constructor of the MSCUExcpet class so that it places a pointer to the this exception in the exception stack.

There should be 2 static data members to help maintain the stack:
static MSCUExcept * ExceptStack; // Pointer to last exception to occur
static int ExceptionCount; // Count of exceptions in the exception stack

When an exception is added to the stack, you should take the current ExceptStack value, and store it in the PrevException pointer for this. You should then take the address of the this exception, and store it to ExceptionStack. Finally (for managing the exception stack), increment the ExceptionCount integer. This will make a 'daisy-chain' of sorts, which is the Exception Stack.

Functions required for the MSCUException class

MSCUExcept(int NewLine, char* NewFile )
Constructor. Initializes the Line, Filename, and PrevExcept data members of the exception class. Will also add the this pointer to the exception stack.
NewLine Line number
NewFile Source code filename



virtual ~MSCUExcept()
Destructor. Just decrements the ExceptionCount by one.

const string & GetMessage() const;
Returns the Message data member. Helpful in outputting the message to the console, or a file.

int GetLine() const;
Returns the Line data member. Helpful in outputting the message to the console, or a file.

char* GetFile() const;
Returns the Filename data member. Helpful in outputting the message to the console, or a file.

static void ClearStack()
Removes all exceptions from the exception stack. You must delete each pointer from the exception stack. The delete of the exception object should call the MSCUExcept destructor (automically), which will decrement the ExceptionCount data member.

static int GetExceptionCount()
Returns the ExceptionCount data member. Helpful when you want to loop through all the exception in the stack.

static const MSCUExcept* GetExcept( int Index )
Returns the address of a specific exception, specified by Index, from the exception stack. You will need to traverse the ExceptStack pointer, like a linked list, as many times as specified by Index, and then return the pointer that you stop on.

Index Specifies position within the stack. Zero indicates the last exception to occur.

static void Dump( ostream& Dst, bool Clear=true )
Dumps (displays) all of the exception in the exception stack.
Dst an ostream, and may be either cout, or an open file stream
Clear If true, then the stack should be cleared after being output (just call ClearStack)


Classes derived from MSCUExcept, in general
The primary purpose for classes derived from MSCUExcept is to initialize the Message data member (you will want to make the data members, or at least the Message data member protected to do this easily). For that reason, you will find that for the derived classes, you only need to write the constructor. The constructor for the derived classes will need to provide an initializer list, where it passes the Line and Filename parameters off to the base class (MSCUExcept) constructor. The derived classes are divided into types of errors so that identifying exception types in catch blocks is possible.


The MSCUMemExcept class
The sole purpose of this class, is to initialize the Message parameter to "Out of memory". It has no data members of it's own, and only a constructor function.

Functions required for the MSCUMemExcept class

MSCUMemExcept( int NewLine, char * NewFile );
Constructor. Since we will only be addressing one type of memory exception, out of memory, this function only needs to set Message to "Out of memory". See also the Notes section.


The MSCUFileExcept class
The purpose of this class is to hold information regarding errors against a disk file. It will only have a constructor whose purpose is to initialize Message with a description of the operation that failed, and the filename that the operation failed against. Like MSCUMemExcept, it has no data members of it's own, and only a constructor function.

Functions required for the MSCUMemExcept class

MSCUFileExcept( int NewLine, char * NewFile, char * Problem, char *Filename );
Constructor. This function should set Message to be Problem + ": [" + Filename + "]".




Notes

• The entire exception stack works under the principle that exception classes are dynamically created, with a new. This means that the this pointer found in the constructor of the MSCUExcept, will not go away until it is delete'ed. This was done because when you travel from the catch of one try block to another (by throwing a another exception in the catch), the original exception thrown is destructed. By dynamically allocating the exceptions, we get to control when the desctrucor is called. Note how the test program does a throw new, not just a throw.
• The ClearStack function is where the pointers are delete'ed.
• The MSCUMemExcept class is somewhat bogus in this example. If you run into an out-of-memory exception, it's bad practice to attempt to dynamically-allocate an object to report it. A real-world solution would involve either treating the MSCUMemExcept as a 'severe' error, bypassing the stack, or involve the pre-allocation of certain exception types.
• All you need in MSCUMemExcept and MSCUFileExcept, is a constructor in each.
• The exception stack is implemented similar to a linked list, but doesn't have any of the functions normally found in a linked list such as DeleteNode or FindNode. You do not need to write any additional functions other than what has been documented here.
• __LINE__ is a predefine macro which will be an integer value representing the line number where it is encountered. __FILE__ is similar, except that it is a char * with the name of the source file, wherever it is encountered. __LINE__ and __FILE__ are intended only for debugging purposes, in a fashion similar to how we use them here. See the throw statements of the test program.
• The Dump function should traverse the exception stack, with the help of GetExceptionCount, getting an exception pointer with the help of GetExcept. For each exception pointer, it should invoke the GetFile, GetLine, and GetMessage functions to display the data to the Dst parameter of Dump (don't specifically send output to cout).
• Because of some complexities with forward referencing, you do not need an ostream operator<< function.
  As always, comments should be added before every function to describe it's purpose, parameters, return values, who wrote it, and when.
• Usage of these exception classes requires some basic rules:
  
• 1. All exceptions are created dynamically and thrown
  2. A catch block must either report the error and clear the stack (with either Dump or ClearStack), throw a new exception object (dynamically), or handle the error without reporting, but still clearing the stack.
  
• My entire solution, including test program, was 135 lines of code (no comments).