Why Use a Disk?

If you've worked with computers very much, and if you've done some programming in other languages, you know the importance of file storagefor data. The typical computer system has much less memory storage than hard disk storage. Your disk drive holds much more data than can fit in your computer's RAM. The disk memory, because it is nonvolatile, lasts longer because the disk retains its contents when you power-off your computer. Also, when your data changes, you (or more important, your users) do not have to edit the program and look for a set of assignment statements. Instead, the users run previously writtenprograms that make changes to the disk data.

Types of Disk File Access

Your programs can access files two ways: through sequential access or random access. Your application determines the method you should choose. The access mode of a file determines how you read, write, change, and delete data from the file. Some of your files can be accessed in both ways, sequentially and randomly, as long as your programs are written properly and the data lends itself to both types of file access.

A sequential file must be accessed in the same order the file was written. This is analogous to cassette tapes: You play music in the same order it was recorded. (You can quickly fast-forward or rewind through songs that you do not want to listen to, but the order of the songs dictates what you do to play the song you want.) It is difficult, and sometimes impossible, to insert data in the middle of a sequential file. How easy is it to insert a new song in the middle of two other songs on a tape? The only way to truly add or delete records from the middle of a sequential file is to create a completely new file that combines both old and new songs.

It might seem that sequential files are limiting, but it turns out that many applications lend themselves to sequential file processing.

Unlike with sequential files, you can access random access files in any order you want. Think of data in a random access file as you would think of songs on a compact disc or a record; you can go directly to any song you want without having to play or fast-forward through the other songs. If you want to play the first song, the sixth song, and then the fourth song, you can do so. The order of play has nothing to do with the order in which the songs appear on the recording. Random file access sometimes takes more programming but rewards that effort with a more flexible file access method. You'll learn about both file storage methods in this chapter.

Learning Sequential File Concepts

There are three operations you can perform on sequential disk files. You can

• Create disk files
• Add to disk files
• Read from disk files

Your application determines what you need to do. If you are creating a disk file for the first time, you must create the file and write the initial data to it. Suppose that you wanted to create a customer data file. You would create a new file and write your current customers to that file. The customer data might originally be in arrays or arrays of structures, pointed to with pointers, or typed into regular variables by the user.

Over time, as your customer base grows, you can add new customers to the file. When you add to the end of a file, you append to that file. As your customers enter your store, you would read their information from the customer data file.

Customer disk processing brings up one disadvantage of sequential files, however. Suppose that a customer moves and wants you to change his or her address in your files. Sequential access files do not lend themselves well to changing data stored in them. It is also difficult to remove information from sequential files. Random files will provide a much easier approach to changing and removing data. The primary approach to changing or removing data from a sequential access file is to create a new one from the old one with the updated data.

Opening and Closing Sequential Files

Before you can create, write to, or read from a disk file, you must open the file. This is analogous to opening a file cabinet before working with a file stored in the cabinet. As soon as you are done with a cabinet's file, you close the file door. You must also close a disk filewhen you finish with it.

When you open a disk file, you must inform C only of the filename and what you want to do (write to, add to, or read from). C and youroperating system work together to make sure that the disk is ready, and they create an entry in your file directory (if you are creating a file) for the filename.

When you close a file, C writes any remaining data to the file, releases the file from the program, and updates the file directory to reflect the file's new size.

