Seshhu's Blog

Exception Handling

seshhu143 — Sun, 11 Oct 2009 11:28:42 +0000

Learning Objectives

At the end of this module, you will be able to

Explain why do we need exception handling.
Explain how to write C++ programs using exception handling.
Explain how to declare and implement exception handing.
Identify and list different exceptions.
Apply exceptions for file handling, memory allocation and real world scenarios.

Exception Handling

Introduction

Exceptions are errors that occur at runtime. They are caused by a wide variety of exceptional circumstance, such as running out of memory, not being able to open a file, trying to initialize an object to an impossible value, or using an out-of-bounds index to a vector.

Why do we need exceptions ?

Why do we need a new mechanism to handle errors? Let’s look at how the process was handled in the past. C-language programs often signal an error by returning a particular value from the function in which it occurred. For example, disk-file functions often return NULL or 0 to signal an error. Each time you call one of these functions you check the return value:

if( somefunc() == ERROR_RETURN_VALUE ) //handle the error or call error-handler function else //proceed normally if( anotherfunc() == NULL ) //handle the error or call error-handler function else //proceed normally if( thirdfunc() == 0 ) //handle the error or call error-handler function else //proceed normally

The Problem with this approach is that every single call to such a function must be examined by the program. Surrounding each function call with an if…else statement, and adding statements to handle the error (or call an error-handler routine), requires a lot of code and makes the listing convoluted and hard to read.

Exception Syntax

Imagine an application that creates and interacts with objects of a certain class. Ordinarily the application’s calls to the class member functions cause no problems. Sometimes, however, the application makes a mistake, causing an error to be detected in a member function. This member function then informs the application that an error has occurred. When exceptions are used, this is called throwing an exception. In the application we install a separate section of code to handle the error. This code is called an exception handler or catch block; it catches the exceptions thrown by the member function. Any code in the application that uses objects of the class is enclosed in a try block. Errors generated in the try block will be caught in the catch block. Code that doesn’t interact with the class need not be in a try block. Below image shows the arrangement.

The exception mechanism uses three new C++ keywords: throw, catch, and try. Also, we need to create a new kind of entity called an exception class. XSYNTAX is not a working program, but a skeleton program to show the syntax.

// xsyntax.cpp // not a working program //////////////////////////////////////////////////////////////// class AClass //a class { public: class AnError //exception class { };

void Func() //a member function { if( /* error condition */ ) throw AnError(); //throw exception } };

////////////////////////////////////////////////////////////////

int main() //application { try //try block { AClass obj1; //interact with AClass objects obj1.Func(); //may cause error } catch(AClass::AnError) //exception handler { //(catch block) //tell user about error, etc. } return 0; }

We start with a class called AClass, which represents any class in which errors might occur. An exception class, AnError, is specified in the public part of AClass. In AClass’s member functions we check for errors. If we find one, we throw an exception, using the keyword throw followed by the constructor for the error class:

throw AnError(); //’throw’ followed by constructor for AnError class

In the main() part of the program we enclose any statements that interact with AClass in a try block. If any of these statements causes an error to be detected in an AClass member function, an exception will be thrown and control will go to the catch block that immediately follows the try block.

A simple Exception Example

Let’s look at a working program example that uses exceptions. This example creates a stack data structure in which integer data values could be stored. The application program might attempt to push too many objects onto the stack, thus exceeding the capacity of the array, or it might try to pop too many objects off the stack, thus obtaining invalid data. In the XSTAK program we use an exception to handle these two errors.

// xstak.cpp // demonstrates exceptions

include

using namespace std; const int MAX = 3; //stack holds 3 integers //////////////////////////////////////////////////////////////// class Stack { private: int st[MAX]; //array of integers

int top; //index of top of stack public: class Range //exception class for Stack { //note: empty class body };

Stack() //constructor { top = -1; }

