Learn C++ Programming within 2 weeks

RRS - Module 6

2009-10-13T09:33:00.002-07:00

Integrate all the modules properly so that the Railway Reservation System works efficiently. Run and test all the modules properly. Take care of exceptions if any in the system.

RRS - Module 5

2009-10-13T09:33:00.001-07:00

Before we start with this module, verify if you have completed with the previous module. Only after you complete with it, should you start with this module.

In this module we would enable the user to cancel his reserved tickets.

A user can cancel reserved ticket and the fare is refunded according to the rules given.

Cancellation Rules:
TICKETS on which Reservations has been made.

If a ticket on which reservation of a seat or berth has been made, is presented for cancellation, refund of fare shall be made after deducting cancellation charge from the fare as follows :-
1. If a ticket is presented for cancellation more than 12 hours before the scheduled departure of the train cancellation charge shall be deducted at the flat rate of Rs. 50/- for A.C Class and Rs. 20/- for Sleeper class.
2. If the ticket is presented for cancellation within 12 hours and up to 3 hours before the scheduled departure of the train, cancellation charges shall be 10% of the fare paid. (Rounded off to nearest rupee).
3. If the ticket is presented for cancellation within 3 hours and up to 30 Minutes before the scheduled departure of the train, Cancellation charges shall be 60% of the fare paid. (Rounded off to nearest rupee).
4. If the ticket is presented for cancellation after the scheduled departure of the train, refund money is Rs 0.

Steps to be followed for Cancellation part in this module are:

Login as User
Allow the user to cancel his/her ticket. (Note: The user can cancel a single ticket even when he has booked 2 tickets which have a single pnr_no)
The amount to be refunded should be mentioned to the user.
The total amount transacted on each day should also be seen by the Admin. This part should be done in the Admin Interface.

RRS - Module 4

2009-10-13T09:31:00.000-07:00

In this module let us create Ticket objects and allow the user to book his tickets

Users cannot book tickets for unscheduled trains. The user needs to check the schedule and the availability of tickets for a train and then only book tickets.

Steps to be followed to create Ticket objects:

Create a base class called Ticket, by identifying the common attributes of a Ticket
Create 2 derived classes called, AC_Ticket and SC_Ticket, for the above given base class (AC_Ticket is for AC class and SC_Ticket is for sleeper class)

Steps to be followed for Reservation part in this module are:

Login as User
Check Schedule of the trains available
Check the availability of berths
If available berths are there, allow the user to book tickets – AC or Sleeper
A User can book maximum of 2 tickets at a time. There is a single pnr number given.
Save the tickets in the folder that contains that particular train and the required day.
Display the ticket to the user in a neat format

RRS - Module 3

2009-10-13T09:29:00.001-07:00

In this module, let us create Train objects and allow Admin to schedule the trains for a week.

Steps to be followed in this module:

Create a class called Train by identifying its member variables
Write the code for the Interface Menu.
1. Login as Admin and do the following
  1. Add new trains
  2. Save the objects in file
  3. Schedule the trains for that week. (Note: Check the assumptions we made at the beginning of this project regarding scheduling)
  4. While scheduling, the folder structure to be created is
    1. RRS\TrainData\TrainNo
  5. The entire schedule could also be written into a file
  6. Display the schedule
2. Logout from Admin Interface and log into the User Interface
  1. Display the schedule based on train
  2. Display the schedule based on Source and Destination
  3. Display the schedule based on Date
  4. Display all the trains scheduled

Note: Make sure that all the display functions print the details in a neat tabular format

RRS - Module 2

2009-10-13T09:29:00.000-07:00

You have identified the objects and their members in the previous module. In this module, let us start the project by first creating the two main important objects – User and Admin

Steps to be followed in this module:

Create a base class called Person, by identifying the common attributes of user and admin
Create 2 derived classes called, User and Admin, for the above given base class
Write the code for the Interface Menu.

Mini Project - Railway Reservation System

2009-10-13T09:26:00.000-07:00

Module 1

Overview

Railway Reservation System-(RRS) Project is developed to help students learn and realize capability of C programming language, and appreciate procedural approach of developing a system.

RRS helps users reserve/cancel berths, search for trains, check reservation/cancellation history, etc...

On the other hand it helps the railway reservation officers to prepare reservation charts, organize train schedules, etc...

RRS provides two types of log-ins one is the User log-in for railway customers and the other one is Admin log-in for railway reservation officers.

Project is divided into 10 modules of four hours duration each.

All the modules will give exactly what to develop in the 4 hour time frame. Since most of the modules are inter-related it is important to keep track of the previous code. After submission it is allowed to make changes in the previous code to suit / integrate well to the system.

Before we start the project, we need to make the following assumptions:

All the seats are reserved seats.
There are only two classes for which users can book tickets
1. Sleeper
2. A/C
The number of seats in all the trains is fixed for each class
1. Sleeper – 12 seats
2. A/C – 8 seats
Passengers cannot book tickets before 5 days of travel date.
Passengers can book tickets from 5 days before the scheduled train departure time and up to 3 hours before the scheduled train departure.
All the trains will not stop in between stations.
Trains start from source station and ends at destination station.
All the transactions for booking tickets / refunding the canceled tickets are through online electronic clearance.
Maximum waiting list per each class is 4 seats.
Auto upgrade waiting list to confirmed ticket.
A user can book only 2 seats at a time.
User can book tickets for others (Family Members, Friends etc) using personal log-in account.
Each train will run on all the days of the week.

Module 1

You have already developed the project in C programming language. You would have a good idea regarding the Railway Reservation System. In this module, let’s design the project according to our previous understanding of the project.

While designing the project, make sure that you imbibe all the important aspects of object oriented concepts that you have learnt in the last 1 week. You also need to take into account the aspect of reusability of your code.

Steps to be done in this module:
1. Identify the classes that you would require in this project.
2. Identify member variables and functions of each class that you have identified in the previous step.
3. Identify where the various object oriented concepts could be used in the project – inheritance, polymorphism, virtual functions, friend functions, etc
4. Draw these classes in a word document.