To open a file, you must call the fopen() function (for ''file open"). To close a file, call the fclose() function. Here is the format of these two function calls:

filePtr = fopen(fileName, access);

and

fclose(filePtr);

a definition in the stdio.h header file. The examples that follow show you how to define a file pointer.The filePtr is a special type of pointer that points only to files, not to data variables. You must define a file pointer with FILE

Your operating system handles the exact location of your data in the disk file. You do not want to worry about the exact track and sector number of your data on the disk. Therefore, you let the filePtr point to the data you are reading and writing. Your program only has to generically manage the filePtr while C and the operating system take care of locating the actual physical data.

The fileName is a string (or a character pointer that points to a string) containing a valid filename for your computer. If you are using a PC or a UNIX-based computer, the fileName can contain a complete disk and directory pathname. If you are using a mainframe, you must use the complete dataset name in the fileName string. Generally, you can specify the filename in uppercase or lowercase letters, as long as your operating system does not have a preference.

Sometimes you see programs that contain a t or a b in the access mode, such as ''rt" or "wb+". The t means text file and is the default mode; each of the access modes listed in Table 24.1 is equivalent to using t after the access mode letter ("rt" is identical to "r", and so on). A text file is an ASCII file, compatible with most other programming languages and applications. Text files do not always contain text, in the word processing sense of the word. Any data you need to store can go in a text file. Programs that read ASCII files can read data you create as C text files. The b in the access mode means binary mode.

If you open a fil for writing (using access modes of "w", "wt", "wb", or "w+"), C creates the file. If a file by that name already exists, C overwrites the old file with no warning. When opening files, you must be careful that you do not overwrite existing data you want to save.

If an error occurs during the opening of a file, C does not return a valid file pointer. Instead, C returns a file pointer equal to the value NULL. NULL is defined in stdio.h. For example, if you open a file for output, but use a disk name that is invalid, C cannot open the file and will make the file pointer point to NULL. Always check the file pointer when writing disk file programs to ensure that the file opened properly.

Writing to a File

Any input or output function that requires a device performs input and output with files. You have seen most of these already. The most common file I/O functions are

getc() and putc()

fprintf()

fgets() and fputs()

There are a few more, but the most common I/O function left that you have not seen is the fscanf() function. fscanf() is to scanf() as fprintf() is to printf(). The only difference between fscanf() and scanf() is its first parameter. The first parameter to fscanf() must be a file pointer (or any C device, such as stdin and stdaux).

The following function reads three integers from a file pointed to by filePtr:

fscanf(filePtr, "%d %d %d", &num1, &num2, &num3);

As with scanf(), you do not have to specify the & before array variable names. The following fscanf() reads a string from the disk file:

fscanf(filePtr, "%s", name);

The fscanf() is not as potentially dangerous as the scanf() function. scanf() gets input from the user. The user does not always enter data in the format that scanf() expects. When you get data from a disk file, however, you can be more certain about the format because you probably wrote the program that created the file in the first place. Errors still can creep into a data file, and you might be wrong about the file's format when using fscanf(), but generally, fscanf() is more secure than scanf().

There is always more than one way to write data to a disk file. Most of the time, more than one function will work. For instance, if you write many names to a file, both fputs() and fprintf() will work. You also can write the names using putc(). You should use whichever function you are most comfortable with for the data being written. If you want a newline character (\n) at the end of each line in your file, the fprintf() and fputs() probably are easier than putc(), but all three will do the job.

Writing to a Printer

The fopen() and other output functions were not designed to just write to files. They were designed to write to any device, including files, the screen, and the printer. If you need to write data to a printer, you can treat the printer as if it were a file. The following program opens a FILE pointer using the MS-DOS name for a printer located at LPT1 (the MS-DOS name for the first parallel printer port):

Adding to a File

You can easily add data to an existing file or create new files by opening the file in append access mode. Data files on the disk rarely are static; they grow almost daily due to (with luck!) increased business. Being able to add to data already on the disk is very useful indeed.

Files you open for append access (using ''a", "at", "ab", "a+b", and "ab+") do not have to exist. If the file exists, C appends data to the end of the file when you write the data. If the file does not exist, C creates the file (as is done when you open a file for write access).

Reading from a File

As soon as the data is in a file, you must be able to read that data. You must open the file in a read access mode. There are several ways to read data. You can read character data a character at a time or a string at a time. The choice depends on the format of the data. If you stored numbers using fprintf(), you might want to use a mirror-image fscanf() to read the data.

Files you open for read access (using ''r", "rt", and "rb") must exist already, or C gives you an error. You cannot read a file that does not exist. fopen() returns NULL if the file does not exist when you open it for read access.

Another event happens when reading files. Eventually, you read all the data. Subsequent reading produces errors because there is no more data to read. C provides a solution to the end-of-file occurrence. If you attempt to read from a file that you have completely read the data from, C returns the value EOF, defined in stdio.h. To find the end-of-file condition, be sure to check for EOF when performing input from files.

Random File Records

Random files exemplify the power of data processing with C. Sequential file processing is slow unless you read the entire file into arrays and process them in memory. Random files provide you a way to read individual pieces of data from a file in any order needed and process them one at a time.

Generally, you read and write file records. A record to a file is analogous to a C structure. A record is a collection of one or more data values (called fields) that you read and write to disk. Generally, you store data in structures and write the structures to disk, where they are called records. When you read a record from disk, you generally read that record into a structure variable and process it with your program.

Unlike some other programming languages, not all C-read disk data has to be stored in record format. Typically, you write a stream of characters to a disk file and access that data either sequentially or randomly by reading it into variables and structures.

The process of randomly accessing data in a file is simple. Consider the data files of a large credit card organization. When you make a purchase, the store calls the credit card company to get an authorization. Millions of names are in the credit card company's files. There is no quick way the credit card company could read every record sequentially from the disk that comes before yours. Sequential files do not lend themselves to quick access. In many situations, looking up individual records in a data file with sequential access is not feasible.

The credit card companies must use a random file access so that their computers can go directly to your record, just as you go directly to a song on a compact disc or a record album. The functions you use are different from the sequential functions, but the power that results from learning the added functions is worth the effort.

Introduction

In this article we will discuss one of the most useful linear data structure – Stack as well as its implementation in C language and C++ languages. Firstly we will implement the algorithms used in stacks in C language and then we will study stacks in C++ using templates. We will also discuss why stacks play an important role in computer science.

Definition and Examples

A stack is a collection of elements in which all insertions and deletions are made at one end, called the top of the stack. It means that new elements are inserted at the ‘top’ of stack and elements are also deleted from the ‘top’ of the stack. Therefore it is the ‘top’ of stack that changes whenever an element is inserted or deleted. A stack of trays or of plates is a simple example of stack, as shown in figure-1.

Figure 1

When we use the word ‘stack’ in a programming context then one should remember that the elements of a stack should be of similar data types and these elements can be of either built-in data types or user-defined data types. Figure-2 is a motion picture of a stack as it expands and shrinks with the passage of time. If a stack has five elements, say A, B, C, D and E, then it is represented as shown in figure-2(a). From this figure it is clear that the element ‘E’ is at the topmost position of stack and ‘A’ is at the bottom most position.Now if we want to insert a new element ‘F’ then after the insertion, the element ‘F’ will be the top element of the stack as shown in figure-2(b).

Again if we want to insert another element then it will be placed on the top of ‘F’. Figure-2(c) represents insertion of two new elements ‘G’ and ‘H’ respectively. Now if we want to delete any element from the stack then ‘H’ will be the first element to be deleted. Figure-2(d) shows the deletion of a element from the stack. From the pictorial representation of figure-2, it is clear that the last element to be inserted into a stack is the first element to be deleted. That’s why the stack is also called as Last-In First-Out (LIFO) data structure.

Figure 2

Operations on Stacks

Generally we perform two basic operations onto a stack – push and pop. When we insert a new element to a stack, it is called as pushed onto the stack and when we delete an element, it is called as popped from the stack. Because of this operation, a stack is also called as Push-down lists. For example, if ‘S’ represent a stack and ‘item’ represents an element to be pushed then the push operation is written as:

Push(S, item); 

Similarly when we pop an element from a stack, it is represented as:

item = Pop(S) 

where ‘S’ represents a stack. For example, if ‘S’ is the stack of figure-2(a) we perform the following operations from 2(b) to 2(d).

Push(S, ‘F’);
Push(S, ‘G’);
Push(S, ‘H’);
Pop(S) 

However we can also perform some other operations on stacks as:

Intialize(S) – Initializes a stack S as an empty stack

StackTop(S) – returns the top element of stack S without removing it from the stack

IsStackFull(S) – checks whether  the stack is full or not. If the stack is full then returns 1; otherwise returns 0.

IsStackEmpty(S) - checks whether  the stack is empty or not. If the stack is empty then returns 1; otherwise returns 0.

The StackTop(S) function returns the top element of stack, only when the stack is not empty. If the stack is empty then it is not possible to return the top element. Similarly a Pop(S) function is possible only when the stack is not empty. Actually the StackTop() is not a new operation since it can be decomposed into a Pop() and Push(). Thus

item = StackTop(S); 

is decomposed into following two operations:

item = Pop(S);
 Push(S, item); 

Therefore before performing these two operations, we must ensure that the stack is not empty by invoking IsStackEmpty() function. Likewise a new element is inserted only when the stack is not full and it is ensured by invoking IsStackFull() function.

Therefore when we build a stack then it is necessary to implement these six operations.

Implementation of Stacks in C

In this section we will study how to represent a stack in a programming language ‘C’. However there are several ways to represent a stack in ‘C’. We can use either an array or a linked list while implementing a stack. Firstly we will see array implementation of stacks.

Array Implementation of Stacks

A stack is an ordered collection of elements. We know that an array contains an ordered collection of elements. Therefore a stack may be represented as a linear array in the computer memory that will store the elements in the stack. Therefore whenever we use array implementation of stack, we attempt to begin a program by declaring a variable ‘Stack’ as an array. We will also use a counter variable ‘top’ to indicate the current top element’s position within array. One end of the array is fixed, say bottom of the stack, while the value of ‘top’ constantly changes as elements are pushed and popped. In this type of implementation, we will also use another simple variable ‘Size’ to indicate the maximum number of elements that can be held by the stack.

A stack in ‘C’ is represented as

#define Size 50
int top;
datatype Stack[Size]; 

Here we have used ‘Stack’ as an array name. However a stack and an array ‘Stack’ are two entirely different things. In general, one can not change the number of elements in an array because it is fixed and assigned by the declaration for the array. On the other hand, a stack is fundamentally a dynamic object whose size is constantly changing as items are pushed and popped. So we declare an array as there is enough space for the maximum size of the stack because the stack may grow and shrink within the space reserved for it.

In the above declaration, ‘Size’ is a constant giving the maximum number of elements allowed for stack, such that the stack will at no time contains more than Size elements (50 elements). In this example, the stack can contain 50 elements (from stack[0] to Stack[49]). The datatype is the type describing the data that will be put into the stack and ‘top’ is an integer variable to indicate the location of the top element of the stack. If the value of top is equal to –1 then it means that the stack is empty; otherwise not. Similarly if the value of top is equal to (Size-1), that is 49, then it means that the stack is full; otherwise not.

Here is the declaration for a stack of 50 integers:

#define Size 50
int top;
int Stack[Size]; 

There is, of course, no reason to restrict a stack to contain only integers, we can also declare as:

float Stack[Size];
char Stack[Size]; 

We can even construct a stack of user-defined data types, such as struct, as:

#define Size 50
int top;
struct Employee
{ 
 char name[25];
int age;
float salary;
};
struct Employee Stack[Size]; 

In fact, should the need arise, a stack can contain objects of different types by using ‘C’ unions. But for the sake of simplicity we will consider a stack of integers only. Figure-3 shows an array implementation of such stack.

Figure 3

Here the value of ‘top’ is 5. It means that there are six elements in the stack. It is because in ‘C’ and C++ array numbering starts from 0 and since Size is equal to 50 therefore we can push forty four more elements in the stack.

Now let us see some routines that are to be performed on stacks.

Initializing an Empty Stack

The Initialize() function is used to initialize a stack to empty before it is first used in a program. A stack is initialized by assigning value –1 to ‘top’ variable.

Here is the function that implements this task.

Initialize()
{
 top=-1;
}

Is Stack Full or Not

When we insert an element onto the stack, then firstly we check whether the stack is full or not. If the stack is not full then the new element is inserted successfully; otherwise an error message is reported. Therefore while implementing this task we must check the value of ‘top’. If the value of ‘top’ is equal to (Size-1) then it means that the stack is full; otherwise not.

Here is the function that implements this task.

IsStackFull()
{
 if (top==Size-1)
 return 1;
 else
 return 0;
}

Is Stack Empty or Not

This condition is tested whenever we attempt to perform a pop operation. An element is removed from the stack only when the stack is not empty. Here again while implementing this task we must check the value of ‘top’. If the value of ‘top’ is equal to -1 then it means that the stack is empty;  otherwise not.

Here is the function that implements this task.

IsStackEmpty()
{
 if (top==-1)
 return 1;
 else
 return 0;
}

Now the question arises – what is the need to define the function IsStackEmpty() when we could just as easily write if (top == -1) each time we want to test for the empty condition? There is no complicated reason behind this. Of course one can write if (top == -1) each time, but a good programmer wishes to make his/her program more comprehensible as well as concern with the readability of his/her code. It will definitely save a large amount of time in debugging the program because large-and-medium sized program will almost never be correct the first time they are run. Therefore if you want to be a mature programmer then concern with the proper balance of code economy and code clarity.

Pop Operation

When we implement Pop() operation we should consider the situation where we try to perform the pop operation on an empty stack. If our stack is empty and we perform pop operation then it should display just an error message that “Stack is Underflow” and the control is returned back. However if the stack is not empty then the top element of the stack is stored in a temporary local variable and the value of the ‘top’ is decremented. Finally this retrieved value is returned back.

Here is the algorithm that pops an element from the non-empty stack.

Algorithm : Pop

Pop(Stack)

Here ‘Stack’ contains the base address of the array ‘Stack’.

• Step-1 : Check whether Stack is empty or not. If Stack is empty then flash an error message – Stack underflow and go to step-4 otherwise go to step-2
• Step-2 : Access the top element of the stack as: Item = Stack[top]
• Step-3 : Decrement the value of top as top = top-1
• Step-4 : Exit

Here is the ‘C’ implementation of this algorithm.

Implementation : Pop

Pop(int Stack[])
{
 int item;
 if (IsStackEmpty())
 {
 printf("\nStack Underflow. ");
exit(0);
 }
 item=Stack[top];
 top--;
 return (item);
}

item = Pop(Stack); 

if (!IsStackEmpty())
 item = Pop(Stack);
else
/* Take some remedial action because stack is empty */

PopAndTest(int Stack[], int *item, int *flag)
{
 if (IsStackEmpty())
 {
 *flag = 1;
 return;
 }
 *flag = 0;
 *item = Stack[top];
 top --;
}

PopAndTest(Stack, &item, &flag);
if (flag == 1)
{
 /* Take some remedial action because stack was empty */
}
else
 /* Use value of item */
….

• Step-1 : Check Stack is full or not.  If Stack is full then flash an error message – Stack  overflow and go to step-4;otherwise go to step-2
• Step-2 : Increment the value of top as top = top+1
• Step-3 : Store the value of ‘item’ at top position a Stack[top] = item
• Step-4 : Exit

Here is the ‘C’ implementation of this algorithm.
Implementation : Push

Push(int Stack[], int item)
{
 if (IsStackFull())
 {
 printf("\nStack Overflow");
 exit(0);
 }
 top++;
 Stack[top]=item;
}

PushAndTest(int Stack[], int item, int *flag)
{
 if (IsStackFull())
 {
 *flag = 1;
 return;
 }
 *flag = 0;
 top++;
 Stack[top]=item;
}

item=Pop(Stack);
 Push(Stack,item); 

• Step-1 : Check Stack is empty or not. If Stack is empty then flash an error message – Stack underflow and go to step-3; otherwise go to step-2
• Step-2 : Access the topmost value of the Stack as: Item = Stack[top] and return it.
• Step-3 : Exit

Here is the ‘C’ implementation of this algorithm.
Implementation : StackTop

StackTop(int Stack[])
{
 int item;
 if (IsStackEmpty())
 {
 printf("\nStack Underflow. ");
 exit(0);
 }
 item=Stack[top];
 return (item);
}

StackTopAndTest(int Stack[], int *item, int *flag)
{
 int item;
 if (IsStackEmpty())
 {
 *flag = 1;
 return;
 }
 *flag = 0;
 *item = Stack[top];
}

• Step-1 : Check Stack is empty or not. If Stack is empty then flash an error message – Stack underflow and go to step-6; otherwise go to step-2
• Step-2 : Initialize i=top
• Step-3 : Repeat through step-5 while (i>=0)
• Step-4 : Access the value stored at ith position as: tem = Stack[i]
• Step-5 : Decrement the value of ‘i’ as i=i-1
• Step-6 : Exit

Here is the ‘C’ implementation of this algorithm:

Implementation : Traverse

Traverse(int Stack[])
{
 int i;
 if (IsStackEmpty())
 {
 printf("\nStack Underflow. ");
 return;
 }
 for(i=top; i>=0; i--)
 printf("\n%d",Stack[i]);
}

struct StackNode
{
 int data;
 struct StackNode *link;
};
typedef struct StackNode StackNode;

and the ‘top’ pointer variable is declared as:

 StackNode *top; 

top = NULL; 

Figure 4

Initializing an Empty Stack

The InitializeStack() function is used to initialize a stack to empty before it is first used in a program. A stack is initialized by assigning a value NULL to ‘top’ pointer variable. Here is the function that implements this task.

InitializeStack(StackNode **top)
{
 (*top)=NULL;
}

Is Stack Full or Not

Since a linked stack is implemented by using a linked list which can expand and shrink according to the situation. So as far as the memory space is available there is no need to worry about the number of elements to be inserted. However if there is no enough memory space then it is not possible to insert a new element. In such case, the function should return a value 1; otherwise 0.

This task is implemented as:

IsStackFull(StackNode *t)
/* This function returns 1, if the linked stack is full; otherwise return 0 */
{
 if (t==NULL)
 return 1;
 else
 return 0;
}

Is Stack Empty or Not

The linked stack is said to be empty only when the value of ‘top’ variable contains a NULL value. If it contains a NULL value then it returns a value 1; otherwise a value 0 is returned. Here is the function that implements this task.

IsStackEmpty(StackNode *t)
/* This function returns 1, if the linked stack is empty; otherwise return 0 */
{
 if (t==NULL)
 return 1;
 else
 return 0;
}

Popping a Node

It is equally simple to pop a node from a linked stack. In popping the stack we will firstly check whether the stack is empty or not. If the stack is empty then it displays an error message and the control is returned back. If the stack is not empty then we store the value ‘top’ variable in a temporary pointer variable ‘temp’, update the value of top and free the memory space occupied by the pointer variable ‘temp’.

Here is the algorithm, which pops a node from a non-empty linked stack.

Algorithm : PopNode

PopNode(&top)

Here ‘top’ is address of topmost node of the linked stack. Parameter ‘top’ is passed by reference (pointer to pointer) to allow it to change during insertion into an empty linked stack.

• Step-1 : Check whether the stack is empty of not. If the stack is empty then flash an error messag “Stack is Underflow” and go to step-6; otherwise go to step-2
• Step-2 : Store value of topmost node in a temporary, Pointer variable ‘temp’ as temp = (*top);
• Step-3 : Access the data field of ‘temp’ node as item = temp->data
• Step-4 : Update the value of ‘top’ as (*top) = (*top)->link;
• Step-5 : Free the memory space occupied by the temp  node as freenode(temp);
• Step-6 : Exit

Here is the function that implements this task:

Implementation : PopNode

PopNode(StackNode **top)
{
 StackNode *temp;
 int item;
 if (IsStackEmpty(*top))
 {
 printf("\nStack Underflow");
exit(0);
 }
 temp=(*top);
 item=temp->data;
 (*top)=(*top)->link;
 freenode(temp);
 return (item);
}

PushNode(StackNode **top, int item)
{
 StackNode *temp;
 temp = getnode();
 temp->data=item;
 temp->link=(*top);
 (*top)=temp;
}

We can also access the top element of the linked stack without removing it from the stack. Here we will also consider the situation whether the stack is empty or not. If the stack is empty then we can not access the top element of it.

Here is the algorithm that implements this task.

Algorithm : StackTopNode
StackTopNodee(top)

Here ‘top’ is value of topmost node of the linked stack.

• Step-1 :     Check whether the stack is empty of not. If the stack is empty then flash an error messa ge “Stack is Underflow” and go to step-6;  otherwise go to step-2
• Step-2 : Store value of topmost node in a temporary. Pointer variable ‘temp’ as temp = (*top);
• Step-3 : Access the data field of ‘temp’ node as
• item = temp->data and return it.
• Step-4 : Exit

The ‘C’ implementation of this function is as:

Implementation : StackTopNode

StackTopNode(StackNode *top)
{
 int item;
 if (IsStackEmpty(top))
 {
 printf("\nStack Underflow");
exit(0);
 }
 item=top->data;
 return (item);
}

• Step-1 : Check whether the stack is empty of not. If the stack is empty then flash an error message “Stack is Underflow” and go to step-5;otherwise go to step-2
• Step-2 : Repeat through step-  while (top != NULL)
• Step-3 : Access the data field of ‘top’ node as
• item = top->data
• Step-4 : Update the value of ‘top’ as top = top->link;
• Step-5 : Exit

Here is the function that implements this task:

Implementation : Traverse

Here is the ‘C’ implementation of this algorithm:

Traverse(StackNode *top)
{
 if (IsStackEmpty(top))
 {
 printf("\nStack is empty. ");
 return;
 }
 while (top!=NULL)
 {
 printf("\n%d",top->data);
 top=top->link;
 }
}

• Step-1 : Store value of topmost node in a temporary
• pointer variable ‘current’ as current = (*top)
• Step-2 : Repeat through step-5  while (current != NULL)
• Step-3 : Update the value of ‘current’ as:
• current = current->link;
• Step-4 : Free the memory space occupied by the temp  node as freenode(*top);
• Step-5 : Set (*top) = current
• Step-6 : Exit

Here is the ‘C’ implementation of this algorithm:

Implementation : DisposeStack

DisposeStack(StackNode **top)
{
 StackNode *current;
 current = (*top);
 while (current != NULL)
 {
 current = current->link;
 freenode(*top);
 (*top) = current;
 }
}

Applications of Stacks

In this section we will study some applications of stacks.

Stack Frames for Subprograms/Functions

Stacks are more commonly used within the computer system when functions are called. When a function is called within another function then the system should remember the location from where the call was made, so that it can return thereafter the called function is completed. Here it is also needed to remember the parameters and local variables of the calling function so that their values will not be lost while its execution resumes.

Suppose that we have four functions first(), second(), third() and forth() and suppose that first calls second, second calls third and third calls forth. The execution of third will not have completed until forth has finished and return. Similarly the execution of second will not have completed until third has finished and return. In the same fashion, the execution of first will not have completed until second has finished and return. 

Similar process takes place when a program uses recursion. In recursion whenever a function call is made, it is necessary to save the current values of parameters, local variables, and the return address of each successive call.

Now let us see another practical application of stacks – evaluation of arithmetic expression.

Evaluation of Arithmetic Expressions

Let we have an arithmetic expression as:
A+B*C

here A, B and C are one letter operands and ‘+’ and ‘*’ are operators. You can also have any legal variable name or constant in a programming language. The value of these operands must be consistent with the operations performed on them. As far as the operators are concerned, the ‘C’ language provides five basic arithmetic operators: plus(+), minus (-), multiply (*), divide (/) and modulus (%). However some other languages may also have an exponential (**) operation.

In a simple expression, such as

A+B

there occurs no problem with understanding the meaning of operation. The problem comes when an expression an expression has two or more than two operators as:

A+B*C

here the system faces a problem in deciding the order of the execution of the operators. It means that either addition operation is performed first and then multiplication or multiplication operation is performed first and then addition. To overcome this problem, the compiler sets a priority level for each arithmetic operator as shown in table-1.

Operators    Priority
*              2
/              2
%             2
+             1
-               1

Therefore while evaluating the expression

A+B*C

The multiplication operation (B*C) is carried out first and then its result is added to A. Let we have an expression where two adjacent operators have the same priority, such as A/B*C then generally the operators are evaluated left to right, that is A/B is evaluated first and then its result is multiplied by C. But one should remember that parentheses can override these rules.

For example, in the expression (A+B)*C the expression A+B is evaluated first and then its result is multiplied with C. If we have nested parentheses as A*(B/(C+D)) then innermost parenthesized expression is evaluated first. But within parentheses, the same rule of precedence applies. It means that in following expression

A*(B+C/D)

The expression C/D is evaluated first, then addition is performed and finally the result is multiplied to A.

Generally when we write an expression, the operator is placed between its two operands (as we have seen so far). Such an expression is called as ‘infix’ expression and this notation is called as infix notation. Here are some examples of infix expressions:

A*B
A+B/C
(A+B)*(C-D)
A-B/(C*D) 

The infix expressions are evaluated according to standard operator-precedence rule. Now the question arises-how can a compiler produce correct code of this infix expression? Actually when a compiler encounters an infix expression, it firstly translates this infix expression into a ‘postfix’ expression. In postfix expression the operator follows its two operands. In other words you can say that in postfix notation the operator is placed after its two operands. The process of writing the operators of an expression either before their operands or after them is called ‘Polish’ notations in honor of its discoverer, the Polish mathematician Jan Luksiewicz.  When we convert an infix expression to a postfix expression we need to remember that highest precedence is converted first and then lower precedence.

Consider the following scenario in which a simple infix expression is converted into a postfix expression.

A+B*C            Infix expression
A+(BC*)        Converting the multiplication
A(BC*)+        Converting the addition
ABC*+            Postfix expression

Now let us see how to convert a bit complex ‘infix’ expression into a ‘postfix’ expression, such as:

A * B / C + D – E * F

Here firstly we will parenthesize this expression according to the operator priority precedence as:

( ( ( ( A * B ) / C ) + D ) – ( E * F ) )

Now we move all operators to their corresponding right parenthesize and in last we delete all parentheses.

Here the arrows head point to the right parenthesize of the corresponding operator. Therefore the resulting postfix expression is as….

A B * C / D + E F * -

Converting an Expression from Infix to Postfix

As stated earlier the expressions within innermost parenthesis must first be converted to postfix. So when we devise an algorithm we need to remember two things – firstly read the expression and parenthesize it correctly and secondly moves the operators to their right parentheses. Now let us see the function InfixToPostfix() that implements this task.

InfixToPostfix(char infix[], char postfix[])
{
 int in=0,out=0,length;
 char ch;
 length=strlen(infix);
 while (in < length)
 {
 if (infix[in]== ' ' || infix[in]=='\t')
 {
 in++;
 continue;
 }
 else if (IsOperand(infix[in]))
 {
 postfix[out]=infix[in];
 out++;
 in++;
 }
 else if (infix[in]=='(')
 {
 Push(Stack,infix[in]);
 in++;
 }
 else if (infix[in] == ')')
 {
 ch = pop(Stack);
 while (ch != '(')
 {
 postfix[out]=ch;
 out++;
 ch=Pop(Stack);
 }
 in++;
 }
 else if (IsOperator(infix[in]))
 {
 if (IsStackEmpty())
 Push(Stack,infix[in]);
 else
 {
 ch=StackTop(Stack);
 while ((top>-1)&&(GetPrec(ch)>=GetPrec(infix[in])))
 {
 postfix[out]=Pop(Stack);
 ch=StackTop(Stack);
 out++;
 }
 Push(Stack,infix[in]);
 }
 in++;
 }
 }
 while (!IsStackEmpty())
 {
 postfix[out] = Pop(Stack);
 out++;
 }
 postfix[out]='\0';
}

Here we have assumed that the stack holds character data items. In this function we have used three functions IsOpertor(), IsOperand() and getprec(). The IsOperator() is used to check whether the specified character is an operator or not. If not then it just displays an error message - Illegal Operator and the control is returned back; otherwise a value 1 is returned back.

Here is the function that implements this task.

IsOperator(char ch)
{
 switch (ch)
 {
 case '*':
 case '+':
 case '-':
 case '/':
 case '%':
 return 1;
 default :
 printf("\nIllegal Operator. ");
 exit(0);
 }}

The IsOperand() is used to check whether the specified character is an operand or not. If not then it returns 0; otherwise a value 1 is returned back. Here is the function that implements this task.

IsOperand(char ch)
{
 if (isdigit(ch) || isalpha(ch))
 return 1;
 else
 return 0;
}

The GetPrec() operator is used to return the precedence of the given character if it is an operator, otherwise it displays an error message - Illegal Operator. This function returns the value ‘2’ for multiplicative operators, ‘1’ for additive operators and –10 for left parentheses. 

Here is the function that implements this task.

GetPrec (char op)
{
 switch (op)
 {
 case '*':
 case '/':
 case '%':
 return (2);
 case '+':
 case '-':
 return (1);
 case '(':
 return (-10);
 default :
 printf("\nIllegal Operator. ");
 exit(0);
 }
}

Now let us see the behavior of this InfixToPostfix() function by considering the following expression

Thus the compiler firstly converts the infix expression into postfix expression and then during execution, the system evaluates this postfix expression by using a stack. Now let us see-how stack helps in evaluating a postfix expression.

Evaluating a Postfix Expression

When a postfix expression is evaluated then we must remember following main things-

• when an operand is encountered it is pushed onto stack.
• when an operator is encountered its operands will be the top two elements on the stack, thus two topmost operands are popped and the specified operator is used with these two popped operands and the result is pushed back onto the stack.

Let we have a postfix expression

A B C * +

Here the first character is an operand, so we push A, then B and in last C as:

The next symbol is a operator (*) , therefore we pop B and C and perform the multiplication operator (*) as:

T1 = B * C

And push T1 on stack as:

Next symbol is +, so again we pop A and T1 and perform the addition operation as:

T2 = A + T1

And push T2 on stack as:

Since there is no other symbol left, so T2 will contain the result.

Now let us implement this task of evaluating the value of an arithmetic postfix expression.

Evaluate(char postfix[])
{
 int post=0,length,value,num;
 int t1,t2;
 char ch;
 length=strlen(postfix);
 while (post < length)
 {
 if (postfix[post]== ' ' || postfix[post]=='\t')
 {
 post++;
 continue;
 }
 else if (isdigit(postfix[post]))
 {
 num=(int) (postfix[post]-'0');
 Push(Stack,num);
 }
 else
 {
 t2=Pop(Stack);
 t1=Pop(Stack);
 switch (postfix[post])
 {
 case '+': value = t1+t2;
 break;
 case '-': value = t1-t2;
 break;
 case '*': value = t1*t2;
 break;
 case '/': value = t1/t2;
 break;
 case '%': value = t1%t2;
 break;
 default :
 printf("\nIllegal operator.");
 exit(0);
 }
 Push(Stack,value);
 }
 post++;
 }
 value=Pop(Stack);
 return value;
}

Here the arrows head point to the left parenthesize of the corresponding operator. Therefore the resulting prefix expression is as….

- + / * A B C  D * E F 

One should remember that the prefix form of a complex expression is not mirror image of a postfix expression. However as far as simple infix expression, such as A+B, A/B etc., it may be true, but not always.

Multiple Stacks

As stated earlier an array implementation of a stack suffers from a serious limitation of its static size. If the size is less then the stack full message announces much frequently. However if the size is large then it may result in wastage of memory space, if we use only a few number of memory locations. Some times we need to have several stacks in a programming environment. Therefore arrays may result in a lot of memory wastage.

To overcome this limitation to some extent we divide the same area space in several stacks as shown in figure-5. Figure-5(a) divides the same memory space into two arrays and figure-5(b) divides into five stacks.

Figure 5

Figure-5(a) represents two stacks of size 25 each and figure-5(b) represents five stacks of size 10 each. Here it is assumed that each stack occupies the same amount memory space. However you can also have different sizes of stacks. If you have different sizes of several stacks then there will be no efficient way to represent them sequentially (in array). Therefore in such cases we will use linked stacks.

A stack node for a linked stack is defined as:

struct StackNode
{
 int data;
 struct StackNode *link;
};
typedef struct StackNode StackNode; 

Now if we want to represent ‘n’ number of stacks then we declare an array of pointers as:

StackNode *top[n]; 

here top[i] contains the address of the topmost node of ith stack, such that  n > i ≥ 0. The process of initializing an ith stack is as:

top[i] = NULL; 

Now let us discuss two basic operation on multiple stacks.

Pushing a Node in Multiple Stacks

When we push (insert) a new node then we need to mention the stack number, say ith stack and ‘item’ of information.

Here is the algorithm, which pushed a mode in multiple stacks.

Algorithm : PushNodes

PushNodes(i, item)

Here ‘item’ is pushed into the ‘i’th stack.

• Step-1 : Create a new node ‘temp’
• Step-2 : Set the data field of ‘temp node to item as
• temp->data = item
• Step-3 : Store the value of ‘top’ variable in the link field of new node as temp->link = top[i]
• Step-4 : Update the value of ‘top[i]’
• Step-5 : Exit

Here is the ‘C’ implementation of this algorithm.

Implementation : PushNodes

PushNodes(int i, int item)
{
 StackNode *temp;
 temp = getnode();
 temp->data = item;
 temp->link = top[i];
 top[i] = temp;
}

• Step-1 :  Check whether the stack is empty of not. If the stack is empty then flash an error message “Stack is Underflow” and go to step-6; otherwise go to step-2
• Step-2 : Store value of topmost node of ‘i’th stack in a  temporary pointer variable ‘temp’ as temp = top[i]
• Step-3 : Access the data field of ‘temp’ node as item = temp->data
• Step-4 : Update the value of top[i]as top[i]=top[i]->link
• Step-5 : Free the memory space occupied by the temp  node as freenode(temp);
• Step-6 : Exit

Here is the ‘C’ implementation of this algorithm.

Implementation : PopNodes

PopNodes(int i)
{
 StackNode *temp;
 int item;
 if (IsStackEmpty(top[i]))
 {
 printf("\nStack Underflow");
exit(0);
 }
 temp = top[i];
 item=temp->data;
 top[i] = top[i]->link;
 freenode(temp);
 return (item);
}

class Stack
{
 private :
 // data members

 public :
 // member functions
};

int st[Size];
int top; 

#define Size 10

IsStackFull()
IsStackEmpty()
Push(int)
int Pop()
void Pop(int &, int &)
void StackTop(int &, int &)

class Stack
{
 private :
 int st[Size];
int top;
 public :
 Stack();
int IsStackFull();
int IsStackEmpty();
void Push(int);
int Pop();
void Pop(int &, int &)
void StackTop(int &, int &);
};

Stack :: Stack()
{
 top=-1;
}

int Stack :: IsStackFull()
{
 if (top==Size-1)
 return 1;
 else
 return 0;
}

int Stack :: IsStackEmpty()
{
 if (top==-1)
 return 1;
 else
 return 0;
}

void Stack :: Push(int item)
{
 if (IsStackFull())
 {
 cout << "\nStack Overflow";
exit(0);
 }
 top++;
 st[top]=item;
}

int Stack :: Pop()
{
 int item;
 if (IsStackEmpty())
 {
 cout << "\nStack Underflow. ";
exit(0);
 }
 item=st[top];
 top--;
 return (item);
}

void Stack :: Pop(int &item, int &flag)
{

 if (IsStackEmpty())
 {
 flag=1;
return;
 }
 flag=0;
 item=st[top];
 top--;
}

void Stack :: StackTop(int &item, int &flag)
{
 if (IsStackEmpty())
 {
 flag=1;
 return;
 }
 flag=0;
 item=st[top];
}

struct StackNode
{
 int data;
 StackNode *link;
};

class LinkedStack
{
 private :
 StackNode *top;
 public :
 LinkedStack();
int IsStackFull(StackNode *)
int IsStackEmpty()
 void PushNode(int);
 int PopNode();
 void PopNode(int &, int &);
 void StackTopNode(int &, int &);
 void display();
 ~LinkedStack();
};

LinkedStack :: LinkedStack()
{
 top=NULL;
}

LinkedStack :: ~LinkedStack()
{
 SatckNode *current;
 while (top != NULL)
 {
 current = top->link;
 delete top;
 top = current;
 }
}

int LinkedStack :: IsStackFull(StackNode *t)
{
 if (t==NULL)
 return 1;
 else
 return 0;
}

int LinkedStack :: IsStackEmpty() 
{
 if (top == NULL)
 return 1;
 else
 return 0;
}

void LinkedStack :: PushNode(int item)
{
 StackNode *temp;
 temp = new StackNode; 
 temp->data = item;
 temp->link = top;
 top = temp;
}

int LinkedStack :: PopNode()
{
 StackNode *temp
 if (IsStackEmpty())
 {
 cout << "\nStack Underflow";
exit(0);
 }

 int item=top->data;
 temp = top;
 top = top->link;
 delete temp;
 return item;
}

void LinkedStack :: PopNode(int &item, int &flag)
{
 StackNode *temp
 if (IsStackEmpty())
 {
 cout << "\nStack Underflow";
flag=1;
return;
 }
 flag=0;
 item=top->data;
 temp = top;
 top = top->link;
 delete temp;
}

void LinkedStack :: StackTopNode(int &item, int &flag)
{
 if (IsStackEmpty()) 
 {
flag=1;
return;
 }
 flag=0;
 item=top->data;
}

template 

template 
class Stack
{
 private :
 T St[Size];
 int top;
 public :
Stack();
 int IsStackFull();
 int IsStackEmpty();
 void Push(T item);
 T Pop();
 void Pop(T &, int &);
void StackTop(T &, int &);
};

template  Stack  :: Stack()
{
 top=-1;
}
template  int Stack :: IsStackFull()
{
 if (top==Size-1)
 return 1;
 else
 return 0;
}
template  int Stack ::IsStackEmpty()
{
 if (top==-1)
 return 1;
 else
 return 0;
}
template  void Stack :: Push(T item)
{
 if (IsStackFull())
 {
 cout << "\nStack Overflow. ";
 exit(0);
 }
 top++;
 St[top]=item;
}
template  T Stack :: Pop()
{
 T item;
 if (IsStackEmpty())
 {
 cout << "\nStack Underflow. ";
 exit(0);
 }
 item = St[top];
 top--;
 return item;
}
template  void Stack :: Pop(T &item, int &flag)
{
 if (IsStackEmpty())
 {
flag=1;
 return;
 }
 flag=0;
 item = St[top];
 top--;
}
template  void Stack :: StackTop(T &item, int &flag)
{
 if (IsStackEmpty())
 {
flag=1;
return;
 }
 flag = 0;
 item = St[top];
}

Stack  IStk;
Stack  CStk; 

Constructor and Destructor is very important basic concepts of C++. Whenever we create an object, there are two special types of functions that would be created automatically if we have not written them in the program. They are known as Constructor and Destructor.

Now Let us get the basic concepts of constructor and destructor.

Constructor:-

As its name is indicating, Constructor means "which constructs something" . We will see what it is going to construct..

Definition:-

Constructor is a special member function with the same name as its class.

Syntax :-

1. class_name(){ definition }

2. class_name(argument1, argument2,...){ definition }

We are going to write a constructor example to understand concept better.

Example:

class Person

{

int age;

int weight;

int height;

public:

Person() // constructor for class Person - same name as class , no return type

{

age = 20;

weight = 60;

height = 160;

}

void showData(); //other function

void enterData(); //other function

};

Can you guess what constructor is doing in above program? If your answer is initialization. then you are absolutely correct. The main responsibility of constructor is to initialize the data members of the class.

But above constructor is having one restriction, it will initialize same values to all the objects. It is not what we want.We should be able to provide different data values to every person. Every person has different body setup.

So we need to provide different values. How to do it? It is very simple. Add one more constructor. Having more than one constructor is called constructor overloading.
Hence this is also an example of constructor overloading.

class Person

{

int age;

int weight;

int height;

public:

Person() // constructor for class Person - same name as class , no return type

{

age = 20;

weight = 60;

height = 160;

}

Person(int a,int w,int h) // added new constructor can accept different values

{

age = a;

weight = w;

height = h;

}

void showData(); //other function

void enterData(); //other function

};

NOTE :- You can write Constructor definition outside the Class as you do normally with other function.

Example:

class Person

{

int age;

int weight;

int height;

public:

Person(); // constructor for class Person - same name as class , no return type

void showData(); //other function

void enterData(); //other function

};

Person::Person() //  outside of the class

{

age = 20;

weight = 60;

height = 160;

}

Use:-

Constructors are used to create, and can initialize, objects of their class type.

Call:-

When an object of a class is created, constructor for that class is called.If there is no constructor defined, DEFAULT constructor is invoked. But default constructor doesn't initialize any variable.

Some facts about Constructors :

* Constructors are special member functions with the same name as the class.

* Constructors can not return any value (nothing even void) .

* Constructors are intended to initialize the members of the class when an instance   of that class is created.

* Constructors are not called directly.

* Constructors can not be virtual.

* Constructors can not be static.

* Constructors can not be const.

* Constructors can not be volatile.

* Constructors aren't automatically inherited between base and derived classes.

* There can be any number of constructors in a same class.

* They must have different parameters to distinguish them. (=> Constructors can be overloaded )

Destructors :-

Destructors are opposite of Constructors.They are called when objects are destructed. They can be used to release memory occupied by the objects.

Definition :

Destructors in C++ also have the same name, but they are preceded by a '~' operator.For example destructor for Person class will be declared as ~Person().

Syntax:
~class_name(){}

Example :

class Person {

public:

// Constructor for class Person

Person();

// Destructor for class Person

~Person();

};

Use :-

Destructors are usually used to release memory and do other cleanup for a class object and its class members when the object is destroyed.

Call:-

The destructors are called when the object of a class goes out of scope or is explicitly deleted.

Some facts about Destructors:

* If the constructor/destructor is declared as private, then the class cannot be instantiated.

* It is not necessary to declare a constructor or a destructor inside a class. If not declared, the compiler will automatically create a default one for each.

* A destructor takes no arguments and has no return type.

* Its address cannot be taken.

* Destructors cannot be declared const.

* Destructors cannot be declared volatile.

* A destructor can be declared virtual or pure virtual.

* We don't have to call destructor explicitly, it is called automatically.

* Only one destructor can be there for each object.

I hope you have understood basic concepts of Constructors and Destructors in C++. Please don't forget to send your valuable feedback.

Control Structures

Normally the statements in a program, are executed sequentially one by one. This is known as the normal flow of control. One of the keys to designing intelligent programs is to make them able to make decisions, such as whether you are going to see a movie or not, whether to play a cricket match or not, whether you want to go on a long journey, and if so by the train or by the air.

Like these activities programs also need to decide among alternative actions, such as whether the year is a leap or not, whether the number is even or odd, and so on. Thus there is the possibility of changing the sequence of statements, based on these decisions.

Decisions can be made in C++ in several ways. C++ provides the if statement and the switch statement for implementing these decisions. The former one is generally used to choose between two alternatives, whereas the later one for multiple alternatives. In this article we will discuss these two decision making statements, along with logical and relational operators, and in last we will see the conditional operator which provides another way to make a choice.

The if statement

The if statement is used in a program where you need to perform a particular action on some condition. If the result of this condition is true then perform the action; otherwise either perform some other action or not. The if statement comes in two flavors:

the if statement
the if–else statement

The if statement is the simplest form of the decision statements. The if statement causes a program to execute a statement or a set of statements when a test-condition results in true, and to skip that statement or set of statements when the condition is false.

The C++ uses the keyword if to implement the decision control statement. The general form of the if statement is:

 if (test-condition)
 statement;

Figure 1

Here the first number, which is on the left-hand side of the relational operator, is compared with the number, which is on the right hand side. Note that the relational operators have a lower precedence than the arithmetic operators. Thus the following expression   

x – 6 > y + 2

corresponds to

(x - 6) > (y + 2)

and not the following

x – (6 > y) + 2

Therefore if x = 10 and y = 6 then the result of the relational expressions are as:

Relational expression        Result
x – 6 > y +2                       0
x – 6 < y +2                       1
x – 6 == y +2                     0
x – 6 != y +2                      1
x – 6 >= y +2                     0
x – 6 <= y +2                     1

Here is a simple program which illustrates the use of the if statement and the relational operators.

// Program-con1.cpp
#include 
void main()
{
 int num;
 cout << “\nEnter a number : ”;
 cin >> num;
 
 if (num >= 0)
 cout << “You have entered a positive number.”;
}

// Program-con2.cpp 
#include 
void main()
{
 int qty;
 float tprice, price, discount;
 discount = 0.0;
 cout << “\nEnter number of shirts : ”;
 cin >> qty;
 cout << “Enter price per shirt : ”;
 cin >> price;
 if (qty > 5)
 discount = 0.2;
 tprice = qty * price * (1-discount);
 cout << “Total price : ” << tprice;
}

if (test-condition)
 {
 statement1;
 statement2;
 statement3;
 statement4;
 }

// Program-con3.cpp
#include 
void main()
{
 int age;
 cout << “\nEnter your age : ”;
 cin >> age;

 if (age >= 20)
 {
 cout << “You have grown up.”;
 cout << “\nNow you can take a pepsi.”;
 }
}

if (test-condition)
 statement1;
 else
 statement2;

if (test-condition)
 {
 statement1;
 statement2;
 statement3;
 statement4;
 }
 else
 {
 statement5;
 statement6;
 statement7;
 statement8;
 }

Figure 2

Here if test-condition is true, the program executes statement1, statement2, statement3, and statement4 and skips over else body statements. If the test-condition is false, the program executes statement5, statement6, statement7, and statement8 and skips if body statements. Figure 2(b) shows the behavior of the if–else statement.

Now let us see a simple program that finds out the largest number among two numbers.

// Program-con4.cpp
#include 
void main()
{ 
 int a, b;
 cout << “\nEnter first number : ”;
 cin >> a;
 cout << “Enter second number : ”;
 cin >> b;

 if (a>b)
 cout << “First number is greater than second number.”;
 else
 cout << “Second number is greater than or equal to first number.”;
}

// Program con5.cpp
#include 
void main()
{ 
 int a,b;
 cout << “\nEnter first number : ”;
 cin >> a;
 cout << “Enter second number : ”;
 cin >> b;

 if (a>b)
 cout << “First number is greater than second number.”;
 else
 {
 if (a cout << “Second number is greater than first number.”;
 else
cout << “Both numbers are equal.”;
}
}

// Program con6.cpp
#include 
void main()
{
 int age;
 cout << “\n Enter your age : ”;
 cin >> age;
 
 if (age <=5)
 cout << “\n You are a lovely kid.”;
 else
 if (age <= 10)
 cout << “\n You are grwoing up.”;
 else
 if (age <= 20)
 cout << “\n You have not yet grown up.”;
 else 
 if (age <= 30)
 cout << “\n Now you have grown up.”;
 else
 cout << “\n You are a nice gentleman.”;
}

// Program con7.cpp
#include 
void main()
{
 int age;
 cout << “\n Enter your age : ”;
 cin >> age;
 
 if (age <=5)
cout << “\n You are a lovely kid.”;
else
if (age <= 10)
cout << “\n You are growing up.”;
else
if (age <= 20)
cout << “\n You have not yet grown up.”;
else 
if (age <= 30)
cout << “\n Now you have grown up.”;
else
cout << “\n You are a nice gentleman.”;
}

// Program con8.cpp 
#include 
void main()
{
 int age;
 cout << “\n Enter your age : ”;
 cin >> age;
 
 if (age <=5)
 cout << “You are a lovely kid.”;
 else if (age <= 10)
 cout << “You are grwoing up.”;
 else if (age <= 20)
 cout << “You have not yet grown up.”;
 else if (age <= 30)
 cout << “Now you have grown up.”;
 else
 cout << “You are a nice gentleman.”;
}

// Program con9.cpp
#include 
void main()
{
 int age;
 cout << “\n Enter your age : ”;
 cin >> age;
 
 if (age <=5)
 cout << “\n You are a lovely kid.”;
 if (age >5 && age <= 10)
 cout << “\n You are growing up.”;
 if (age > 10 && age <= 20)
 cout << “\n You have not yet grown up.”;
 if (age > 20 && age <= 30)
 cout << “\n Now you have grown up.”;
 if (age > 30)
 cout << “\n You are a nice gentleman.”;
}

// Program con10.cpp
#include 
void main()
{
 char ch;
 cout << “\n Enter a character (a/b/c) : ”;
 cin >> ch;    
 if (ch == ‘a’ || ch == ‘A’)
 cout << “You have entered either a or A”;
 else  if (ch == ‘b’ || ch == ‘B’)
 cout << “You have entered either b or B”;
 else  if (ch == ‘c’ || ch == ‘C’)
 cout << “You have entered either c or C”;
 else
 cout << “Read your question again.”;
}

// Program con11.cpp
#include 
void main()
{
 int year;
 cout << “\nEnter a year : ”;
 cin >> year;
 
 if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
 cout << “Leap year.”;
 else
 cout << “Not a leap year.”;
}

! num == 0 is interpreted as (!num) == 0 instead of ! (num == 0).

 ! (num == 0)

// Program con12.cpp
#include 
void main()
{
 int a, b, big;
 cout << “\n Enter two numbers : ”;
 cin >> a >> b;
 
 big = (a > b) ? a : b;
 cout << “Largest number : ” << big;
}

big = (a > b) ? a : b;

if (a>b)
 big = a;
 else
 big = b;

// Program con13.cpp
#include 
void main()
{
 int num;
 cout << “\nEnter a number : ”;
 cin >> num;
 
 (num >= 0 ? cout << “Positive number” : cout << “Negative number.”);
}

// Program con14.cpp
#include 
void main()
{
 int a, b, c, big;
 cout << “\nEnter three numbers : ”;
 cin >> a >> b >> c;

 big = (a>b ? (a>c ? a : c) : (b>c ? b : c));
 cout << “Largest number : ” << big;
}

X == 10    // Comparison
 X = 10        // Assignment

// Program con15.cpp
#include 
void main()
{
 int num;
 cout << “\n Enter a number : ”;
 cin >> num;
 
 if (num == 10)
 cout << “You have entered 10”;
 else
 cout << “You have not entered 10”;

 if (num = 10)
 cout << “\nYou have entered 10”;
 else
 cout << “\nYou have not entered 10”;

}

if(10)

if (num == 10) ;
 cout << “You have entered 10”;

cout << “You have entered 10”;

switch (integer-expression)
 {
 case label1 :
 statement(s);
 case label2 :
 statement(s);
 case label3 :
 statement(s);
 ….

 case labeln :
 statement(s);
 default :
 statement(s);
 }

// Program con16.cpp
#include 
void main()
{
 int n;
 cout << “\nEnter a number : ”;
 cin >> n;

 switch (n)
 {
 case 1:
 cout << “\nYou entered 1.”;
 case 2:
 cout << “\nYou entered 2.”;
 case 3:
 cout << “\nYou entered 3.”;
 case 4:
 cout << “\nYou entered 4.”;
 default :
 cout << “\nYou have not entered 1, 2, 3 or 4.”;
 }
}

// Program con17.cpp
#include 
void main()
{
 int n;
 cout << “\nEnter a number : ”;
 cin >> n;

 switch (n)
 {
 case 1:
 cout << “You entered 1.”;
 break;
 case 2:
 cout << “You entered 2.”;
 break;
 case 3:
 cout << “You entered 3.”;
 break;
 case 4:
 cout << “You entered 4.”;
 break;
 default :
 cout << “You have not entered 1, 2, 3 or 4.”;
 }
}

// Program con18.cpp
#include 
void main()
{
 int n;
 cout << “\n Enter a number : ”;
 cin >> n;

 switch (n)
 {
 case 4:
 cout << “You entered 4.”;
 break;
 case 1:
 cout << “You entered 1.”;
 break;
 case 27:
 cout << “You entered 27.”;
 break;
 case 6:
 cout << “You entered 6.”;
 break;
 default :
 cout << “Pardon me.”;
 }
}

// Program con19.cpp
#include 
void main()
{
 char ch;
 cout << “\nEnter any vowel : ”;
 cin >> ch;

 switch (ch)
 {
 case ‘a’:
 cout << “You entered a.”;
 break;
 case ‘e’:
 cout << “You entered e.”;
 break;
 case ‘i’:
 cout << “You entered i.”;
 break;
 case ‘o’:
 cout << “You entered o.”;
 break;
 case ‘u’:
 cout << “You entered u.”;
 break;
 default :
 cout << “You have not entered any vowel.”;
 }
}

// Program con20.cpp
#include 
void main()
{
 char ch;
 cout << “\n Enter any vowel : ”;
 cin >> ch;

 switch (ch)
 {
 case ‘a’:
 cout << “You entered a.”;
 break;
 case 101:
 cout << “You entered e.”;
 break;
 case ‘i’:
 cout << “You entered i.”;
 break;
 case 111:
 cout << “You entered o.”;
 break;
 case ‘u’:
 cout << “You entered u.”;
 break;
 default :
 cout << “You have not entered any vowel.”;
 }
}

// Program con21.cpp 
#include 
void main ()
{
char ch;
cout  <<  “\nEnter any of first four alphabet:”;
cin  >> ch;
switch (ch)
{
case ‘a’:
case ‘A’:
 cout << “You entered a and A”;
 break;            
case ‘b’:
case ‘B’:
cout << “You entered b and B”;
break;
case ‘c’:
case ‘C’:
cout << “You entered c and C”;
break;
case ‘d’:
case ‘D’:
cout << “You entered d and D”;
break;
default:
cout << “You have not entered any of the first four alphabet.”;
}
}

if (num >100 && num <=200)
// statements
else if (num >200 && num <=500)
// statements
else 
// statements

// Program con22.cpp 
#include 
void main()
{
 int number;
 start :
 cout << “\nEnter a number :”;
 cin >> number;
 if (number >=0)
 {
 cout << “Positive number”;
 goto start;
 }
 else
 cout << “You have entered a negative number”;
}

// Program con23.cpp
 #include 
 #include     // header file for abs()–function 
 void main()
 {
 int a, b, c, d, e, sum, number, n;
 cout << “\nEnter a number – “;
 cin >> number;
 n = abs(number);
 a = n%10;
 n = n/10;
 b = n%10;
 n = n/10;
 c = n%10;
 n = n/10;
 d = n%10;
 n = n/10;
 e = n%10;
 sum = a+b+c+d+e;
 cout << “\nSum of digits = ” << sum;
 }

n % 10 and
 n / 10

 while (test-condition)
 {
 statement(s);
 }

// Program con24.cpp
#include 
#include 
void main ()
{
int a, sum=0, n , num ;
cout << “\nEnter any number:”;
n = abs(num);
cin >>num;
while (num != 0)
{
a= num  % 10;
 num = num /10;
 sum = sum + a;
}
cout << “ \n Sum of digit =” <}

// Program con25.cpp
#include
void main()
{
int num;
cout<< “\nEnter a positive number: “;
cin>>num;
while (num>=0)
{
 cout<< “Square of  “< cout<< “\nEnter the another positive”;
 cin>>num;
}
 cout<< “\n you have entered a negative number”;
}

// Program con26.cpp
#include
void main()
{
int num;
num=1;
while (num>=0)
{
 cout<< “\n Square of ”< cout<< “\n Enter the another positive”;
}
 cout<< “\n you have entered a negative number”;
}

while (num>=0);

while (num>=0)                                     
 {                             
 }

while (x==0)
 cin>>x;

// Program con27.cpp
#include 
void main()
{
int count; 
float a, b, c, average;
count=1;
while (count<=5)
{
cout<< “\n Enter three numbers :”;
 cin >> a>>b>>c;
 average = (a + b + c)/3.0;
cout<< “Average = ”<< average;
count++;
}    
}

num = 0.2;

num = num +0.5;

do
{
statement(s);

} while(test-condition);

// Program con28.cpp 
#include
 void main()
 {
 int x=0;
while (x==1)
{
cout<< “ \n You have done a big mistake “;
cout<< “\n Never try this again “;
 }
 cout<< “\n  I was a big stupid “;
 }

// Program con29.cpp 
#include
void main()
{
 int x=0;
 do
 {
 cout<< “\n Thanks god”;
 cout<< “\n I have not done a big mistakes”;
 } while (x==1);
cout<< “\n I am a big stupid”;
}

for (initialize_counter; test-condition; update_counter)
{
 statement(s);
}

// Program con30.cpp
#include 
void main()
{
 int n;
 for (n=1; n<=5; n++)
 cout<< “\n N=”<}

// Program con31.cpp
#include 
void main()
{
 int n;
 for (n=10; n>=1; n--)
 cout<< “\nN=”<}

// Program con32.cpp
#include 
void main()
{
 int n;
 for (n=1; n<=5; n++)
 {
cout<< “\n N=”< cout << “\tN*N=”< cout<< “\tN*N*N=”< }
}

for (int n=1;n<=5; n++)
{
 //
}

for (i=1, j=5; i<=5; i++, j--)
 cout<< i <<  “ ” << j << “\n”;

for(n=1;n<=5;)
 {
 statement(s);
n++; }

n=1;
 for( ; n<=5;n++)
 {    
statement(s);
 }

n=1;
 for(;n<=5;)
 {
statement(s);
 n++;
 }

// Program con33.cpp
#include
void main( )
{
 int n;
 for( n=1; n<=20; n=n+3)
cout<< “\nN =”<}

Sum = x – x3/3! + x5/5! – x7/7! + ……… (-1)n-1 x2n-1/(2n-1)!

// Program con34.cpp
# include 
void main ()
{
int i , n ;
 float x, sum , num , den , sn = -1;  
 cout << “\nEnter x and n: ”;
 cin >> x >> n;
 sum = x;
 num = x;
 den = 1;
 for (i=1 ;i <=n-1 ; i ++)  
 {
 num = num * x * x;
 den = den * (2*i) * (2*i+1);
 sum = sum + (num /den ) *sn;
 sn =-sn;
 }
 cout << “\nX=” <}

ith item = (-1)i-1x2i-1 /(2i-1)!(i +1) 
item = (-1)I x(2i+1)/(2i+1)!

// Program con35.cpp
#include
void main ( )
{
 int  i, j, temp; 
 for (i=1;i<=3;i++ ) 
 {
 for ( j=1 ;j<=3 ; j++)
 {
 temp = i * j;    
cout << “\nI=”<< i << “\tJ=”< }
 }
}

 break; 

statement; 
 while (test-condition1)
 {
 statement(s);
 if(test-condition 2)
 break;
 statement(s);
}
statement;

// Program con36.cpp
#include
void main( )
{
 int num , i , flag;
 cout<< “\nEnter a number :”;
 cin>>num;
 i=2;
 flag=0;
 while (i<=num/2)
 {
 if(num%i==0)
 {
 flag = 1;
 break;
 }
 i++;
 }
 if (flag==0)
 cout<< “Prime number: ”<< num;
else
 cout<< “Not a prime number: ” << num;
}

// Program con37.cpp
# include
void main()
{
 int i ,j , k;
 for (i=1;i<=3;i++)
 {
 for(j=1;j<=3; j++)    
 {
 for(  k=1; k<=3;k++)
 {
 if ((i ==j)||(j==k)||(k==i))
 break;
 else
 cout< }
 }
 }
}

continue;

statement; 
 while (test-condition1)
 {
statement (s);        
 if( test-condition 2)
 continue ;
 statement (s);        
}    
statement (s);

// Program con38.cpp
#include 
void main()
{
int i , j , k ;
 for ( i=1; i<=3; i++)
 {
 for ( j=1 ;j<=3;j++)
 {
 for (k=1 ;k<=3;k++)
 {
 if ((i==j)||(j==k)||(k==i))
 continue ;
 else
 cout << "\n" << i << "\t" << j << "\t" << k ;
 }
 }
 }
}