void push(int var) { if(top >= MAX-1) //if stack full, throw Range(); //throw exception st[++top] = var; //put number on stack }

int pop() { if(top < 0) //if stack empty, throw Range(); //throw exception return st[top--]; //take number off stack } }; ////////////////////////////////////////////////////////////////

int main() { Stack s1; try { s1.push(11); s1.push(22); s1.push(33); // s1.push(44); //oops: stack full cout << “1: “ << s1.pop() << endl; cout << “2: “ << s1.pop() << endl; cout << “3: “ << s1.pop() << endl; cout << “4: “ << s1.pop() << endl; //oops: stack empty } catch(Stack::Range) //exception handler { cout << “Exception: Stack Full or Empty” << endl; } cout << “Arrive here after catch (or normal exit)” << endl; return 0; } Note that we’ve made the stack small so that it’s easier to trigger an exception by pushing too many items.

Let’s examine the features of this program that deal with exceptions. There are four of them. In the class specification there is an exception class. There are also statements that throw exceptions. In the main() part of the program there is a block of code that may cause exceptions (the try block), and a block of code that handles the exception (the catch block).

Specifying the Exception Class

The program first specifies an exception class within the Stack class: class Range { //note: empty class body };

Here the body of the class is empty, so objects of this class have no data and no member functions. All we really need in this simple example is the class name, Range. This name is used to connect a throw statement with a catch block. (The class body need not always be empty, as we’ll see later.)

Throwing an Exception

In the Stack class an exception occurs if the application tries to pop a value when the stack is empty or tries to push a value when the stack is full. To let the application know that it has made such a mistake when manipulating a Stack object, the member functions of the Stack class check for these conditions using if statements, and throw an exception if they occur. In XSTAK the exception is thrown in two places, both using the statement

throw Range();

The Range() part of this statement invokes the implicit constructor for the Range class, which creates an object of this class. The throw part of the statement transfers program control to the exception handler (which we’ll examine in a moment).

The try Block

All the statements in main() that might cause this exception—that is, statements that manipulate Stack objects—are enclosed in braces and preceded by the try keyword:

try { //code that operates on objects that might cause an exception }

This is simply part of the application’s normal code; it’s what you would need to write even if you weren’t using exceptions. Not all the code in the program needs to be in a try block; just the code that interacts with the Stack class. Also, there can be many try blocks in your program, so you can access Stack objects from different places.

The Exception Handler (Catch Block)

The code that handles the exception is enclosed in braces, preceded by the catch keyword, with the exception class name in parentheses. The exception class name must include the class in which it is located. Here it’s

Stack::Range. catch(Stack::Range) { //code that handles the exception }

This construction is called the exception handler. It must immediately follow the try block. In XSTAK the exception handler simply prints an error message to let the user know why the program failed.

Control “falls through” the bottom of the exception handler, so you can continue processing at that point. Or the exception handler may transfer control elsewhere, or (often) terminate the program.

Sequence of Events

Let’s summarize the sequence of events when an exception occurs:

Code is executing normally outside a try block.
Control enters the try block.
A statement in the try block causes an error in a member function.
The member function throws an exception.
Control transfers to the exception handler (catch block) following the try block.

That’s all there is to it. Notice how clean the resulting code is. Any of the statements in the try block could cause an exception, but we don’t need to worry about checking a return value for each one, because the try-throw-catch arrangement handles them all automatically. In this particular example we’ve deliberately created two statements that cause exceptions. The first

s1.push(44); //pushes too many items

causes an exception if you remove the comment symbol preceding it, and the second

cout << “4: “ << s1.pop() << endl; //pops item from empty stack

causes an exception if the first statement is commented out. Try it each way. In both cases the same error message will be displayed:

Stack Full or Empty

Multiple Exceptions

You can design a class to throw as many exceptions as you want. To show how this works, we’ll modify the XSTAK program to throw separate exceptions for attempting to push data on a full stack and attempting to pop data from an empty stack. Here’s the listing for XSTAK2:

// xstak2.cpp // demonstrates two exception handlers

include

using namespace std; const int MAX = 3; //stack holds 3 integers //////////////////////////////////////////////////////////////// class Stack { private: int st[MAX]; //stack: array of integers int top; //index of top of stack public: class Full { }; //exception class

class Empty { }; //exception class

//————————————————————– Stack() //constructor { top = -1; } //————————————————————– void push(int var) //put number on stack { if(top >= MAX-1) //if stack full, throw Full(); //throw Full exception st[++top] = var; }

//————————————————————– int pop() //take number off stack { if(top < 0) //if stack empty, throw Empty(); //throw Empty exception return st[top--]; } }; //////////////////////////////////////////////////////////////// int main() { Stack s1; try { s1.push(11); s1.push(22); s1.push(33); // s1.push(44); //oops: stack full cout << “1: “ << s1.pop() << endl; cout << “2: “ << s1.pop() << endl; cout << “3: “ << s1.pop() << endl; cout << “4: “ << s1.pop() << endl; //oops: stack empty } catch(Stack::Full) { cout << “Exception: Stack Full” << endl; } catch(Stack::Empty) { cout << “Exception: Stack Empty” << endl; } return 0; }

In XSTAK2 we specify two exception classes:

class Full { }; class Empty { }; The statement throw Full();

is executed if the application calls push() when the stack is already full, and

throw Empty();

is executed if pop() is called when the stack is empty.

A separate catch block is used for each exception:

try { //code that operates on Stack objects } catch(Stack::Full) { //code to handle Full exception } catch(Stack::Empty) { //code to handle Empty exception }

All the catch blocks used with a particular try block must immediately follow the try block. In this case each catch block simply prints a message: “Stack Full” or “Stack Empty”. Only one catch block is activated for a given exception. A group of catch blocks, or a catch ladder, operates a little like a switch statement, with only the appropriate section of code being executed. When an exception has been handled, control passes to the statement following all the catch blocks. (Unlike a switch statement, you don’t need to end each catch block with a break. In this way catch blocks act more like functions.)

Specifing Data in an Exception Class

What happens if the application needs more information about what caused an exception? For instance, in the XSTAK2 example, it might help the programmer to know what MAX elements the stack can have.

It’s convenient to make the data in an exception class public so it can be accessed directly by the exception handler. Here’s the specification for the new Full exception class in XSTAK2:

class Full{ //exception class public: int maxElements; //Max elements the stack can store string message; //For name of the routine

Full(int max, string m){ maxElements = max; //put max in value in the object message = m; //put string in object } }; There are public variables for a string object, which will hold the name of the member function being called, and a type int, for the MAX stack elements.

Initializing an Exception Object

How do we initialize the data when we throw an exception? In the two-argument constructor for the Stack class we say

throw Full(MAX,”STACK PUSH –> Stack is FULL”");

When the exception is thrown, the handler will display the string and MAX. The string will tell us which member function is throwing the exception, and the value of MAX. This additional data will make it easier for the programmer or user to figure out what caused the error.

Resources

Web Resources:

Steps to Attack the problem sets

Step 1: Read about Exception and try the example programs
Step 2: Go through the PPT on Exceptions and try stack program from the PPT.(you can copy paste the program)
Step 3: Go through the additional resources given.
Step 4: Attack the problem sets in the given order(Problem Set A and then Problem Set B …).
Step 5: If you are not clear with the problem sets then contact your respective mentor for clarification.

Spend atleast 2 hours from step 1 to step 3

Problem Sets

Problem Set A

1. Write an interactive program which divides two Integer Wrapper(Declaration is given) Class Objects. Overload divide(/) operator. Handle cases such as division-by-zero using exceptions. Write a test program to test the Wrapper Integer class for division.

The declaration of Integer class is

class Integer{ private: int value; public: Integer(int v){value=v;}; //Consturctor int getInt(); //returns the integer void setInt(int v); //set the int value to the object Integer operator/= (const Integer &); };

Name the program as: PA1_Integer.cpp

Problem Set B

1. Add exceptions to the queue template you have written in Module 9. Throw two exceptions: one if the capacity of the queue is exceeded, the other if the program tries to remove an item from an empty queue. One way to handle this is to add a new data member to the queue: a count of the number of items currently in the queue. Increment the count when you insert an item, and decrement it when you remove an item. Throw an exception if this count exceeds the capacity of the queue, or if it becomes less than 0.

Add Exceptions in the Dynamic Array if the Memory allocation failed.

You might try making the main() part of this exercise interactive, so the user can put values on a queue and take them off. This makes it easier to exercise the queue. Following an exception, the program should allow the user to recover from a mistake without corrupting the contents of the queue.

Name the DynamicArray program as: PB1_DynamicArray.cpp
Name the Queue program as: PB1_QueueException.cpp
Name the Header as: PB1_QueueException.h

Templates

seshhu143 — Sun, 11 Oct 2009 11:26:23 +0000

Learning Objectives

At the end of this Module, you will be able to:

Explain how to achieve static polymorphic behavior through the use of templates
Explain how to write generic code using templates
Explain how to declare and implement function templates
Explain how to declare and implement class templates
Explain how to declare and implement class member function templates

Static Polymorphism

Introduction

Static polymorphic behavior is realized at compile time. A class template acts as a generic class definition from which new class types can be defined by a simple change of parameter types. Whereas a normal class is used to create objects, a class template is used to define new class types, from which objects are then created. The compiler uses the types you supply, combined with the class template, to create a wholly new class type.

Understanding how to declare, implement, and use class and function templates will pay big dividends in many ways. Primarily, it provides you with a mechanism to write generic code. Learning to write generic code can potentially save you a lot of work.

Definition of Template

A template defines a related set of classes or functions. The related set of classes or functions defined by a template share the same code structure and functionality. The class or function template can then be used to declare a new class or function type.

Function Templates

A function template is a generic function declaration and definition from which different versions of the function can be created by the compiler based on the argument types used to call the function. If you think this sounds a lot like overloaded functions you are right. Function templates and overloaded functions are related as you will soon see.

Class Templates

A class template is a generic class declaration and definition from which different, but related, class types can be created by the compiler based on type parameters.

Structure Templates

A structure template is like a class template but using structures instead.

How Templates Work: An Analogy

When you declare and define a template you are creating a generic version of whatever piece of code you are writing, be it a function or a class. In the declaration and definition of the template you will use one or more identifiers as type placeholders. These type placeholders are similar in function to the placeholders in a form letter generated with a word processor.

The below figure illustrates a simple mail merge operation. A master letter is created with placeholders for certain data elements. The structure of the data source is mapped to the master letter by the placeholder identifiers name and age. When the mail merge function is executed, the data source is merged with the master letter to yield the finished letters. The master letter is a generic document that can be reused to generate many specific letter instances. Class and function templates work in similar fashion. A generic function or class is declared and defined. Placeholders are inserted into the code to reserve spots for actual data types. When specific versions of a template function are required the type substitutions are made based on the types of the arguments used to call the function. In the case of template classes, a special syntax is used when a new template class is declared.

Declaring And Using Function Templates

Up until now, if you wanted to create different versions of the same function to operate on different data types you would overload the function. For instance, if you wanted to declare a function named Sum() that took two arguments, added them together, and returned the result you could create several versions of the function like so:

int Sum(int val1, int val2); float Sum(float val1, float val2); char Sum(char val1, char val2);

These three functions can be replaced with one function template.

ifndef SUM_TEMPLATE_H
define SUM_TEMPLATE_H

template T Sum(T val1, T val2){

return val1 + val2;

}

endif

The Sum() function is declared to be a template by the keyword template appearing on line 4. Following the keyword template in angle brackets is the keyword class followed by a placeholder identifier named T. The class keyword as it is used here essentially means “any type”. The placeholder T will then appear somewhere in the function. It can appear in more than one place, as it does here in the parameter list. You can use any valid identifier as a placeholder name, not just T. You can also declare more than one placeholder.

To use the Sum() function template The Sum() function is called the same way as normal functions are called. The example below shows a main() function using the Sum() function on different data types.

include
ifndef SUM_TEMPLATE_H
define SUM_TEMPLATE_H

template T Sum(T val1, T val2){

return val1 + val2;

}

endif

using namespace std; int main(){

cout<
//cout<

Using Multiple Placeholders
The Sum() function template declared and defined in the above example used one type placeholder named T to reserve type spots in the function. Because both of the Sum() function’s parameters are reserved with the same placeholder they must be of the same type when the function is called. To illustrate, let us see what happens when the Sum() function is called with an integer and a float argument as shown in the following line of code:
cout<
Error : in function int main() line no 15: no matching function for call to `Sum(int, double)
When the Sum() function template is called with two different argument types an error results. This error was produced using the Dev C++ 4.9.9.2. One way to eliminate this error is to declare the Sum() function template to use two different placeholders.


include 
ifndef SUM_TEMPLATE_H
define SUM_TEMPLATE_H

template T Sum(T val1, U val2){
 return val1 + val2;
}


endif

using namespace std; int main(){
cout<
} 
Notice now there are two type placeholders declared on line 5 of the above example. T and U. The U placeholder is used for the second parameter in the Sum() function while the T placeholder is used for the first parameter and the return value. This will solve one problem but introduce another. The above Example shows the revised Sum() function template in use.
Refer to line 14 of the above example. Notice now that the Sum() function is called with the first argument an integer and the second argument a float. By using two placeholders in the function template the error produced by using two different argument types is eliminated. However, the result type of the Sum() function is dictated by the first argument type. Since the T placeholder is used to reserve the type spot for both the first parameter and the return type of the function, whatever type the first argument to the function happens to be will also be the return type of the function. In this example it is an integer. So, the result of calling the Sum() function with the arguments 3 and 3.5 is 6, not 6.5! Notice what happens when the order of the arguments are swapped.

To resolve the ambiguous return type issue simply declare yet another type place holder used specifically to dictate the function’s return type. The below example gives the revised Sum() function with the extra type placeholder V declared and used to reserve the return type.


include 
ifndef SUM_TEMPLATE_H
define SUM_TEMPLATE_H

template V Sum(T val1, U val2){
return val1 + val2;

}

endif

using namespace std; int main(){
cout<(3, 25)<(3.456, 5.786)<('a', 'b')<(3.5, 3)<
return 0; } 
Notice the Sum() function call on line 11. The function name Sum is followed by a series of type names enclosed in angle brackets. This is referred to as a template specialization. The order of type names appearing in the specialization map to the same order as the function template type parameters. On line 11 the Sum() function is being specialized to take two integers as arguments to the function and return an integer value. Following the specialization is the argument list appearing in parentheses as usual. Line 12 introduces another Sum() function specialization, as does line 13 and line 14. The specialization on line 14 says that the Sum() function will take a double as the first argument, an integer as the second argument, and return a double value.

Declaring And Using Class Templates
Class templates are used to declare and define a generic class structure. The compiler uses the class template and any types supplied via specialization to build a new class type. Let us begin the discussion of class templates with a simple Foo example. Example below shows the declaration and definition of a class template named Foo.


include 


ifndef FOOTEMPLATEDEF_H
define FOOTEMPLATEDEF_H

template class Foo{ public: 	Foo(T _val); 	virtual ~Foo(); 	void setVal(T _val); 	T getVal(); private: 	T val; };
template Foo::Foo(T _val):val(_val){}
template Foo::~Foo(){}
template void Foo::setVal(T _val){ 	val = _val; }
template T Foo::getVal(){ 	return val; }

endif

using namespace std;
int main(){ 	Foo f1(1); 	Foo f2(‘d’); 	cout<
The declaration of the Foo class templates begins on line 6 with the keyword template. There is only one template parameter declared named T. The T is used throughout the class declaration and definition to reserve a spot for the type declared when the Foo class is specialized.
Referring to line 33 of above example, notice how the Foo class template is specialized to use an int type. The important point to note in this example is that Foo and Foo are two distinct types.

A More Complex Class Template Example
The below Example gives the source code for a template of the DynamicArray class.


include 


ifndef _DYNAMIC_ARRAY_H
define _DYNAMIC_ARRAY_H

template class DynamicArray{ public: 	DynamicArray(int _size = 5); 	virtual ~DynamicArray(); 	T& operator[](unsigned i); 	int getSize(); private: 	T* its_array; 	int size; };
template DynamicArray::DynamicArray(int _size):size(_size){ 	its_array = new T[_size]; 	for(int i=0; i(0); }
template DynamicArray::~DynamicArray(){ 	delete[] its_array; }
template T& DynamicArray::operator[](unsigned i){ if(i >= (size)){ 	int newsize = size+10; 	T* temp = new T[size]; 	for(int j = 0; j(0); 	} 	delete[] temp; 	size = newsize; 	return its_array[i]; }  else  	return its_array[i]; }
template int DynamicArray::getSize(){ return size;}

endif

using namespace std;
int main(){ 	DynamicArray d1; 	DynamicArray d2; 	for(int i=0; i<6; i++){ 		d1[i] = ‘a’; 	} 	for(int i=0; i<6; i++){ 		d2[i] = (i + .5); 	} 	for(int i=0; i
Converting the DynamicArray class into a class template increased its usefulness as it can now be used to hold different types of objects, even user-defined types. The above example gives a main() function showing the DynamicArray class template in use.


Steps to attack the problem sets

Step 1: Read about  Static Polymorphism and try sample programs(DynamicArray) given in Static Polymorphism(You can copy paste the programs)
Step 2: Go through the PPT on Templates and try stack program from the PPT.(you can copy paste the program)
Step 3: Go through the additional resources given.
Step 4: Attack the problem sets in the given order(Problem Set A and then Problem Set B …).
Step 5: If you are not clear with the problem sets then contact your respective mentor for clarification.

Spend atleast 2 hours from Step 1 to Step 3.

Problem Sets

Problem Set A
1. Create a function called swaps() that interchanges the values of the two arguments sent to it. (You will probably want to pass these arguments by reference.) Make the function into a template, so it can be used with all numerical data types (char, int, float, and so on). Write a main() program to exercise the function with several types.
Name the program as: PA1_swaps.cpp


Problem Set B
2. Create a function called amax() that returns the value of the largest element in an array. The arguments to the function should be the address of the array and its size. Make this function into a template so it will work with an array of any numerical type. Write a main() program that applies this function to arrays of various types.
Name the program as:PB1_amax.cpp


Problem Set C
3. A queue is a data-storage device. It’s like a stack, except that, instead of being last-in first-out, it’s first-in-first-out, like the line at a bank teller’s window. If you put in 1, 2, 3,you get back 1, 2, 3 in that order.
A stack needs only one index to an array (i.e top of the array). A queue, on the other hand, must keep track of two indexes to an array: one to the tail, where new items are added, and one to the head, where old items are removed. The tail follows the head through the array as items are added and removed. If either the tail or the head reaches the end of the array, it is reset to the beginning.
Write a class template for a queue class. Assume that the programmer using the queue won’t make any mistakes, like exceeding the capacity of the queue or trying to remove an item when the queue is empty. Define several queues of different data types and insert and remove data from them.
Use the  dynamicarray discussed previously for implementing the queue.
Write the declaration and defining of Queue template in separate header file and a Test program to test the queue in separate source file.
Refer:

Queue Animation  Java Applet(Animation) represents a simple queue at a shop

Name the Header files as: PC1_queue.h
Name the Test program as: PC1_queueTest.cpp

Friend Functions

seshhu143 — Sun, 11 Oct 2009 11:23:19 +0000

Learning Objectives

At the end of this module, you will able to:

Explain and use friend functions in C++ programs
Implement software objects as friends to one another

Introduction

Friend

The concepts of encapsulation and data hiding dictate that nonmember functions should not be able to access an object’s private or protected data. The policy is, if you’re not a member, you can’t get in. However, there are situations where such rigid discrimination leads to considerable inconvenience. in order to access the non-public members of a class, C++ provides the friend facility.

Friend Functions

Imagine that you want a function to operate on objects of two different classes. Perhaps the function will take objects of the two classes as arguments, and operate on their private data. In this situation there’s nothing like a friend function. Here’s a simple example, FRIEND, that shows how friend functions can act as a bridge between two classes:

// friend.cpp // friend functions

include

using namespace std; //////////////////////////////////////////////////////////////// class beta; //needed for frifunc declaration class alpha { private: int data; public: alpha() : data(3) { } //no-arg constructor friend int frifunc(alpha, beta); //friend function }; //////////////////////////////////////////////////////////////// class beta { private: int data; public: beta() : data(7) { } //no-arg constructor friend int frifunc(alpha, beta); //friend function }; //////////////////////////////////////////////////////////////// int frifunc(alpha a, beta b) //function definition { return( a.data + b.data ); } //————————————————————– int main() {

alpha aa;
beta bb;
cout << frifunc(aa, bb) << endl; //call the function
return 0;

}

In this program, the two classes are alpha and beta. The constructors in these classes initialize their single data items to fixed values (3 in alpha and 7 in beta).

We want the function frifunc() to have access to both of these private data members, so we make it a friend function. It’s declared with the friend keyword in both classes:

friend int frifunc(alpha, beta);

This declaration can be placed anywhere in the class; it doesn’t matter whether it goes in the public or the private section.

An object of each class is passed as an argument to the function frifunc(), and it accesses the private data member of both classes through these arguments. The function doesn’t do much: It adds the data items and returns the sum. The main() program calls this function and prints the result.

A minor point: Remember that a class can’t be referred to until it has been declared. Class beta is referred to in the declaration of the function frifunc() in class alpha, so beta must be declared before alpha. Hence the declaration class beta; at the beginning of the program.

Friend Classes

The member functions of a class can all be made friends at the same time when you make the entire class a friend. The program FRICLASS shows how this looks.

// friclass.cpp // friend classes

include

using namespace std; //////////////////////////////////////////////////////////////// class alpha { private: int data1; public: alpha() : data1(99) { } //constructor friend class beta; //beta is a friend class }; //////////////////////////////////////////////////////////////// class beta { //all member functions can public: //access private alpha data void func1(alpha a) { cout << “\ndata1=” << a.data1; } void func2(alpha a) { cout << “\ndata1=” << a.data1; } }; //////////////////////////////////////////////////////////////// int main() {

 alpha a;
 beta b;
 b.func1(a);
 b.func2(a);
 cout << endl;
 return 0;

}

In class alpha the entire class beta is proclaimed a friend. Now all the member functions of beta can access the private data of alpha (in this program, the single data item data1). Note that in the friend declaration we specify that beta is a class using the class keyword:

friend class beta;

We could have also declared beta to be a class before the alpha class specifier, as in previous examples

class beta;

and then, within alpha, referred to beta without the class keyword:

friend beta;

Resources

Refer previous modules on how to Identify a class, it’s state and behavior.

Lesson 9: Tic Tac Toe Supporting Material

Steps to solve the problems sets

Read the introduction part of this module
View the video and read the supporting material
Think about how to write the tic tac toe program with objects.

Spend atleast 1 hour on the resources and Other modules covered so far.

Problem Sets

Problem Set A

1. Game Program: The object of tic-tac-toe is to get three X’s or three O’s in a row either horizontally, vertically or diagonally. The tic-tac-toe game board is a 3 x 3 grid and looks something like this:

During a typical game, players takes turns placing their X’s and O’s on the game board. The first to get their pattern in a row wins. The follow game board represents what the results of a typical game might look like:

Use a 3 x 3 array of cell objects to track player turns. Check the array after each player’s turn to see if they’ve won. Draw the game board on the screen after each turn so players can see the game’s progress. Make it a two player game.

Use Object Oriented Programming approach to solve this problem, thought the problem can be solved simple as presented in the video given.

Write a game program called tic-tac-toe by Identifying the Game as a class consists of Player Objects and Board Object. Board consists of Cell Objects representing the cell in the board.

Identify the Objects in the game with attributes and behavior.

Player can have player Name as an attribute and behavior as playing the game.

Identify and the write friend functions\classes in the board class, cell class, player class and Game class.

Use your imagination to identify the objects, It’s not limited to the classes which we have defined.

Name the program as:- PA1_TicTacToe.cpp

Polymorphism

seshhu143 — Sun, 11 Oct 2009 11:20:17 +0000

Introduction

Polymorphism

Polymorphism is the ability to associate more than one implementation with the same operation. The binding of the operation with the implementation, can be decided at compile time or at run time. In object orientation, polymorphism can exist in two ways.

Hierarchy independent – This takes the form of overloading, where the same name of an operation, has different implementations in different classes and these classes need not be related by class hierarchy.
Hierarchy dependent- Here, an operation defined in the superclass can have any number of implementations along the class hierarchy. This type of polymorphism is referred to as universal polymorphism or overriding. The operation can be bound to any of the implementations. This resolution can take place, at compile time or at run time.

Pointers

Address and Pointers

The ideas behind pointers are not complicated. Here’s the first key concept: Every byte in the computer’s memory has an address. Addresses are numbers, just as they are for houses on a street. The numbers start at 0 and go up from there—1, 2, 3, and so on. If you have 1MB of memory, the highest address is 1,048,575. (Of course you have much more.)

Your program, when it is loaded into memory, occupies a certain range of these addresses. That means that every variable and every function in your program starts at a particular address.

Pointers to void

Before we go on to see pointers at work, we should note one peculiarity of pointer data types.Ordinarily, the address that you put in a pointer must be the same type as the pointer. You can’t assign the address of a float variable to a pointer to int, for example:

float flovar = 98.6;
int* ptrint = &flovar; //ERROR: can’t assign float* to int*

However, there is an exception to this. There is a sort of general-purpose pointer that can point to any data type. This is called a pointer to void, and is defined like this:

void* ptr; //ptr can point to any data type

Such pointers have certain specialized uses, such as passing pointers to functions that operate independently of the data type pointed to.

The next example uses a pointer to void and also shows that, if you don’t use void, you must be careful to assign pointers an address of the same type as the pointer. Here’s the listing for PTRVOID:

// ptrvoid.cpp
// pointers to type void
#include
using namespace std;
int main()
{
int intvar; //integer variable
float flovar; //float variable
int* ptrint; //define pointer to int
float* ptrflo; //define pointer to float
void* ptrvoid; //define pointer to void
ptrint = &intvar; //ok, int* to int*
// ptrint = &flovar; //error, float* to int*
// ptrflo = &intvar; //error, int* to float*
ptrflo = &flovar; //ok, float* to float*
ptrvoid = &intvar; //ok, int* to void*
ptrvoid = &flovar; //ok, float* to void*
return 0;
}

You can assign the address of intvar to ptrint because they are both type int*, but you can’t assign the address of flovar to ptrint because the first is type float* and the second is type int*. However, ptrvoid can be given any pointer value, such as int*, because it is a pointer to void.

If for some unusual reason you really need to assign one kind of pointer type to another, you can use the reinterpret_cast. For the lines commented out in PTRVOID, that would look like this:

ptrint = reinterpret_cast(flovar);
ptrflo = reinterpret_cast(intvar);

The use of reinterpret_cast in this way is not recommended, but occasionally it’s the only way out of a difficult situation. Static casts won’t work with pointers. Old-style C casts can be used, but are always a bad idea in C++.

Base class Pointers

In C++ a pointer of a base class can point to an object of any of its derived class.

In the example given below shows what happens when a base class and derived classes all have functions with the same name, and you access these functions using pointers. Here is the listing of BASEPOINT

// basepoint.cpp
// normal functions accessed from pointer
#include
using namespace std;
////////////////////////////////////////////////////////////////
class Base //base class
{
public:
      void show(){ cout << "Base\n"; }
};
////////////////////////////////////////////////////////////////
class Derv1 : public Base //derived class 1
{
public:
      void show()
        { cout << "Derv1\n"; }
};
////////////////////////////////////////////////////////////////
class Derv2 : public Base //derived class 2
{
public:
      void show()
           { cout << "Derv2\n"; }
};
////////////////////////////////////////////////////////////////
int main()
{
Derv1 dv1; //object of derived class 1
Derv2 dv2; //object of derived class 2

Base* ptr; //pointer to base class

Derv1 *pdv1; //pointer to Derv1
Derv2 *pdv2; //pointer to Derv2

ptr = &dv1; //put address of dv1 in pointer
ptr->show(); //execute show()

ptr = &dv2; //put address of dv2 in pointer
ptr->show(); //execute show()

ptr = &dv1; //put address of dv1 in pointer
if(reinterpret_cast(ptr) !=0){
  pdv1 =  reinterpret_cast(ptr);
  pdv1->show();
}
ptr = &dv2; //put address of dv2 in pointer
if(reinterpret_cast(ptr) !=0){
  pdv2 =  reinterpret_cast(ptr);
  pdv2->show();
}
return 0;
}

The Derv1 and Derv2 classes are derived from class Base. Each of these three classes has a member function show(). In main() we create objects of class Derv1 and Derv2, and a pointer to class Base. Then we put the address of a derived class object in the base class pointer in the line

ptr = &dv1; // derived class address in base class pointer

But wait—how can we get away with this? Doesn’t the compiler complain that we’re assigning an address of one type (Derv1) to a pointer of another (Base)? On the contrary, the compiler is perfectly happy, because type checking has been relaxed in this situation, for reasons that will become apparent soon. The rule is that pointers to objects of a derived class are type-compatible with pointers to objects of the base class.

Now the question is, when you execute the line

ptr->show();

what function is called? Is it Base::show() or Derv1::show()? Again, in the last two lines of BASEPOINT we put the address of an object of class Derv2 in the pointer, and again execute

ptr->show();

Which of the show() functions is called here? The output from the program answers these questions:

Base

As you can see, the function in the base class is always executed. The compiler ignores the contents of the pointer ptr and chooses the member function that matches the type of the pointer, as shown in Figure below.

Sometimes this is what we want, but it doesn’t solve the problem posed at the beginning of this section: accessing objects of different classes using the same statement.

You can use reinterpret_cast to cast the pointer of it’s type and use it. But that doesn’t solve the problem if u have hundreds of derived class from the base class.

Virtual Functions

Virtual means existing in appearance but not in reality. When virtual functions are used, a program that appears to be calling a function of one class may in reality be calling a function of a different class. Why are virtual functions needed? Suppose you have a number of objects of different classes but you want to put them all in an array and perform a particular operation on them using the same function call. For example, suppose a geometry program includes several different shapes: a triangle, a circle, a square, and so on. Each of these classes has a member function getArea() that returns the area of the object.

Now suppose you plan to calculate the area by grouping a number of these elements together, and you want to calculate in a convenient way. One approach is to create an array that holds pointers to all the different objects. The array might be defined like this.

shape *ptrarr[100]; //array of 100 pointers to shapes

If you insert pointers to all the shapes into this array, you can then calculate area using a simple loop:

 for(int j=0; jgetArea() << endl;

This is an amazing capability: Completely different functions are executed by the same function call. If the pointer in ptrarr points to a square, the square function that returns area is called; if it points to a triangle, the triangle area function is called. This is called polymorphism, which means different forms. The functions have the same functionality, the getArea(), but different actual functions are called, depending on the contents of ptrarr[j]. Polymorphism is one of the key features of object-oriented programming, after classes and inheritance.

For the polymorphic approach to work, several conditions must be met.

First, all the different classes of shapes, such as circle and triangles, must be descended from a single base class (called shape in Geometry).
Second, the getArea() function must be declared to be virtual in the base class.

Virtual Member Functions Accessed with Pointers

Let’s make a single change in our program (BASEPOINT): We’ll place the keyword virtual in front of the declarator for the show() function in the base class. Here’s the listing for the resulting program,VIRTPOINT:

// virtpoint.cpp
// virtual functions accessed from pointer
#include
using namespace std;
////////////////////////////////////////////////////////////////
class Base //base class
{
public:
      virtual void show(){ cout << "Base\n"; }
};
////////////////////////////////////////////////////////////////
class Derv1 : public Base //derived class 1
{
public:
      void show()
        { cout << "Derv1\n"; }
};
////////////////////////////////////////////////////////////////
class Derv2 : public Base //derived class 2
{
public:
      void show()
           { cout << "Derv2\n"; }
};
////////////////////////////////////////////////////////////////
int main()
{
Derv1 dv1; //object of derived class 1
Derv2 dv2; //object of derived class 2
Derv1 *pdv1;
Derv2 *pdv2;

Base* ptr; //pointer to base class
ptr = &dv1; //put address of dv1 in pointer
ptr->show(); //execute show()

ptr = &dv2; //put address of dv2 in pointer
ptr->show(); //execute show()

ptr = &dv1; //put address of dv1 in pointer

if(dynamic_cast(ptr) !=0){
  pdv1 =  reinterpret_cast(ptr);
  pdv1->show();
}
ptr = &dv2; //put address of dv2 in pointer
if(dynamic_cast(ptr) !=0){
  pdv2 =  reinterpret_cast(ptr);
  pdv2->show();
}

system("PAUSE");
return 0;
}

The output of this program is

Derv1
Derv2
Derv1
Derv2

Now, as you can see, the member functions of the derived classes, not the base class, are executed. We change the contents of ptr from the address of Derv1 to that of Derv2, and the particular instance of show() that is executed also changes. So the same function call

ptr->show();

executes different functions, depending on the contents of ptr. The rule is that the compiler selects the function based on the contents of the pointer ptr, not on the type of the pointer, as in BASEPOINT. This is shown in Figure below.

You can use dynamic_cast operator to cast to a particular derived type for the polymorphic classes.

Late Binding

The astute reader may wonder how the compiler knows what function to compile. In BASEPOINT the compiler has no problem with the expression

ptr->show();

It always compiles a call to the show() function in the base class. But in VIRTPOINT the compiler doesn’t know what class the contents of ptr may contain. It could be the address of an object of the Derv1 class or of the Derv2 class. Which version of draw() does the compiler call? In fact the compiler doesn’t know what to do, so it arranges for the decision to be deferred until the program is running. At runtime, when it is known what class is pointed to by ptr, the appropriate version of draw will be called. This is called late binding or dynamic binding.(Choosing functions in the normal way, during compilation, is called early binding or static binding.) Late binding requires some overhead but provides increased power and flexibility.

We’ll put these ideas to use in a moment, but first let’s consider a refinement to the idea of virtual functions.

Abstract Classes and Pure Virtual Functions

Think of the shape class. We’ll never make an object of the shape class; we’ll only make specific shapes such as circles and triangles. When we will never want to instantiate objects of a base class, we call it an abstract class. Such a class exists only to act as a parent of derived classes that will be used to instantiate objects. It may also provide an interface for the class hierarchy.

How can we make it clear to someone using our family of classes that we don’t want anyone to instantiate objects of the base class? We could just say this in the documentation, and count on the users of the class to remember it, but of course it’s much better to write our classes so that such instantiation is impossible. How can we can do that? By placing at least one pure virtual function in the base class. A pure virtual function is one with the expression =0 added to the declaration. This is shown in the VIRTPURE example.

// virtpure.cpp
// pure virtual function
#include
using namespace std;
////////////////////////////////////////////////////////////////
class Base //base class
{
public:
 virtual void show() = 0; //pure virtual function
};
////////////////////////////////////////////////////////////////
class Derv1 : public Base //derived class 1
{
public:
 void show()
  { cout << “Derv1\n”; }
};
////////////////////////////////////////////////////////////////
class Derv2 : public Base //derived class 2
{
public:
 void show()
 { cout << “Derv2\n”; }
};
////////////////////////////////////////////////////////////////
int main()
{
// Base bad; //can’t make object from abstract class
Base* arr[2]; //array of pointers to base class
Derv1 dv1; //object of derived class 1
Derv2 dv2; //object of derived class 2
arr[0] = &dv1; //put address of dv1 in array
arr[1] = &dv2; //put address of dv2 in array
arr[0]->show(); //execute show() in both objects
arr[1]->show();
return 0;
}

Here the virtual function show() is declared as

virtual void show() = 0; // pure virtual function

The equal sign here has nothing to do with assignment; the value 0 is not assigned to anything. The =0 syntax is simply how we tell the compiler that a virtual function will be pure. Now if in main() you attempt to create objects of class Base, the compiler will complain that you’re trying to instantiate an object of an abstract class. It will also tell you the name of the pure virtual function that makes it an abstract class. Notice that, although this is only a declaration, you never need to write a definition of the base class show(), although you can if you need to.

Once you’ve placed a pure virtual function in the base class, you must override it in all the derived classes from which you want to instantiate objects. If a class doesn’t override the pure virtual function, it becomes an abstract class itself, and you can’t instantiate objects from it (although you might from classes derived from it). For consistency, you may want to make all the virtual functions in the base class pure. As you can see, we’ve made another, unrelated, change in VIRTPURE: The addresses of the member functions are stored in an array of pointers and accessed using array elements. This works in just the same way as using a single pointer. The output of VIRTPURE is the same as

VIRT:

Derv1
Derv2

Virtual Destructors

Base class destructors should always be virtual. Suppose you use delete with a base class pointer to a derived class object to destroy the derived-class object. If the base-class destructor is not virtual then delete, like a normal member function, calls the destructor for the base class, not the destructor for the derived class.

Points to remember

The process of resolving a function call to an object is called binding
Associating an object to a function call at run-time is referred to as late binding.
A pointer of a base class can point to an object of any of its derived class.
The virtual keyword is used to declare a function as virtual.
Virtual functions that have no body are called pure virtual functions.
A class containing one or more pure virtual functions is called an abstract class.
Instances of an abstract class cannot be created but pointers to it can created.
Static polymorphism involves binding of a function on the basis of the number, type and sequence of its arguments.
Function overloading is an example of static polymorphism because functions can be bound to the calls at compile time.
A function exhibits dynamic polymorphism when it exists in more than one form, and calls to its various forms are resolved dynamically when the program executed.
Static binding is considered to be more efficient while dynamic binding is more flexible.

Steps to attack the problem sets

Step 1: Read the Introduction and try sample programs given in the introduction(You can copy paste the programs)
Step 2: Go through the given PPT on Polymorphism and try sample problems given in the PPT.(you can copy paste the programs from the PPT)
Step 3: Go through the additional resources give for further clarification.
Step 4: Attack the problem sets in the given order(Problem Set A and then Problem Set B).
Step 5: If you are not clear with the problem sets then contact your respective mentor for clarification.

Spend at least 2-3 hours from Step 1 to Step 3.

Don’t get confused with the example given in PPT and in the introduction part of this Module for shapes. In PPT, Shapes are used with respect to point in a plane and in introduction part shapes is used with respect to Geometry(area, sides, circumference etc).

Resources

References:

Problem Sets

Problem Set A

1. Create a set of classes of Shapes (triangle, quadrilateral, circle) with the following inheritance relationship.

Declare and define the classes as

Shapes– Abstract base class.
- Triangle — Abstract derived class with base class as Shapes
  - IsoscelesTriangle — derived class with base class as Triangle.(Attribute with two sides)
  - EquilateralTriangle — derived class with base class as Triangle(Attribute with one side)
- Quadrilateral –Abstract derived class with base class as Shapes.
  - Rectangle — derived class with base class as Quadrilateral.(Attribute with two sides– length and breadth)
  - Square — derived class with base class as Quadrilateral.(Attribute with one side)
  - Rhombus — derived class with base class as Quadrilateral. (Attribute with two sides– length and breadth)
- Circle — Derived class with base class as Shapes. (Attribute with radius)

Use the following declarations for the abstract class and the test main function. Write the code where ever necessary.

#include
using namespace std;
////////////////////////////////////////////////////////////////
class Shapes //Abstract base class
{
public:
      virtual double getArea()=0; //Calculates the Area and returns the area
      virtual double getPerimeter()=0; //Calculates the perimeter and return the perimeter.
      virtual void getData()=0; //Take input from the user and store in the state of the object.
      virtual ~Shapes(){};
};

class Triangle : public Shapes  //Derived Abstract class
{
//Write your code here
};

class Quadrilateral : public Shapes //Derived Abstract class
{
public:
//Write your code here
};

//Write your code here to declare and define other classes stated

int main(){

//Write your code here to declare an array pointer of Shapes[6].

//Write a Loop for the Menu to create an instance of the object
// andget the input from the user for the selected Shape
//and add the pointer to the Shapes array.

//Write a Loop to Print the Area and Perimeter of the array shapes.

   system("PAUSE");
}

Display a Menu Interface to the user to Create an instance of the Object. The Menu should be like.

Create an Instance of
- Triangle
  - Create IsoscelesTriangle
  - Create EquilateralTriangle
- Quadrilateral
  - Create Rectangle
  - Create Square
  - Create Rhombus
- Create Circle

Create should create an instance of the derived class selected and then call the getData() function of that class and store that instance in the array of Shapes(Base Class).

You can add constructors for the derived classes with default values.

Write a test main function to take the input from the user for all the shapes and store them in a array, then print the area and perimeter of the class.

Refer: http://www.math.com/tables/geometry/index.htm

All the measurements is in Centimeters

Multiple Inheritance

seshhu143 — Sun, 11 Oct 2009 11:17:51 +0000

Learning Objectives

At the end of this Module, you will be able to:

Understand the concept of multiple inheritance
Identify and solve the ambiguities that arise in multiple inheritance.
Define Virtual base class
State the order of invocation of constructors and destructors

Introduction

Multiple Inheritance

Multiple Inheritance is the concept where a subclass inherits properties from multiple base classes. A familiar example of multiple inheritance is the child inheriting the characteristics of the parents.

You can derive a class from any number of base classes. Deriving a class from more than one direct base class is called multiple inheritance.

In the following example, classes A, B, and C are direct base classes for the derived class X:

The following inheritance graph describes the inheritance relationships of the above example. An arrow points to the direct base class of the class at the tail of the arrow:

class A { /* ... */ };
class B { /* ... */ };
class C { /* ... */ };
class X : public A, private B, public C { /* ... */ };

Ambiguities in Multiple Inheritance

When a class inherits from multiple base classes, a whole lot of ambiguities creep in. For example , what happens when two base classes contain a function of the same name?

For example given below –> Class A , Class B has Member functions disp() (to display the attributes of the class) and Class C inherits A and B.

class A {
  /* ... */
  public:
  void disp(void);
  };
class B {
 /* ... */
 public:
  void disp(void);
};
class C : public A, private B {
/* ... */
};

void main(){
 C c;
 C.disp();//Ambiguous
}

Here the reference to disp() is ambiguous because the compiler does not know whether disp() refers to the member in class base1 or base2. This ambiguity can be resolved using the scope resolution operator as illustrated hereunder.

class C : public A, private B {
/* ... */
public:
   void disp(void){
      A.disp();
      B.disp();
   }
};
void main(){
 C c;
 c.disp();
}

This ambiguity can also be resolved by overriding as illustrated hereunder.

void main(){
 C c;
 c.A::disp();
 c.B.::disp();
}

Another ambiguity that arises in multiple inheritance is the possibility of the derived class having multiple copies of the same base class. Consider the following diagram.

class L { /* ... */ };                  // indirect base class
class B2 : public L { /* ... */ };
class B3 : public L { /* ... */ };
class D : public B2, public B3 { /* ... */ }; // valid

In the above example, class D inherits the indirect base class L once through class B2 and once through class B3. However, this may lead to ambiguities because two objects of class L exist, and both are accessible through class D. You can avoid this ambiguity by referring to class L using a qualified class name. For example:

B2::L

B3::L

You can also avoid this ambiguity by using the base specifier virtual to declare a base class.

Virtual Base Classes

The principle behind virtual base classes is very simple. When the same class is inherited more than once via multiple paths, multiple copies of the base class members are created in memory. By declaring the base class inheritance as virtual, only one copy of the base class is inherited. A base class inheritance can be specified as virtual using virutal qualifier.

The class definitions would be modified as follows

class L { /* ... */ }; // indirect base class
class B1 : virtual public L { /* ... */ };
class B2 : virtual public L { /* ... */ };
class D : public B1, public B2 { /* ... */ }; // valid

Invocation of Constructors and Destructors

Constructors are invoked in the following order:
- Virtual base class constructors — in the order of inheritance.
- Non-Virtual base class constructors — in the order of inheritance.
- Member objects constructors — in the order of declaration
- Derived class constructor.
Destructor are invoked in the reverse order

Problem Sets

Problem Set A

1. Create a set of classes named A, B, C, D, E, F, & G with the following inheritance relationship:

Give each class a constructor and destructor only that print simple trace messages to the screen(‘like Constructor A or Destructor A ). Use non-virtual inheritance. Test each of the classes individually by creating objects of each type in a Test Program. Study the constructor and destructor trace messages and submit the trace.
The Trace document should contain the trace output for each of the classes individually by creating objects of each type.

Name the program as: PA1_NonVirtualInheritance.cpp
Name the Trace Document as: PA1_NonVirtualInheritance.doc

Problem Set B

1. Create a set of classes named A, B, C, D, E, F, & G with the following inheritance relationship:

Give each class a constructor and destructor only that print simple trace messages to the screen(‘like Constructor A or Destructor A ). Use virtual qualifier in the inheritance wherever necessary. Test each of the classes individually by creating objects of each type in a Test Program. Study the constructor and destructor trace messages and submit the trace.
The Trace document should contain the trace output for each of the classes individually by creating objects of each type.

Name the program as: PB1_VirtualInheritance.cpp
Name the Trace Document as: PB1_VirtualInheritance.doc

Problem Set C

1. Thomson publishing company markets both books and video-cassette. Create a class called Publication that stores the title(string) and price(float) of a publication. From this class derive two classes: Book which adds a page count (type int); and VideoCassette, which adds a playing time (type int) in minutes. Each of these classes should have a getdata() function to get its data from the user and a putdata()function to display its data.

Add another base class Sales that holds an array of three floats so that it can record the sales of a particular publication for the last three months. Include a getdata() function to get three sales amounts from the user, and a putdata() function to display the sales figures. Alter the book andtape classes so that they are derived from both Publication and Sales. An object of class book or tape should input or output sales along with its other data. Write a main() function to create a book object and a tape object and which will update their corresponding member data along with the sales made.

Inheritance

seshhu143 — Sun, 11 Oct 2009 11:15:31 +0000

Learning Objectives

At the end of this module, you will be able to

Understand the implementation of inheritance in C++
Override the base class members
Access overridden base class members using the scope resolution operator
Understand the concept of base class initialization

Introduction

Inheritance

The philosophy behind inheritance is to portray things as they exist in the real world. As inheritance is found in real world, it is important feature of OO programming. Inheritance has many advantages, the most important of them being the resuability of code. Once a class is defined and debugged, it can be used to create new subclasses. The reuse of existing class saves time and effort.

The Class from which another class is derived is called the base class. The class which inherits the properties of the base class is called the derived class. Each instance of the derived class includes all the members of the base class. Since the derived class inherits all properties of the base class, the derived class has a larger set of properties than its base class. However, the derived class may override some or all the properties of the base class.

Any class can be a base class. More than one class can be derived from a single base class, and a derived class can be a base class to another.

if class d1 is inherited from class b1, then the syntax for declaring class derived is

class d1::public b1

An object defined outside the class can access only the public members of the class. Therefore, private members of a class cannot be directly accessed from outside the class. This holds true even for a derived class. Even though the derived class inherits all the members data and functions from the base class, private members of the base class are not directly accessible from the derived class. The idea behind this is never to compromise on encapsulation implemented through data hiding.

The protected members of a class can be accessed by its members functions, or within any class derived from it. Protected members behave like public members with respect to the derived class and like private members with respect to the rest of the program.

Overriding Base Class Members

A base class members can be overridden by defining a derived class member with the same name as that of the base class member.

If the function exists in both the derived class and the base class then.

If the function is invoked from an Object of the derived class, then the function in the derived class is executed.
If the function is invoked from an Object of the base class, then the base class member function is invoked.

Inheritance Example in Real World

In a Banking System, Manager, Officers, Clerk have some common and as well as special behavior (specific tasks/actions). The commonality is that they are all employees of the Bank. A generalized class “Employee_GeneralizedClass” could be used to represent the commonality among Object classes.

The generalization is often referred to as inheritance, and the generalized class as parent class. inheritance is a means of specifying hierarchical relationships between object classes.

Points to Remember

The class from which a subclass is derived is referred to as the base class’.
Base class constructors and destructors are not inherited by the derived class.
Derived class constructors must explicitly call the base class constructors with appropriate parameters.
Destructors are invoked in the reverse order.

Inheritance:

Protected:

http://www.parashift.com/c++-faq-lite/basics-of-inheritance.html#faq-19.6

Steps to attack the problem sets

Step 1: Read the Introduction
Step 2: Go through the Videos given in the Resources.
Step 3: Go through the given PPT on Inheritance and try sample problems given in the PPT.(you can copy paste the programs from the PPT)
Step 4: Go through the additional resources give for further clarification.
Step 5: Attack the problem sets in the given order(Problem Set A and then Problem Set B).
Step 6: If you are not clear with the problem sets then contact your respective mentor for clarification.

Spend at least 2 hours from Step 1 to Step 4.

Problem Sets

Problem Set A

1. Draw an inheritance hierarchy for classes Quadrilateral, TRapezoid, Parallelogram, Rectangle and Square. Use Quadrilateral as the base class of the hierarchy. Make the hierarchy as deep as possible.

The diagrams should include the state and behavior for each class.

Example Image for Inheritance is:

Name the document as : PA1_Quadrilateral.doc

2. Draw an inheritance hierarchy for classes Shapes. Circle, Square, Triangle and Quadrilateral(described in previous task). Use the Shapes as the base class for the hierarchy. Make the hierarchy as deep as possible.

The diagrams should include the state and behavior for each class. Refer to the image given in PA1.

Refer: To the PPT given in the resources for inheritance.

Name the document as : PA2_Shapes.doc

Problem Set B

1. (Account Inheritance Hierarchy) Create an inheritance hierarchy that a bank might use to represent customers’ bank accounts. All customers at this bank can deposit (i.e., credit) money into their accounts and withdraw (i.e., debit) money from their accounts. More specific types of accounts also exist. Savings accounts, for instance, earn interest on the money they hold. Checking accounts, for instance, charge a fee per transaction (i.e., credit or debit). Current accounts, on other hand, has overdraft(Negative balance) facility to withdraw the money.

Create an inheritance hierarchy containing base class Account and derived classes SavingsAccount, CheckingAccount and CurrentAccount that inherit from class Account. Base class Account should include one data member of type double to represent the account balance. The class should provide a constructor that receives an initial balance and uses it to initialize the data member. The constructor should validate the initial balance to ensure that it is greater than or equal to 0.0. If not, the balance should be set to 0.0 and the constructor should display an error message, indicating that the initial balance was invalid. The class should provide three member functions. Member function credit should add an amount to the current balance. Member function debit should withdraw money from the Account and ensure that the debit amount does not exceed the Account’s balance. If it does, the balance should be left unchanged and the function should print the message “Debit amount exceeded account balance.” Member function getBalance should return the current balance.

Derived class SavingsAccount should inherit the functionality of an Account, but also include a data member of type double indicating the interest rate (percentage) assigned to the Account. SavingsAccount’s constructor should receive the initial balance, as well as an initial value for the SavingsAccount’s interest rate. SavingsAccount should provide a public member function calculateInterest that returns a double indicating the amount of interest earned by an account. Member function calculateInterest should determine this amount by multiplying the interest rate by the account balance. [Note: SavingsAccount should inherit member functions credit and debit as is without redefining them.]

Derived class CheckingAccount should inherit from base class Account and include an additional data member of type double that represents the fee charged per transaction. CheckingAccount’s constructor should receive the initial balance, as well as a parameter indicating a fee amount. Class CheckingAccount should redefine member functions credit and debit so that they subtract the fee from the account balance whenever either transaction is performed successfully. CheckingAccount’s versions of these functions should invoke the base-class Account version to perform the updates to an account balance. CheckingAccount’s debit function should charge a fee only if money is actually withdrawn (i.e., the debit amount does not exceed the account balance). [Hint: Define Account's debit function so that it returns a bool indicating whether money was withdrawn. Then use the return value to determine whether a fee should be charged.]

Derived class CurrentAccount should inherit the functionality of an Account, but also include a data member of type double indicating the maximum overdraft limit (percentage) assigned to the Account. CurrentAccount’s constructor should receive the initial balance, as well as an initial value for the CurrentAccount’s maximum overdraft limit. CurrentAccount should redefine member function debit, so that the account holder can withdraw money upto a maximum of overdraft limit if the balance is below 0. [Note: An overdraft occurs when withdrawals from a bank account exceed the available balance which gives the account a negative balance]

After defining the classes in this hierarchy, write a Test program that creates objects of each class and tests their member functions. For Example: Add interest to the SavingsAccount object by first invoking its calculateInterest function, then passing the returned interest amount to the object’s credit function.

You can write the class declarations in separate header files’as given in the example of the PPT anddefinitions in separate CPP file.

Use the Project in Dev C++ (File->New->Project) to compile and execute the programs

Operator Overloading

seshhu143 — Sun, 11 Oct 2009 11:12:52 +0000

Learning Objectives

Objective is to better understand

Constructor
Destructor
Operator Overloading
Dynamic Memory Allocation

and also gain additional practice with classes

Resources

Problem Sets

Problem Set A

1. Consider a polynomial with integer coefficients, for instance 5x³ -4 x² + 5. We can represent this polynomial by array of integers. The 0^th element of the array is the coefficient of the x⁰ term (5 in our example), the 1st element of the array is the coefficient of the x¹ term (0 in our example), the 2^nd element of the array is the coefficient of the x² term (-4 in our example), etc. The size of the array determines how large a degree the polynomial can have: a polynomial with degree d will need an array with at least d+ 1 elements. Note that the actual degree of the polynomial may be smaller than (size of vector – 1), since some of the higher order terms may have zero coefficients.
In this problem set, you will implement a Polynomial class. The polynomial class is having two members: array of integers and degree of polynomial as integer. It should support the following member functions.

Int degree() – Return the degree the of the polynomial
Polynomial addition(const Polynomial &p) – Returns the sum q + p, where q is the polynomial object whose member function is called. The degree of this sum will be at most max (degree(q), degree(p)).
Polynomial sub(const Polynomial &p) – Returns the subtraction q – p, where q is the polynomial object whose member function is called. The degree of this subtract will be at most max (degree(q), degree(p)).
Polynomial multiply(const Polynomial&p) – Returns the product qp, where q is the polynomial object whose member function is called. The degree of this sum will be exactly degree(q) + degree(p).
bool equal(const Polynomial&p) – Returns true if q is the same polynomial as p, and false otherwise, where q is the polynomial object whose member function is called. Two polynomials are equal if and only if (1) they have the same degree and (2) the coefficient of the terms of the same degree are equal.
void read() – Reads the polynomial from cin. Your code should prompt the user for the degree of the polynomial, create a array with the correct size, and then use a loop to prompt and input each coefficient.
void print() – Outputs the polynomial to cout. The polynomial should be printed out using a format that resembles the following: 5x^3 -4x^2 + 5.
int evaluate(int x) - method to compute and return the polynomial evaluated at x
Additionally, the class should have the following constructors:
1. Polynomial () – The polynomial is initialized to be a degree 1 polynomial whose only coefficient is zero.
2. Polynomial (int d) – The polynomial is initialized to be a degree d polynomial. That is, the array should have size d+1 whose coefficients are all zero.
3. Polynomial (string s) – The polynomial is initialized to the string.
4. Polynomial (const Polynomial &p) – The polynomial is initialized to the polynomial passed (Know as copy constructor).
The class should have the following operators overloaded
1. =
2. ==
3. +=
4. +
5. –
6. -=
7. *
8. *=
9. << (as cout << p)Refer: http://gethelp.devx.com/techtips/cpp_pro/10min/10min0400.asp
10. >> (as cin >> p) Refer: http://www.csse.monash.edu.au/~jonmc/CSE2305/Topics/10.19.OpOverload/html/text.html#an_important_use_of_operator_overloading
~Polynomial() – The class should have destructor to delete the memory allocated to the integer array

Write a short test main function for polynomial class with the menu option like

"What would you like to do?"
#Give a value to a polynomial(print the polynomial)
#Add the two polynomials
#Multiply the two polynomials
#Subtract the two polynomials
#Test equality of the two polynomial
#Evaluate the two polynomials for a given value of x
#Quit

You can add few more option to the menu if you like

Name the program as: PA1_Polynomial.cpp

Creation and Behavior of software Objects

seshhu143 — Sun, 11 Oct 2009 11:06:25 +0000

Learning Objectives

On successful completion of this module you should be able to:

explain the purpose of a class constructor and identify a default constructor for a class
explain the purpose of a class destructor and identify a default destructor for a class
Apply function overloading
Apply operator overloading
code and use simple C++ classes using the following facilities:
- public member functions and private data members
- one or more constructors, including where appropriate, a default constructor
- Overloading of functions
- Operator overloading

Introduction

The Class

The class is a data type which specifies the data and the permissible operations on the instance of this class. The set of operations define the interface of the objects of the class. The class definition consists of zero or more data members, which together define the data part and zero or more member functions, which together define the interface. In addition, there are three levels of program access, that are associated with a class.

The members (data or functions) can be declared to be

Private members of the class are hidden and can be accessed only with in the class. Access to them members is denied from out side the class
Protected members are accessible within the class and to the derived class(to be covered in next modules)
Public members are visible outside the class and can be accessed from anywhere within the program.

A class looks just like a struct, and indeed they are almost equivalent. By convention we always use class for abstract data types and only use struct for ‘ordinary data structures’ that don’t have member functions. The only difference between class and struct is that the default access control for members is private in the former and public in the latter.

A class consists of data memebers and member functions. Each having different program access level.

The data memebers, specify the attributes/state of the objects of the class. The data members define the name of the attributes and their type.

The member function describes behavior of an object-class and act on state (variables/fields) of an object-class. The member functions collectively define the interface of an object of a class. The special trait about member functions is they can access the private/protected data members (state variables/fields) of their class and manipulate them. No external functions can access the private/protected data members of a class.

The Class Scope

Every class defines the scope for the members in it. The data members of a class may be defined, before they are used in a member functions, or can be used in the member functions, and may be defined later in the class. The data members have the class scope, immaterial of where they are defined in the class.

Constructor

A constructor is also a member function, the first function called while creating an object. It could contain initializations to the variables of the object or calling other functions etc. The constructor by nature cannot return any value. The return has to be void. It can however take an argument list. The constructor has the same name as the class but having different argument list.

The constructor can be defined within the class definition or outside of it, just as any other member function definition. It can also be defined outside the class and made inline, just as other member functions can be

The constructor which takes no arguments is called the default constructor.

Overloading constructor:When constructor are overloaded, the constructor must vary in the argument list. Upon object creation, that constructor for which there is match between the formal and the actual parameters, is invoked.

Copy constructor

A copy constructor is a special constructor in the C++ programming language used to create a new object as a copy of an existing object. First argument of such constructor is a reference to an object of the same type as being constructed (const or non-const), which might be followed by parameters of any type (all having default values).

Normally the compiler automatically creates a copy constructor for each class (known as an implicit copy constructor) but for special cases the programmer creates the copy constructor, known as an explicit copy constructor. In such cases, the compiler doesn’t create one.

Refer: http://www.fredosaurus.com/notes-cpp/oop-condestructors/copyconstructors.html

Destructor

The destructor destroys a previously created object. The destructor takes no arguments and cannot return a value. The destructor has the same name as of the class, except that the name is preceded by a ~ (tilda).

Composite Class

A Composite object can be defined as one which consists of other objects.

As an example, consider the class Circle as composite object containing an instance of Point, representing the centre and radius which is of type, float. The definition of Point and Circle in this case would be.

class Point{
 float x;
 float y;
};

class Circle{
 float radius;
 Point centre;
};

Function Overloading

In order to overload a function, a different signature should be used for each overloaded version. A function signature consists of the list of types of its arguments as well as their order. Here’s a set of valid overloaded versions of a function named f:

void f(char c, int i);
void f(int i, char c);
void f(string & s);
void f();
void f(int i);
void f(char c);

Note, however, that a function differing only by return type is illegal (it is legal to use different a return type with a different argument list, though) :

int f();  //error; differs from void f(); above only by return type
int f(float f);  //fine. unique signature

You can overload the member functions in a class.

Refer: http://publib.boulder.ibm.com/infocenter/macxhelp/v6v81/index.jsp?topic=/com.ibm.vacpp6m.doc/language/ref/clrc11cplr312.htm Function Overloading
Refer for example: http://smart2help.com/e-books/ticpp-2nd-ed-vol-one/Chapter07.html

Operator Overloading

When a class is defined, a set of operations are associated with it which together define the behavior of the instance of the class. So far, mnemonics have been used to name the operation. In some situations, it may be desirable to use operators which have conventional meaning rather than use a name for it. For example, consider the class IntSet, a set of integers class. To check if two instances are equal, one way is to define a member function

int IntSet::equal(IntSet &s2);

in the class IntSet, which could be used as follows:

if s1.equal(s2)

Another way of doing this is to overload the C++ “==” operator in the class IntSet. The same functionalily can be coded as:

if (s1==s2)

The C++ Operators which can be overloaded are arithmetic, logical, relational operators, as well as call(), subscripting[], dereferencing ->, assignment =, the extraction <<>> operators.

Refer: http://publib.boulder.ibm.com/infocenter/macxhelp/v6v81/index.jsp?topic=/com.ibm.vacpp6m.doc/language/ref/clrc11cplr318.htm Operator Overloading
Refer for example: http://www.cplusplus.com/doc/tutorial/classes2/

The keyword this

The keyword this represents a pointer to the object whose member function is being executed. It is a pointer to the object itself.

One of its uses can be to check if a parameter passed to a member function is the object itself.

Problem Sets

Problem Set A

1. Define a class Random to provide random numbers within a range that is specified through the constructor. The class should provide a draw function to get a random number.

Use the code given below for the Random Class. You need to write the code in the given program wherever it is commented as write the code here o

#include //For I/O
#include     // For time()
#include   // For srand() and rand()

using namespace std;

class Random{
     private:
             int max;
             int min;
     public:
            Random(){
                 cout << "Default Random Constructor is called and default values set with Min 10 and Max 20\n";
                    //Write the code here to set the default values for min 10 and max 20
            }
            Random(int minA, int maxA){
                 cout << "Random Constructor called with argument of Min"<< minA << " and Max"<

Refer: http://www.fredosaurus.com/notes-cpp/misc/random.html

Name the program as: PA1_random.cpp

Problem Set B

1. Write a class called Point that is capable of representing the coordinates of a point on a two-dimensional graph. You must permit creation of variables as follows:

Point p, q(2.1, -4.3);

The declaration of p above will be for the point (0,0).

Provide the following operations:

Return the x coordinate or the y coordinate
Set the x coordinate or the y coordinate
Return the distance from the origin, formula is sqrt(x² + y²)
Input a point as two floating point numbers
Output a point in the format (2.1,-4.3)

Write a short test main function for your class.

Refer: http://www.cppreference.com/wiki/c/math/start

Name the program as PB1_Point.cpp

Problem Set C

1. Write a class to hold the time of day. You must permit the creation of variables as follows:

Time t1, t2(3600), t3(12,00), t4(23, 59, 59);

In this case t1 is set to 00:00:00, t2 to 01:00:00 (3600 seconds), t3 to 12:00:00 and t4 to 23:59:59.

Provide the following operations:

Return the hours, minutes or seconds
Return the total seconds using a cast operator overload to type long
Set the hours, minutes or seconds
Automatically convert an integer to a time, interpreting the integer value as the number of seconds
Input a time as three integers in the format hh:mm:ss
Output the time in the format hh:mm:ss
Add a specified number of seconds to a time
Overload the operator = for assignment and == for equality.

Write a short test main function for your class.

Identifying Objects and Creating Software Objects

seshhu143 — Sun, 11 Oct 2009 10:56:39 +0000

Learning Objective

Identifying Real world Objects
Creating Software Objects using class.
Implement state and behavior of software objects.

Instructional Activities

Reference Reading:

Problem Sets

Problem Set A

1. Identify 5 objects in real world

List the state of these objects
List the behavior of these objects
Note: Your list of objects should be unique from the entire class. Otherwise you would be give zero marks for the whole of this module

Problem Set B

1. Classes and Objects: Using the following class create an object for it in the main program

   class Integer {
     private:
         int integer;
     public:
         void readInteger();
         void printMessage();
  };

 void Integer::readInteger() {
      cout<<"enter the value of N";
       cin>>N;
 }
 void Integer::printMessage() {
              for (int i = 0 ; i < N ; i++) {
                  cout<

Create a object called “intobj” for the class “Integer” in the main program
- Call intobj.readInteger() and intobj.printMessage() from the main program
- Add another member function called int addInteger(int no) to the class Integer.
- The function addInteger() returns the sum of the value of “N + no”.
- Call intobj.addInteger() from the main program
Create a class called “class Circle { };”
- Add members function to readRadius
- Add a member function to displayArea
- Create an object for the class Circle
- Call the member functions readRadius() and displayArea() from the main program.

2. Create the class called ‘Math’.

  class Math{
  private:
    int ival
  public:
     int sum(int x, int y);
 };

Create a class called “Math”
- Complete the member function int sum(int x, int y);
  - return the sum of x and y;
- Write a main program which creates an object say “m” for the class “Math”
  - From the main program read two integers i1, i2.
  - Call the member function “total = m.sum(i1, i2)” to get the sum of i1 + i2
Accessing private member in member functions:
- Modify the member functions so that sum() stores the output in ival.
- ival = x + y; return ival;

Problem Set C

1. Create a class called State() with the following member functions

readDistricts(); //read N = no of districts, dynamically allocated memory for N strings, read each district name from the stdin.
printDistricts(); //print the district names on the standard output (display-screen);
Use dynamic allocation of strings in the classes is compulsory:

Create an object for the class State in the main program
Call read_districts() and printDistricts() from the main program

2. Create class called Interest

Create class called Interest with the following attributes and behavior
- Attributes
  - Principle Amount
  - Number of Years
  - Rate of Interest
- Behavior
  - readPrincipleAmount();
  - readNoOfYears();
  - readInterestRatePY();
  - calcuateSimpleInterest();
  - calculateCompoundInterest();
Create an object for the class Interest in the main program
call member functions, read* to read principle amount, no. of years and interest rate
call calcuateSimpleInterest() and calculateCompoundInterest() to display the amount+interest separately.

3. Create class for 3 Objects identified in Problem Set A 1

Create 3 classes with state and behavior identified.

Create an object for the 3 classes in the main program and test them.

Introduction to C++ and differences between C

seshhu143 — Sun, 11 Oct 2009 10:41:49 +0000

Learning Objective

To know differences between C and C++
Demonstrate the capability of programming in C++
Apply C++ syntax, New/Delete and Reference operations

Introduction

Origins of C++

Stroustrup began work on C with Classes in 1979. The idea of creating a new language originated from Stroustrup’s experience in programming for his Ph.D. thesis. Stroustrup found that Simula (another programming language) had features that were very helpful for large software development, but the language was too slow for practical use.

Stroustrup set out to enhance the C language with Simula-like features. C was chosen because it is general-purpose, fast, and portable.

The name C++”‘

This name is credited to Rick Mascitti (mid-1983) and was first used in December 1983. Earlier, during the research period, the developing language had been referred to as “new C”, then “C with Classes”.

Features of C++

Compared to the C language, C++ introduced extra features, including declarations as statements, function-like casts, new/delete, bool, reference types, inline functions, default arguments, function and operator overloading, namespaces and the scope resolution (::) operator, classes (including all class-related features such as inheritance, member functions, virtual functions, abstract classes, and constructors), templates, exception handling, runtime type identification, and the overloaded input (>>) and output (<<) operators for input and output respectively.

For more information Read

Differences between C and C++

The main difference between C and C++ is that C is a procedure oriented language where as C++ is an object oriented language we can compile and and execute all our c programs in a C++ compiler, c++ is an extension to c. C++ was first called ‘C with classes’ the ++ in C++ indicates the increment operator in C meaning C++ is an advanced language compared to C. The advantage of C++ lies in object oriented programing generally called oops. The features of OOPS are classes, data abstraction, encapsulation, inheritance, polymorphism, exception handling,etc.,

Resources

Problem Sets

Problem Set A

1. Write a simple ‘Hello, new world!’ program in C and CPP edited, compiled and running on your chosen development platform. Change the program to take a command line argument (or multiple command line arguments) and to say ‘Hello name!’

Solutions: PA1_HelloWorld.c and PA1_HelloWorld.cpp

2. Tabulate all the basic C/C++ types, eg. Char, int, float, double. Don’t forget the unsigned, signed, short, long etc. Write a simple C and C++ program to print out the sizes in bytes of each type on your system.

Solutions: PA2_BasicTypes.c and PA2_BasicTypes.cpp

3. Find out on your system what the largest and smallest values are for the basic types above? Write a program in C and C++ to print out the Limits of each data type described in previous program.

Solutions:PA3_limits.c and PA3_limits.cpp

Problem Set B

1. Write a function to print the date, for the structure Date in C and C++.

You need to write the code wherever necessary for the given program in C and C++.

Program to print date in C

include //Standard Input and Output Library

struct DATE

{

int day;
int month;
int year;

};

void showDate(struct DATE d);

void setDate(int d, int m, int year, struct DATE * date);

int main(void)

{

struct DATE date;
setDate(24,8,2009,&date);
showDate(date);
return 1;

}

void showDate(struct DATE d)

{

//Write your code here

}

void setDate(int d, int m, int y, struct DATE * date)

{

//Write your code here

}

Program to print date in C++

include //Input/Output stream Library

using namespace std;

struct Date

{

int day;
int month;
int year;
void showDate()
{
 //Write your code here

}
void setDate(int d, int m, int y){
 //Write your code here
}

};

int main(void)

{

struct Date date;
date.setDate(24,8,2009);
date.showDate();
system("PAUSE");
return 1;

}

Resources:

http://www.cs.uregina.ca/Links/class-info/cplusplus/Structure.html

Solutions: PB1_print_date.c and PB1_print_date.cpp

2. Write the struct Date(of previous program) in separate namespace in C++ and use the Date structure in main to print the date.

Solutions: PB2_ns_print_date.cpp

Problem Set C

Write the code in C++ for all the problems given in this problem set.

1. STDIO: Read an integer value N from standard input.

Print “MSIT @ IIIT Hyderabad and JNTU Hyderabad” for N times using a for-loop.

Resources:

Solutions: PC1_cout_n.cpp

2. STRINGS: use “string” variable

Read your firstName
Read your lastName
Use “+” string operator and contenate firstName and lastName with “_” in between.
Display firstName_lastName on the screen
Use length() function of string class and display the length of “firstName_lastName”
Access the characters in the string “firstName_lastName” and display one by one separated by a single space
Ex: Display “Kishore_Prahallad” as “K i s h o r e _ P r a h a l l a d”
Display the characters in reverse order
Display as “d a l l a h a r P _ e r o h s i K”

Resources

Solutions: PC2_string.cpp

3. Using new and delete in C++

New and Delete for integer:

Read an integer N
Create a 1-dimensional dynamic integer array using new[] for N integers
Read N integers from the standard input
Delete the allocated memory using delete[]

New and Delete for Strings:

Read an integer N
Create a 1-dimensional dynamic string array using new[] for N strings
Read N strings from the standard input
Delete the allocated memory using delete[]

New and Delete for 2-dimensional Matrix:

Read two integers N and M
Create a 2-dimensional dynamic integer array using new[]
Read N x M integers from standard input
Delete using delete[]

Use separate functions for integer, strings and 2D Matrix.

Resources:

http://www.cplusplus.com/doc/tutorial/dynamic.html

Solutions: PC3_new_delete.cpp