The diagram shows all the member variables and functions of each class identified for a School scenario. It also shows that Student and Teacher classes are inherited from Person class.
Note: Draw the classes that you have identified for the project in a similar way as shown in the above example.
5. Identify the various details that you would require to store in files. (You need to write objects into files instead of single data). Document the folder/file structure that would make your programming efficient
6. Identify what kind of data could lead to exceptions in your project
7. Show the documentation to your mentor and take their consent

Standard Template Library

2009-10-13T09:25:00.001-07:00

Learning Objective

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

Understand Standard Template Library
Explain the need of STL
Understand and use the vector and list of STL.
Using real world objects with STL.

Standard Template Library

Introduction

The Standard Template Library (STL) is a fundamental part of the C++ Standard, is a C++ library of container classes, algorithms, and iterators; it provides many of the basic algorithms and data structures of computer science. The STL is a generic library, meaning that its components are heavily parameterized: almost every component in the STL is a template. You should make sure that you understand how templates work in C++ before you use the STL.

The STL contains several kinds of entities. The three most important are containers, algorithms,and iterators.

A container is a way that stored data is organized in memory. In earlier chapters we’ve explored two kinds of containers: stacks and linked lists. Another container, the array, is so common that it’s built into C++ (and most other computer languages). However, there are many other kinds of containers, and the STL includes the most useful. The STL containers are implemented by template classes, so they can be easily customized to hold different kinds of data.

Algorithms in the STL are procedures that are applied to containers to process their data in various ways. For example, there are algorithms to sort, copy, search, and merge data. Algorithms are represented by template functions. These functions are not member functions of the container classes. Rather, they are standalone functions. Indeed, one of the striking characteristics of the STL is that its algorithms are so general. You can use them not only on STL containers, but on ordinary C++ arrays and on containers you create yourself. (Containers also include member functions for more specific tasks.)

Iterators are a generalization of the concept of pointers: they point to elements in a container. You can increment an iterator, as you can a pointer, so it points in turn to each element in a container. Iterators are a key part of the STL because they connect algorithms with containers.

Think of them as a software version of cables (like the cables that connect stereo components together or a computer to its peripherals).

Figure below shows these three main components of the STL.

In this Module we’ll discuss and learn about containers( Vectors and List).

Resources

Web Resources:

C++ STL (Standard Template Library) Tutorial and Examples

STL:

PPT:

Chapter 28: Standard Template Library--> How to Program in C++ by Dietle and Dietle

Step to attack the problem sets

Step 1: Go through the introduction part and have an understanding about STL.
Step 2: Go through the Web Resource 1 (Try the problem sets given)
- C++ STL Tutorial Contents:
  1. STL description
  2. STL vector
  3. STL list
Step 3: Go through the PPT given (Try the problem sets given in that)
Step 4: Attack the problem sets in the given order.
Step 5: If you are not clear with the problem sets then contact your respective mentor for clarification.

Spend atleast 2-3 Hours from step 1 - step 3.

Problem Sets

Problem Set A

1. Create a vector containing the letters of the alphabets in order. Print the elements of that vector in order and in reverse order.

Name the program as: PA1_vector.cpp

Problem Set B

1. Create a list and read a list of names of fruits from cin into it. Sort the list and print it.

Name the program as: PB1_list_sort.cpp

Problem Set C

1. Write two separate functions for Week 2 Module 1 Problem Set A - 1(cricket Stats).

Function 1: Load all the data from the binary file into the List and return the List.

Function 2: Load all the data from the binary file into the Vector and return the Vector.

Comparison of two instances of Player should be based on Name.

Override the operators = , == and <>

Print all the player details sorted on Player Name Using List.

Print all the player details using Vector.

Streams & Files

2009-10-13T09:23:00.000-07:00

CPP09 W2 M1 Streams and Files

Learning Objective

Understanding streams
Understand the stream class hierarchy
Understand the concepts of stream insertion and extraction
Use streams for file input and output
Distinguish between text and binary file input and output
Write programs for random access of data files using:
- get pointer
- put pointer
- seekg()
- tellg()
- seekp()
- tellp()

Streams and Files

Introduction

In simple words, a stream is a sequence of bytes. In input operations, the bytes are transferred from a device (a keyboard, a disk drive, a network connection etc.) to the main memory. Where as in case of output operations, this is reverse. That means, the bytes are transferred from main memory to a device such as a display screen, a printer, a disk drive, network connection, a tape( a file on tape) etc.

Streams

In C++, a stream is a source or destination for collection of characters. Streams are of two types:

Output stream
Input Stream

Output streams allow you to write or store characters, and input streams allow you to read or fetch character. Applications can use both these streams.

The Stream Class Hierarchy

The stream classes are arranged in a rather complex hierarchy. Figure below shows the arrangement of the most important of these classes.

We’ve already made extensive use of some stream classes. The extraction operator >> is a member of the istream class, and the insertion operator << is a member of the ostream class. Both of these classes are derived from the ios class. The cout object, representing the standard output stream, which is usually directed to the video display, is a predefined object of the ostream_withassign class, which is derived from the ostream class. Similarly, cin is an object of the istream_withassign class, which is derived from istream.

The istream and ostream classes are derived from ios and are dedicated to input and output, respectively. The istream class contains such functions as get(), getline(), read(), and the overloaded extraction (>>) operators, while ostream contains put() and write(), and the overloaded insertion (<<) operators.

The iostream class is derived from both istream and ostream by multiple inheritance. Classes derived from it can be used with devices, such as disk files, that may be opened for both input and output at the same time. Three classes—istream_withassign, ostream_withassign, and iostream_withassign—are inherited from istream, ostream, and iostream, respectively. They add assignment operators to these classes.

The ios class is the granddaddy of all the stream classes, and contains the majority of the features you need to operate C++ streams. The three most important features are the formatting flags, the error-status flags, and the file operation mode.

Stream Insertion and Extraction

Stream Insertion

Stream classes have their own member data, functions definitions. Class ostream contains functions defined for output operations. These operations are called stream insertions. The <<>

cout<<"Hello World\n";

translates as: the text string to the right of the inserter is to be stored in the stream object on the left. The <<>

Stream Extraction

The opposite of insertion is extraction, which is fetching of data from an input stream. Input stream operations are defined in istream class. The >> operator, called the extractor, can accept any fundamental data type. The most important point to note is that the extractor skips leading white spaces(,\n\t') while extracting any of these data types. cin is the predefined object if the istream class attached to standard input device which is keyboard.

User defined Streams

The input and output streams discussed so far dealt only with standard input and output. C++ also provides specific classes which deal with user-defined streams. User-defined streams are in the form of files. In C++ a files is linked to a stream. Before a file can be opened. a stream must be obtained. These streams are more powerful than the pre-defined streams.

File I/O with Streams

Most programs need to save data to disk files and read it back in. Working with disk files requires another set of classes: ifstream for input, fstream for both input and output, and ofstream for output. Objects of these classes can be associated with disk files, and we can use their member functions to read and write to the files.

Referring back to Figure previously, you can see that ifstream is derived from istream, fstream is derived from iostream, and ofstream is derived from ostream. These ancestor classes are in turn derived from ios. Thus the file-oriented classes derive many of their member functions from more general classes. The file-oriented classes are also derived, by multiple inheritance, from the fstreambase class. This class contains an object of class filebuf, which is a fileoriented buffer, and its associated member functions, derived from the more general streambuf class. You don’t usually need to worry about these buffer classes.

The ifstream, ofstream, and fstream classes are declared in the FSTREAM file.

Formatted File I/O

In formatted I/O, numbers are stored on disk as a series of characters. Thus 6.02, rather than being stored as a 4-byte type float or an 8-byte type double, is stored as the characters ‘6’, ‘.’, ‘0’, and ‘2’. This can be inefficient for numbers with many digits, but it’s appropriate in many situations and easy to implement. Characters and strings are stored more or less normally.

Writing Data

The following program writes a character, an integer, a type double, and two string objects to a disk file. There is no output to the screen. Here’s the listing for FORMATO:

// formato.cpp
// writes formatted output to a file, using <<
#include  //for file I/O
#include 
#include 
using namespace std;
int main()
{
char ch = ‘x’;
int j = 77;
double d = 6.02;
string str1 = "Kafka"; //strings without
string str2 = "Proust"; // embedded spaces
ofstream outfile("fdata.txt"); //create ofstream object
if(!outfile){
 cout<<"Error Opening File";
 return 0;
}
outfile << ch //insert (write) data
        << j
        << ‘ ‘ //needs space between numbers
        << d
        << str1
        << ‘ ‘ //needs spaces between strings
        << str2;
cout << "File written\n";
return 0;
}

Here we define an object called outfile to be a member of the ofstream class. At the same time, we initialize it to the file FDATA.TXT. This initialization sets aside various resources for the file, and accesses or opens the file of that name on the disk. If the file doesn’t exist, it is created. If it does exist, it is truncated and the new data replaces the old. The outfile object acts much as cout did in previous programs, so we can use the insertion operator (<<) to output variables of any basic type to the file. This works because the insertion operator is appropriately overloaded in ostream, from which ofstream is derived.

When the program terminates, the outfile object goes out of scope. This calls its destructor, which closes the file, so we don’t need to close the file explicitly. There are several potential formatting glitches. First, you must separate numbers (such as 77 and 6.02) with nonnumeric characters. Since numbers are stored as a sequence of characters, rather than as a fixed-length field, this is the only way the extraction operator will know, when the data is read back from the file, where one number stops and the next one begins. Second, strings must be separated with whitespace for the same reason. This implies that strings cannot contain imbedded blanks. In this example we use the space character (‘ ‘) for both kinds of delimiters. Characters need no delimiters, since they have a fixed length. You can verify that FORMATO has indeed written the data by examining the FDATA.TXT file with the Windows WORDPAD accessory or the DOS command TYPE.

Reading Data

We can read the file generated by FORMATO by using an ifstream object, initialized to the name of the file. The file is automatically opened when the object is created. We can then read from it using the extraction (>>) operator.

Here’s the listing for the FORMATI program, which reads the data back in from the FDATA.TXT file:

// formati.cpp
// reads formatted output from a file, using >>
#include  //for file I/O
#include 
#include 
using namespace std;

int main()
{
char ch;
int j;
double d;
string str1;
string str2;
ifstream infile("fdata.txt"); //create ifstream object
if(!infile){
  cout<<"File Cannot be opened";
  return 0;
  }
//extract (read) data from it
infile >> ch >> j >> d >> str1 >> str2;
cout << ch << endl //display the data
     << j << endl
     << d << endl
     << str1 << endl
     << str2 << endl;

return 0;
}

Here the ifstream object, which we name infile, acts much the way cin did in previous programs. Provided that we have formatted the data correctly when inserting it into the file, there’s no trouble extracting it, storing it in the appropriate variables, and displaying its contents. The program’s output looks like this:

x
77
6.02
Kafka
Proust

Of course the numbers are converted back to their binary representations for storage in the program. That is, the 77 is stored in the variable j as a type int, not as two characters, and the 6.02 is stored as a double.

Character I/O

The Character I/O functions such as get() and put() can be used when the programmer wishes to read / write white space characters also. So, with Character I/O the problem of accepting and writing character/string with white spaces is solved.

The put() and get() functions, which are members of ostream and istream, respectively, can be used to output and input single characters. Here’s a program, OCHAR, that outputs a string, one character at a time:

// ochar.cpp
// file output with characters
#include  //for file functions
#include 
#include 
using namespace std;
int main()
{
string str = "Time is a great teacher, but unfortunately "
             "it kills all its pupils. Berlioz";
ofstream outfile("TEST.TXT"); //create file for output

if(!outfile){
  cout<<"File Cannot be opened";
  return 0;
  }

for(int j=0; j<str.size(); j++) //for each character,
 outfile.put( str[j] ); //write it to file
cout << "File written\n";
return 0;
}

The length of the string object str is found using the size() member function, and the characters are output using put() in a for loop.

We can read this file back in and display it using the ICHAR program.

// ichar.cpp
// file input with characters
#include  //for file functions
#include 
using namespace std;
int main()
{
char ch; //character to read
ifstream infile("TEST.TXT"); //create file for input

if(!infile){
  cout<<"File Cannot be opened";
  return 0;
  }

while( infile ) //read until EOF or error
{
 infile.get(ch); //read character
 cout << ch; //display it
}
cout << endl;
return 0;
}

Binary Input and Output

All the input and output opeartions you have seen so far are text or character based. That is, all information is stored in the same format as it would be dispalyed on the screen.

You can write a few numbers to disk using formatted I/O, but if you’re storing a large amount of numerical data it’s more efficient to use binary I/O, in which numbers are stored as they are in the computer’s RAM memory, rather than as strings of characters. In binary I/O an int is stored in 4 bytes, whereas its text version might be "12345", requiring 5 bytes. Similarly, a float is always stored in 4 bytes, while its formatted version might be "6.02314e13", requiring 10 bytes.

Our next example shows how an array of integers is written to disk and then read back into memory, using binary format. We use two new functions: write(), a member of ofstream; and read(), a member of ifstream. These functions think about data in terms of bytes (type char). They don’t care how the data is formatted, they simply transfer a buffer full of bytes from and to a disk file. The parameters to write() and read() are the address of the data buffer and its length. The address must be cast, using reinterpret_cast, to type char*, and the length is the length in bytes (characters), not the number of data items in the buffer. Here’s the listing for BINIO:

// binio.cpp
// binary input and output with integers
#include  //for file streams
#include 
using namespace std;
const int MAX = 100; //size of buffer
int buff[MAX]; //buffer for integers
int main()
{
for(int j=0; j<MAX; j++) //fill buffer with data
buff[j] = j; //(0, 1, 2, ...)
             //create output stream
ofstream os("edata.dat", ios::binary);
if(!os){
        cerr << "File cannot be opened\n";
}
//write to it
os.write( reinterpret_cast<char*>(buff), MAX*sizeof(int) );
os.close(); //must close it
for(j=0; j<MAX; j++) //erase buffer
buff[j] = 0;
//create input stream
ifstream is("edata.dat", ios::binary);
//read from it
is.read( reinterpret_cast<char*>(buff), MAX*sizeof(int) );
for(j=0; j<MAX; j++) //check data
if( buff[j] != j )
{
  cerr << "Data is incorrect\n";
  return 1;
  }
  cout << "Data is correct\n";
  return 0;
}

You must use the ios::binary argument in the second parameter to write() and read() when working with binary data. This is because the default, text mode, takes some liberties with the data. For example, in text mode the ‘\n’ character is expanded into two bytes—a carriagereturn and a linefeed—before being stored to disk. This makes a formatted text file more readable by DOS-based utilities such as TYPE, but it causes confusion when it is applied to binary data, since every byte that happens to have the ASCII value 10 is translated into 2 bytes. The ios::binary argument is an example of a mode bit. We’ll say more about this when we discuss the open() function later in this chapter.

The reinterpret_cast Operator

In the BINIO program (and many others to follow) we use the reinterpret_cast operator to make it possible for a buffer of type int to look to the read() and write() functions like a buffer of type char.

is.read( reinterpret_cast(buff), MAX*sizeof(int) );

The reinterpret_cast operator is how you tell the compiler, “I know you won’t like this, but I want to do it anyway.” It changes the type of a section of memory without caring whether it makes sense, so it’s up to you to use it judiciously. You can also use reinterpret_cast to change pointer values into integers and vice versa. This is a dangerous practice, but one which is sometimes necessary.

Closing Files

So far in our example programs there has been no need to close streams explicitly because they are closed automatically when they go out of scope; this invokes their destructors and closes the associated file. However, in BINIO, since both the output stream os and the input stream is are associated with the same file, EDATA.DAT, the first stream must be closed before the second is opened. We use the close() member function for this. You may want to use an explicit close() every time you close a file, without relying on the stream’s destructor. This is potentially more reliable, and certainly makes the listing more readable.

Object I/O

Since C++ is an object-oriented language, it’s reasonable to wonder how objects can be written to and read from disk. The next examples show the process.

Writing an Object to Disk

When writing an object, we generally want to use binary mode. This writes the same bit configuration to disk that was stored in memory, and ensures that numerical data contained in objects is handled properly. Here’s the listing for OPERS, which asks the user for information about an object of class person, and then writes this object to the disk file PERSON.DAT:

// opers.cpp
// saves person object to disk
#include  //for file streams
#include 
using namespace std;
////////////////////////////////////////////////////////////////
class person //class of persons
{
protected:
          char name[80]; //person’s name
          short age; //person’s age
public:
       void getData() //get person’s data
       {
        cout << “Enter name: “; cin >> name;
        cout << “Enter age: “; cin >> age;
        }
};

////////////////////////////////////////////////////////////////
int main()
{
person pers; //create a person
pers.getData(); //get data for person
//create ofstream object
ofstream outfile(“PERSON.DAT”, ios::binary);
if(!outfile){
 cerr << "File cannot be Opened";
 return 0;
}
//write to it
outfile.write(reinterpret_cast<char*>(&pers), sizeof(pers));
return 0;
}

The getData() member function of person is called to prompt the user for information, which it places in the pers object. Here’s some sample interaction:

Enter name: Coleridge
Enter age: 62

The contents of the pers object are then written to disk, using the write() function. We use the sizeof operator to find the length of the pers object.

Reading an Object from Disk

Reading an object back from the PERSON.DAT file requires the read() member function. Here’s the listing for IPERS:

// ipers.cpp
// reads person object from disk
#include  //for file streams
#include 
using namespace std;
////////////////////////////////////////////////////////////////
class person //class of persons
{
protected:
          char name[80]; //person’s name
          short age; //person’s age
public:
       void showData() //display person’s data
       {
        cout << “Name: “ << name << endl;
        cout << “Age: “ << age << endl;
        }
};

////////////////////////////////////////////////////////////////
int main()
{
person pers; //create person variable
ifstream infile(“PERSON.DAT”, ios::binary); //create stream
if(!infile){
 cerr << "File cannot be opened";
 return 0;
 }
//read stream
infile.read( reinterpret_cast<char*>(&pers), sizeof(pers) );
pers.showData(); //display person
return 0;
}

The output from IPERS reflects whatever data the OPERS program placed in the PERSON.DAT file:

Name: Coleridge
Age: 62

Compatible Data Structures

To work correctly, programs that read and write objects to files, as do OPERS and IPERS, must be talking about the same class of objects. Objects of class person in these programs are exactly 82 bytes long: The first 80 are occupied by a string representing the person’s name, and the last 2 contain an integer of type short, representing the person’s age. If two programs thought the name field was a different length, for example, neither could accurately read a file generated by the other.

Notice, however, that while the person classes in OPERS and IPERS have the same data, they may have different member functions. The first includes the single function getData(), while the second has only showData(). It doesn’t matter what member functions you use, since they are not written to disk along with the object’s data. The data must have the same format, but inconsistencies in the member functions have no effect. However, this is true only in simple classes that don’t use virtual functions.

If you read and write objects of derived classes to a file, you must be more careful. Objects of derived classes include a mysterious number placed just before the object’s data in memory. This number helps identify the object’s class when virtual functions are used. When you write an object to disk, this number is written along with the object’s other data. If you change a class’s member functions, this number changes as well. If you write an object of one class to a file, and then read it back into an object of a class that has identical data but a different member function, you’ll encounter big trouble if you try to use virtual functions on the object. The moral: Make sure a class used to read an object is identical to the class used to write it.

You should also not attempt disk I/O with objects that have pointer data members. As you might expect, the pointer values won’t be correct when the object is read back into a different place in memory.

I/O with Multiple Objects

The OPERS and IPERS programs wrote and read only one object at a time. Our next example opens a file and writes as many objects as the user wants. Then it reads and displays the entire contents of the file. Here’s the listing for DISKFUN:

// diskfun.cpp
// reads and writes several objects to disk
#include  //for file streams
#include 
using namespace std;
////////////////////////////////////////////////////////////////
class person //class of persons
{
protected:
          char name[80]; //person’s name
          int age; //person’s age
public:
       void getData() //get person’s data
       {
            cout << “\n Enter name: “; cin >> name;
            cout << “ Enter age: “; cin >> age;
        }
        void showData() //display person’s data
        {
         cout << “\n Name: “ << name;
         cout << “\n Age: “ << age;
        }
};

////////////////////////////////////////////////////////////////
int main()
{
char ch;
person pers; //create person object
fstream file; //create input/output file
//open for append
file.open(“GROUP.DAT”, ios::app | ios::out |
ios::in | ios::binary );
do //data from user to file
{
cout << “\nEnter person’s data:”;
pers.getData(); //get one person’s data
//write to file
file.write( reinterpret_cast<char*>(&pers), sizeof(pers) );
cout << “Enter another person (y/n)? “;
cin >> ch;
}

while(ch==’y’); //quit on ‘n’

file.seekg(0); //reset to start of file

//read first person
file.read( reinterpret_cast<char*>(&pers), sizeof(pers) );
while( !file.eof() ) //quit on EOF
{
cout << “\nPerson:”; //display person
pers.showData(); //read another person
file.read( reinterpret_cast<char*>(&pers), sizeof(pers) );
}

cout << endl;
return 0;
}

Here’s some sample interaction with DISKFUN. The output shown assumes that the program has been run before and that two person objects have already been written to the file.

Enter person’s data:
Enter name: McKinley
Enter age: 22

Enter another person (y/n)? n Person: Name: Whitney Age: 20

Person: Name: Rainier Age: 21

Person: Name: McKinley Age: 22

Here one additional object is added to the file, and the entire contents, consisting of three objects, are then displayed.

The fstream Class

So far in this chapter the file objects we have created have been for either input or output. In DISKFUN we want to create a file that can be used for both input and output. This requires an object of the fstream class, which is derived from iostream, which is derived from both istream and ostream so it can handle both input and output.

The open() Function

In previous examples we created a file object and initialized it in the same statement:

ofstream outfile(“TEST.TXT”);

In DISKFUN we use a different approach: We create the file in one statement and open it in another, using the open() function, which is a member of the fstream class. This is a useful approach in situations where the open may fail. You can create a stream object once, and then try repeatedly to open it, without the overhead of creating a new stream object each time.

The Mode Bits

We’ve seen the mode bit ios::binary before. In the open() function we include several new mode bits. The mode bits, defined in ios, specify various aspects of how a stream object will be opened.

Mode bit for open function are.

in Open for reading (default for ifstream)
out Open for writing (default for ofstream)
ate Start reading or writing at end of file (AT End)
app Start writing at end of file (APPend)
trunc Truncate file to zero length if it exists (TRUNCate)
nocreate Error when opening if file does not already exist
noreplace Error when opening for output if file already exists, unless ate or app is set
binary Open file in binary (not text) mode

In DISKFUN we use ios::app because we want to preserve whatever was in the file before. That is, we can write to the file, terminate the program, and start up the program again, and whatever we write to the file will be added following the existing contents. We use ios:in and ios:out because we want to perform both input and output on the file, and we use ios:binary because we’re writing binary objects. The vertical bars between the flags cause the bits representing these flags to be logically combined into a single integer, so that several flags can apply simultaneously.

We write one person object at a time to the file, using the write() function. When we’ve finished writing, we want to read the entire file. Before doing this we must reset the file’s current position. We do this with the seekg() function, which we’ll examine in the next section. It ensures we’ll start reading at the beginning of the file. Then, in a while loop, we repeatedly read a person object from the file and display it on the screen. This continues until we’ve read all the person objects—a state that we discover using the eof() function, which returns the state of the ios::eofbit.

File Pointers

Each file object has associated with it two integer values called the get pointer and the put pointer. These are also called the current get position and the current put position, or—if it’s clear which one is meant—simply the current position. These values specify the byte number in the file where writing or reading will take place. (The term pointer in this context should not be confused with normal C++ pointers used as address variables.)

Often you want to start reading an existing file at the beginning and continue until the end. When writing, you may want to start at the beginning, deleting any existing contents, or at the end, in which case you can open the file with the ios::app mode specifier. These are the default actions, so no manipulation of the file pointers is necessary. However, there are times when you must take control of the file pointers yourself so that you can read from and write to an arbitrary location in the file. The seekg() and tellg() functions allow you to set and examine the get pointer, and the seekp() and tellp() functions perform these same actions on the put pointer.

Resources

PPT:

Chapter 14- File Processing C++ How to program by Dietle and Dietle
- 14.1 Introduction
- 14.2 The Data Hierarchy
- 14.3 Files and Streams
- 14.4 Creating a Sequential-Access File
- 14.5 Reading Data from a Sequential-Access File
- 14.6 Updating Sequential-Access Files
- 14.7 Random-Access Files
- 14.8 Creating a Random-Access File
- 14.9 Writing Data Randomly to a Random-Access File
- 14.10 Reading Data Sequentially from a Random-Access File
- 14.11 Example: A Transaction-Processing Program
- 14.12 Input/Output of Objects

Web Resources:

http://www.arachnoid.com/cpptutor/student3.html ---> Output Formatting]
http://www.cplusplus.com/doc/tutorial/files/ ---> Input/Output with files

I/O Stream Library:

http://www.cplusplus.com/reference/iostream/ios_base/ ---> ios_base
http://www.cplusplus.com/reference/iostream/ios/ ---> ios
http://www.cplusplus.com/reference/iostream/ ---> IO Stream Library
http://www.cplusplus.com/reference/iostream/fstream/ ---> fstream

Steps to solve the problem sets

Step 1: Read about Streams and Files given
Step 2: Try sample programs given (You can copy paste the programs and try your self)
Step 3: Go through the PPT on file processing.(you can copy paste the program and try your self)
Step 4: Go through the additional resources given.
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 atleast 2 - 3 Hours from Step 1 to Step 6.

Try the programs given in the PPT for Random access files.

Problem Sets

Problem Set A

1. Write a C program that uses a binary file cricket.binary. The binary file is having the information of Indian cricket player statistics.

The binary file is divided into 2 parts.

1st part(Header part) is the header, having information of number of records in the file.
2nd part(Data part) contains the data of the players.

A record in binary file is the information of one player.

The layout of the file is

Header Part is of 4 Bytes( Size of Integer) -- Number of records(N).
Data Part is of N * Size of Player Bytes -- N Records.

The structure of the player is

//Player Class
class Player{
Private:
    int id;       //#ID -- Unique ID given to each player and starts from 1.
    char name[50];//#Name -- Name of the Player
    int career;   //#Career -- Career Started year
    int matches;  //#Matches -- Number of Matches Played
    int runs;     //#Runs -- Total runs scored
    int highest;  //#Highest -- Highest score of the player
    int r50;      //#50's -- Number of half centuries of the player.
    int r100;     //#100's -- Number of Centuries of the player.
    float average;//#Average -- Average score of the player. (Total Runs/Number of Matches played)
Public:
//Declare the Implementation specific functions here and define them.
};

The Program should display the Menu with the following five choices

Print all player details
1. Display the details of all the players in a tabular format
Print Individual Player details
1. Display the Individual player details based on the ID enter by the user.
Update a Player Record for the Match.
1. User will enter the ID of the Player to be updated
2. IF Player is not found - print Player not found and redisplay the MENU
3. Display the Player details.
4. Ask for the runs scored for the recent match played by the Player.
5. Update the record of the entered player in the same file with the following details.
  1. Matches Played will be increment by one
  2. Runs - runs + runs scored
  3. highest - Check highest score with runs scored and update whichever is higher.
  4. r50 -- if runs scored is a half century then increment r50 by 1
  5. r100 -- if runs scored is a century then increment r100 by 1
  6. average -- Calculate the new average with the runs scored.
Add a new player
1. Generate a new ID for the player (ID will be the next highest ID of all the records)
2. Ask for all the details of the player from the user except ID.
3. Update the number of players in the file.
4. Append the new player details at the last of the file.
Quit

Use a loop for the Menu choice and perform the operation selected by the user. The program should quit only when the user selects quit option in the menu.

The program should open the binary file in Random Access Mode for reading and writing. Use seekg() to move the cursor position in the file.

You are not supposed to use Array of Players or Dynamic memory allocation.

You can use ID to seek in the file for the location of the record. (4Bytes+(ID*size of player)from start of file)

The data file should be passed as command line argument.

A sample program cricket_read.cpp is given.

Compile the cricket_read.cpp
Execute the program as $> cricket_read.exe in the directory where you saved the binary file.
1. Prints all the player details

Excveptiona Handling

2009-10-13T09:13:00.000-07:00

CPP09 - W1 - M10 - Exception Handling
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.

exceptions.jpg

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.

0.

// xsyntax.cpp

1.

// not a working program

2.

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

3.

class AClass //a class

4.

{

5.

public:

6.

class AnError //exception class

7.

{

8.

};

9.

10.

void Func() //a member function

11.

{

12.

if( /* error condition */ )

13.

throw AnError(); //throw exception

14.

}

15.

};

16.

17.

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

18.

19.

int main() //application

20.

{

21.

try //try block

22.

{

23.

AClass obj1; //interact with AClass objects

24.

obj1.Func(); //may cause error

25.

}

26.

catch(AClass::AnError) //exception handler

27.

{ //(catch block)

28.

//tell user about error, etc.

29.

}

30.

return 0;

31.

}

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.

0.

// xstak.cpp

1.

// demonstrates exceptions

2.

#include

3.

using namespace std;

4.

const int MAX = 3; //stack holds 3 integers

5.

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

6.

class Stack

7.

{

8.

private:

9.

int st[MAX]; //array of integers

10.

11.

int top; //index of top of stack

12.

public:

13.

class Range //exception class for Stack

14.

{ //note: empty class body

15.

};

16.

17.

Stack() //constructor

18.

{ top = -1; }

19.

20.

void push(int var)

21.

{

22.

if(top >= MAX-1) //if stack full,

23.

throw Range(); //throw exception

24.

st[++top] = var; //put number on stack

25.

}

26.

27.

int pop()

28.

{

29.

if(top <>

3.

using namespace std;

4.

const int MAX = 3; //stack holds 3 integers

5.

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

6.

class Stack

7.

{

8.

private:

9.

int st[MAX]; //stack: array of integers

10.

int top; //index of top of stack

11.

public:

12.

class Full { }; //exception class

13.

14.

class Empty { }; //exception class

15.

16.

//--------------------------------------------------------------

17.

Stack() //constructor

18.

{ top = -1; }

19.

//--------------------------------------------------------------

20.

void push(int var) //put number on stack

21.

{

22.

if(top >= MAX-1) //if stack full,

23.

throw Full(); //throw Full exception

24.

st[++top] = var;

25.

}

26.

27.

//--------------------------------------------------------------

28.

int pop() //take number off stack

29.

{

30.

if(top < 0) //if stack empty,
31. throw Empty(); //throw Empty exception
32. return st[top--];
33. }
34. };
35. ////////////////////////////////////////////////////////////////
36. int main()
37. {
38. Stack s1;
39. try
40. {
41. s1.push(11);
42. s1.push(22);
43. s1.push(33);
44. // s1.push(44); //oops: stack full
45. cout << “1: “ << s1.pop() << endl;
46. cout << “2: “ << s1.pop() << endl;
47. cout << “3: “ << s1.pop() << endl;
48. cout << “4: “ << s1.pop() << endl; //oops: stack empty
49. }
50. catch(Stack::Full)
51. {
52. cout << “Exception: Stack Full” << endl;
53. }
54. catch(Stack::Empty)
55. {
56. cout << “Exception: Stack Empty” << endl;
57. }
58. return 0;
59. }

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

Static Polymorphism

2009-10-13T08:20:00.000-07:00

CPP09 W1 M1: Static Polymorphism: Templates

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<class T> 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<class T> T Sum(T val1, T val2){

```
 return val1 + val2;
```
```
}
```
```
#endif
```
```
 
```
```
using namespace std;
```
```
int main(){
```
```
 cout<<Sum(3, 25)<<endl;//Integer
```
```
 cout<<Sum(3.456, 5.786)<<endl; //Float
```
```
 cout<<Sum('a', 'b')<<endl; //Char
```
```
//cout<
```
```
return 0;
```
```
}
```

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<class T, class U> T Sum(T val1, U val2){

```
  return val1 + val2;
```
```
 }
```
```
#endif
```
```
 
```
```
using namespace std;
```
```
int main(){
```
```
 cout<<Sum(3, 25)<<endl;
```
```
 cout<<Sum(3.456, 5.786)<<endl;
```
```
 cout<<Sum('a', 'b')<<endl;
```
```
 cout<<Sum(3, 3.5)<<endl;
```
```
 return 0;
```
```
}
```

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<class T, class U, class V> V Sum(T val1, U val2){

```
 return val1 + val2;
```
```
}
```
```
#endif
```
```
 
```
```
using namespace std;
```
```
int main(){
```
```
 cout<<Sum<int, int, int>(3, 25)<<endl;
```

 cout<<Sum<double, double, double>(3.456, 5.786)<<endl;

 cout<<Sum<char, char, char>('a', 'b')<<endl;

 cout<<Sum<double, int, double>(3.5, 3)<<endl;

```
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 T> class Foo{
```
```
public:
```
```
	Foo(T _val);
```
```
	virtual ~Foo();
```
```
	void setVal(T _val);
```
```
	T getVal();
```
```
private:
```
```
	T val;
```
```
};
```
```
 
```

template<class T> Foo<T>::Foo(T _val):val(_val){}

```
 
```
```
template<class T> Foo<T>::~Foo(){}
```
```
 
```

template<class T> void Foo<T>::setVal(T _val){

```
	val = _val;
```
```
}
```
```
 
```
```
template<class T> T Foo<T>::getVal(){
```
```
	return val;
```
```
}
```
```
 
```
```
#endif
```
```
 
```
```
using namespace std;
```
```
 
```
```
int main(){
```
```
	Foo<int> f1(1);
```
```
	Foo<char> f2('d');
```
```
	cout<<f1.getVal()<<endl;
```
```
	cout<<f2.getVal()<<endl;
```
```
	return 0;
```
```
}
```

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 T> class DynamicArray{
```
```
public:
```
```
	DynamicArray(int _size = 5);
```
```
	virtual ~DynamicArray();
```
```
	T& operator[](unsigned i);
```
```
	int getSize();
```
```
private:
```
```
	T* its_array;
```
```
	int size;
```
```
};
```
```
 
```

template<class T> DynamicArray<T>::DynamicArray(int _size):size(_size){

```
	its_array = new T[_size];
```
```
	for(int i=0; i<size; i++)
```
```
		its_array[i] = static_cast<T>(0);
```
```
}
```
```
 
```

template<class T> DynamicArray<T>::~DynamicArray(){

```
	delete[] its_array;
```
```
}
```
```
 
```

template<class T> T& DynamicArray<T>::operator[](unsigned i){

```
if(i >= (size)){
```
```
	int newsize = size+10;
```
```
	T* temp = new T[size];
```
```
	for(int j = 0; j<size; j++){
```
```
	temp[j] = its_array[j];
```
```
	}
```
```
	delete[] its_array;
```
```
	its_array = new T[newsize];
```
```
	for(int j = 0; j<size; j++){
```
```
		its_array[j] = temp[j];
```
```
	}
```
```
	for(int j=size; j<newsize; j++){
```
```
		its_array[j] = static_cast<T>(0);
```
```
	}
```
```
	delete[] temp;
```
```
	size = newsize;
```
```
	return its_array[i];
```
```
} 
```
```
else 
```
```
	return its_array[i];
```
```
}
```
```
 
```

template<class T> int DynamicArray<T>::getSize(){ return size;}

```
#endif
```
```
 
```
```
using namespace std;
```
```
 
```
```
int main(){
```
```
	DynamicArray<char> d1;
```
```
	DynamicArray<float> 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<d1.getSize(); i++){
```
```
		cout<<d1[i]<<" "<<d2[i]<<endl;
```
```
	}
```
```
return 0;
```
```
}
```

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.

Resources

/ Fig.�11.2: tstack1.h

// Stack class template.

#ifndef TSTACK1_H

#define TSTACK1_H



template<>

class Stack {     



public:

Stack( int = 10 );  // default constructor (stack size 10)



// destructor

~Stack()

{

delete [] stackPtr;



} // end ~Stack destructor



bool push( const T& );  // push an element onto the stack

bool pop( T& );         // pop an element off the stack

// determine whether Stack is empty

bool isEmpty() const

{

return top == -1;



} // end function isEmpty



// determine whether Stack is full

bool isFull() const

{

return top == size - 1;



} // end function isFull



private:

int size;     // # of elements in the stack

int top;      // location of the top element

T *stackPtr;  // pointer to the stack



}; // end class Stack



// constructor

template<>      

Stack<>::Stack( int s )

{

size = s > 0 ? s : 10; 

top = -1;  // Stack initially empty

stackPtr = new T[ size ]; // allocate memory for elements



} // end Stack constructor



// push element onto stack;

// if successful, return true; otherwise, return false

template<>                       

bool Stack<>::push( const T &pushValue )

{

if ( !isFull() ) {

stackPtr[ ++top ] = pushValue;  // place item on Stack

return true;  // push successful



} // end if



return false;  // push unsuccessful



} // end function push



// pop element off stack;

// if successful, return true; otherwise, return false

template<>               

bool Stack<>::pop( T &popValue )

{

if ( !isEmpty() ) {

popValue = stackPtr[ top-- ];  // remove item from Stack

return true;  // pop successful



} // end if



return false;  // pop unsuccessful



} // end function pop





// Fig.�11.3: fig11_03.cpp

// Stack-class-template test program.

#include 



using std::cout;

using std::cin;

using std::endl;



#include "tstack1.h"  // Stack class template definition



int main()

{

Stack<> doubleStack( 5 );

double doubleValue = 1.1;



cout << "Pushing elements onto doubleStack\n";



while ( doubleStack.push( doubleValue ) ) {

cout << doubleValue << ' ';

doubleValue += 1.1;



} // end while



cout << "\nStack is full. Cannot push " << doubleValue

<< "\n\nPopping elements from doubleStack\n";

while ( doubleStack.pop( doubleValue ) )

cout << doubleValue << ' ';



cout << "\nStack is empty. Cannot pop\n";



Stack<> intStack;

int intValue = 1;

cout << "\nPushing elements onto intStack\n";



while ( intStack.push( intValue ) ) {

cout << intValue << ' ';

++intValue;



} // end while



cout << "\nStack is full. Cannot push " << intValue

<< "\n\nPopping elements from intStack\n";



while ( intStack.pop( intValue ) ) 

cout << intValue << ' ';



cout << "\nStack is empty. Cannot pop\n";



return 0;

} // end main





#endif







2.http://www.functionx.com/cpp/Lesson07.htm

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.

Friend Functions

2009-10-12T09:04:00.000-07:00

CPP09 - W1 - M8: Friend Functions

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.

The accessibility of class members in various forms is shown in the below figure

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

http://xoax.net/comp/cpp/console/Lesson9.php

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

2009-10-01T08:29:00.000-07:00

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<int*>(flovar);
ptrflo = reinterpret_cast<float*>(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<Derv1 *>(ptr) !=0){
  pdv1 =  reinterpret_cast<Derv1 *>(ptr);
  pdv1->show();
}
ptr = &dv2; //put address of dv2 in pointer
if(reinterpret_cast<Derv2 *>(ptr) !=0){
  pdv2 =  reinterpret_cast<Derv2 *>(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; j<N; j++)
 cout << ptrarr[j]->getArea() << 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<Derv1 *>(ptr) !=0){
  pdv1 =  reinterpret_cast<Derv1 *>(ptr);
  pdv1->show();
}
ptr = &dv2; //put address of dv2 in pointer
if(dynamic_cast<Derv2 *>(ptr) !=0){
  pdv2 =  reinterpret_cast<Derv2 *>(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

PPT:

Object-Oriented Programming: Polymorphism -- 'How to C++ by Ditel and Associates'

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

2009-10-01T08:27:00.000-07:00

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

Resources

Multiple Inheritance

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

2009-10-01T08:14:00.000-07:00

Week 1 - M5 : Inheritance

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.

Resources

Walk Through Video (here)

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

Creation and Behavior of software Objects

2009-10-01T08:12:00.000-07:00

Learning Objectives

Objective is to better understand

Constructor
Destructor
Operator Overloading
Dynamic Memory Allocation

and also gain additional practice with classes

Resources

Problem Sets

Complete the following task with in 2 hours

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 << href="http://gethelp.devx.com/techtips/cpp_pro/10min/10min0400.asp" class="external free" title="http://gethelp.devx.com/techtips/cpp_pro/10min/10min0400.asp" rel="nofollow">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

Creation and Behavior of software Objects

2009-10-01T08:10:00.000-07:00

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.

Resources

Problem Sets

Complete following tasks In 2 hours

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"<<maxA<<"\n";
                   //Write the code here to set the max and min 
            }
            int draw(){
                int r;
                srand(time(0));  // Initialize random number generator.
                r = (rand() % (max - min)) + min;                
                return r;
            }
};

int main(void){
 //Write the code here to declare two Instances of Random class and by calling different constructors.

 //Use cout to call the draw function for each of the Random instance
}

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.

Name the program as: Time.cpp

Identifying Objects and Creating Software Objects

2009-10-01T08:03:00.000-07:00

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<<Hello<<endl;
              }
  }

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.

Basics

2009-09-22T11:02:00.000-07:00

Introduction to C++ and differences between C

Learning Objective

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

Resources

Problem Sets

Complete the following problem sets with in 2 hours

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!’

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.

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.

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

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

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 “Hai” for N times using a for-loop.

Resources:

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

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