C++ Tutorials

Introduction To Programming CS201 Lecture_08

2011-11-05T10:37:00.000-07:00

Introduction To Programming Lecture-08

Introduction To Programming CS201 Lecture_07

2011-11-05T10:34:00.000-07:00

Introduction To Programming Lecture-07

Introduction To Programming CS201 Lecture_06

2011-11-05T10:33:00.000-07:00

Introduction To Programming Lecture-06

Introduction To Programming CS201_Lecture-05

2011-11-05T10:31:00.000-07:00

Introduction To Programming Lecture-05

Introduction To Programming CS201_Lecture-04

2011-10-24T08:32:00.001-07:00

Introduction To Programming Lecture-04

Introduction To Programming CS201_Lecture-03

2011-10-24T08:31:00.000-07:00

Introduction To Programming Lecture-03

Introduction To Programming CS201 Lecture-02

2011-10-24T08:25:00.000-07:00

Introduction To Programming Lecture-02

Introduction To Programming CS201_Lecture01

2011-10-24T08:14:00.000-07:00

Introduction To Programming Lecture-01

ROBERT LAFORE-OBJECT ORIENTED PROGRAMMING IN C++

2011-10-12T04:01:00.000-07:00

To Download OBJECT ORIENTED PROGRAMMING IN C++. Click on the link below.

http://www.ziddu.com/download/16777122/Robert_Lafore_Object_Oriented_Programming_in_C_.pdf.html

RAILWAY SEAT RESERVATION PROJECT

2011-10-10T18:05:00.000-07:00

RAILWAY SEAT RESERVATION PROJECT

Description: This C++ program on RAILWAY SEAT RESERVATION is a simple text base program.We have used procedure oriented method to design this program. This program is without grahics to keep program simple for beginners.

in a trian compartment there are 67 seats...13 rows of 5 (3 by2) setats and the last row has 2

#include<iostream.h>

#include<conio.h>

#include<stdio.h>

struct rail

{

int seatNo;

int isEmpty;

}seat[67];

void reserve(int n);

int arrRowState[15];

void main()

{

for(int i = 0 ; i <67 ; i++)

{

seat[i].seatNo=(i+1);

seat[i].isEmpty=1;

}

for(i=0 ; i<13 ; i++)

arrRowState[i]=5;

arrRowState[13]=2;

arrRowState[14]=67;

char res='y';

{

int n;

cout<<"Enter d no of seats u want to reserve : ";

cin>>n;

reserve(n);

cout<<"Do u want to reserve more seats?";

res=getchar();

}while(res!='n');

}

void reserve(int n)

{

if(n>arrRowState[14])

{

cout<<"Too large group to accomodate";

getch();

return;

}

int flag=0;

int seatbook;

for(int i = 0 ; flag==0&&i<=13 ; i++)

{

if(arrRowState[i] >= n)

{

flag=1;

// cout<<"Following Seats Alloted";

seatbook=(((i)*5)+(6-arrRowState[i]));

for(int j = 0 ; j < n ; j++)

{

cout<<""<<seatbook+j<<"";

seat[(seatbook+j)].isEmpty=0;

}

arrRowState[i]=arrRowState[i]-n;

arrRowState[14]=arrRowState[14]-n;

}

if(flag==0)

{

while(n!=0)

{

int max,rowNo=0;

max=arrRowState[0];

for( int j = 0 ; j<14 ; j++)

{

if(arrRowState[j] > max)

{

max=arrRowState[j];

rowNo=j;

}

if(n>max)

{

n=n-max;

seatbook=(((rowNo)*5)+(6-arrRowState[rowNo]));

arrRowState[rowNo]=arrRowState[rowNo]-max;

for( int j = 0 ; j<max ; j++)

{

cout<<""<<(seatbook+j)<<"";

seat[(seatbook+j)].isEmpty=0;

}

else

{

reserve(n);

n=0;

}

getch();

}

MS Visual C++ 6.0 (standard version)

2011-10-10T09:41:00.001-07:00

Click Here To Download MS Visual C++ 6.0.
http://www.ziddu.com/download/16751945/MicrosoftVisualCplusplus6.0StandardEdition.exe.html

DYNAMIC QUEUE

2011-10-09T08:46:00.000-07:00

DYNAMIC QUEUE

linked list implemented queue containing data values, function to insert and delete a number from the queue

Queue is a linear data structure in which insertion and deletion of elements takes place from two opposite ends rear and front respectively.

#include<iostream.h>
#include<conio.h>

struct node
{
int data;
node *next;
};

class queue
{
      node *rear,*front;
public:
      queue()
      { rear=NULL;front=NULL;}
      void qinsert();
      void qdelete();
      void qdisplay();
      ~queue();
};

void queue::qinsert()
{
      node *temp;
      temp=new node;
      cout<<"Data :";
      cin>>temp->data;
      temp->next=NULL;
      if(rear==NULL)
      {
            rear=temp;
            front=temp;
      }
      else
      {
            rear->next=temp;
            rear=temp;
      }
}

void queue::qdelete()
{
      if(front!=NULL)
      {
            node *temp=front;
            cout<<front->data<<"deleted \n";
            front=front->next;
            delete temp;
            if(front==NULL)
                  rear=NULL;
      }
      else
            cout<<"Queue Empty..";
}

void queue::qdisplay()
{
      node *temp=front;
      while(temp!=NULL)
      {
            cout<<temp->data<<endl;
            temp=temp->next;
      }
}

queue::~queue()
{
      while(front!=NULL)
      {
            node *temp=front;
            front=front->next;
            delete temp;
      }
}

void main()
{
      queue obj; char ch;
      do
      {
            cout<< "i. insert\nd. Delete\ns. Display\n q. quit ";
            cin>>ch;
            switch(ch)
            {
                  case 'i' : obj.qinsert();break;
                  case 'd' : obj.qdelete();break;
                  case 's' : obj.qdisplay();
            }
      }while(ch!='q');
}

DYNAMIC STACK

2011-10-09T08:45:00.000-07:00

DYNAMIC STACK

Defining structure of node for the linked stack, Defining member function PUSH() - to push a node to the stack which is allocated dynamically, POP() - to remove a node from the stack and release the memory.

Stack is a linear data structure in which insertion and deletion of elements takes place only one end known as TOP.

#include<iostream.h>
#include<conio.h>

struct node
{
int data;
node *next;
};

class stack
{
      node *top;
public :
      stack()
      { top=NULL;}
      void push();
      void pop();
      void display();
      ~stack();
};

void stack::push()
{
      node *temp;
      temp=new node;
      cout<<"Enter data :";
      cin>>temp->data;
      temp->next=top;
      top=temp;
}

void stack::pop()
{
      if(top!=NULL)
      {
            node *temp=top;
            top=top->next;
            cout<<temp->data<<"deleted";
            delete temp;
      }
      else
            cout<<"Stack empty";
}

void stack::display()
{
      node *temp=top;
      while(temp!=NULL)
      {
      cout<<temp->data<<" ";
      temp=temp->next;
      }
}

stack::~stack()
{
      while(top!=NULL)
      {
            node *temp=top;
            top=top->next;
            delete temp;
      }
}

void main()
{
      stack st;
      char ch;
      do
      {
            cout<<"stack options\nP for push \nO for Pop \nD for Display \nQ for quit";
            cin>>ch;
            switch(ch)
            {
                  case 'P': st.push();break;
                  case 'O': st.pop();break;
                  case 'D': st.display();break;
            }
      }while(ch!='Q');
}

CIRCULAR QUEUE

2011-10-09T08:44:00.000-07:00

CIRCULAR QUEUE

Array implemented circular queue containing data values, function to insert and delete data from the queue

#include<iostream.h>
#include<conio.h>
#define size 4

class cqueue
{
      int data[size];
      int front,rear;
public:
      cqueue()
      {
            front=-1;rear=-1;
      }
      void insert();
      void remove();
};

void cqueue::insert()
{
      if(rear==size-1&&front==0 || front==rear+1)
      {
            cout<<"\nCircular queue is full";
            return;
      }
      else if(rear==-1)
      {
            rear++;
            front++;
      }
      else if(rear==size-1)
            rear=0;
      else
            rear++;

cout<<"Enter Data : ";
cin>>data[rear];
}

void cqueue::remove()
{
      if(front==-1)
      {
            cout<<"\n Circular Queue is empty";return;
      }

cout<<data[front]<<" deleted"<<endl;

      if(front==rear)
      {
            front=-1;rear=-1;
      }
      else if(front==size-1)
            front=0;
      else
            front++;
}

void main()
{
      cqueue cq;
      int ch;
      do
      {
            cout<<"\n1. Insert\n2. Remove\n3. Quit\nEnter Choice(1-3) ";
            cin>>ch;
            switch(ch)
            {
                  case 1: cq.insert();break;
                  case 2: cq.remove();break;
            }
      }while(ch!=3);
}

STATIC STACK

2011-10-09T08:43:00.000-07:00

STATIC STACK

Stack as an Array, Defining member function PUSH() - to push data to the stack, POP() - to remove data from the stack.

#include<iostream.h>
#include<conio.h>
#define size 4

class stack
{
     int data[size];
     int top;
public:
     stack()
     {
          top=-1;
     }
     void push();
     void pop();
     void display();
};

void stack::push()
{
     if(top==size-1)
     {
          cout<<"\nStack is full";
          return;
     }
     else
     {
          top++;
          cout<<"Enter Data : ";
          cin>>data[top];
     }
}

void stack::pop()
{
     if(top==-1)
          cout<<"\n Stack is empty";
     else
     {
          cout<<data[top]<<"deleted "<<endl;
          top--;
     }
}

void stack::display()
{
     int t=top;
     while(t>=0)
     {
          cout<<data[t]<<endl;
          t--;
     }
}

void main()
{
     stack st;
     int ch;
     do
     {
          cout<<"\n1. Push\n2. Pop\n3. Display \n4.Quit\nEnter Choice(1-4) ";
          cin>>ch;
          switch(ch)
          {
               case 1: st.push();break;
               case 2: st.pop();break;
               case 3: st.display();
          }
     }while(ch!=4);
}

POINTER

2011-10-09T08:41:00.001-07:00

POINTER

C++ Memory Map, Defining Pointer Variable, Pointer Arithmetics, Pointers and Arrays, Pointers and strings, Pointers to Structures, Dynamic memory, Memory Leak, Self Referential Structure

C++ Memory Map

Once a program is compiled, C++ creates four logically distinct regions of memory:
Code Area : Area to hold the compiled program code
Data Area : Area to hold global variables
Stack Area : Area to hold the return address of function calls, argument passed to the functions, local variables for functions and the current state of the CPU.
Heap : Area from which the memory is dynamically allocated to the program.

Accessing address of a variable

Computer’s memory is organized as a linear collection of bytes. Every byte in the computer’s memory has an address. Each variable in program is stored at a unique address. We can use address operator & to get address of a variable:
int num = 23;
cout << &num; // prints address in hexadecimal

POINTER

A pointer is a variable that holds a memory address, usually the location of another variable in memory.

Defining a Pointer Variable
int *iptr;
iptr can hold the address of an int

Pointer Variables Assignment:
int num = 25;
int *iptr;
iptr = &num;

Memory layout

To access num using iptr and indirection operator *
cout << iptr; // prints 0x4a00
cout << *itptr; // prints 25

Similary, following declaration shows:
char *cptr;
float *fptr;
cptr is a pointer to character and fptr is a pointer to float value.

Pointer Arithmetic

Some arithmetic operators can be used with pointers:
   - Increment and decrement operators ++, --
    - Integers can be added to or subtracted from
      pointers using the operators +, -, +=, and -=

Each time a pointer is incremented by 1, it points to the memory location of the next element of its base type.
If “p” is a character pointer then “p++” will increment “p” by 1 byte.
If “p” were an integer pointer its value on “p++” would be incremented by 2 bytes.

Pointers and Arrays

Array name is base address of array
            int vals[] = {4, 7, 11};
            cout << vals;       // displays 0x4a00
            cout << vals[0]; // displays 4

Lets takes an example:

int arr[]={4,7,11};
int *ptr = arr;
What is ptr + 1?
It means (address in ptr) + (1 * size of an int)
cout << *(ptr+1); // displays 7
cout << *(ptr+2); // displays 11

Array Access
Array notation arr[i] is equivalent to the pointer notation *(arr + i)

Assume the variable definitions
   int arr[]={4,7,11};
   int *ptr = arr;
Examples of use of ++ and --
   ptr++; // points at 7
   ptr--; // now points at 4

Character Pointers and Strings

Initialize to a character string.
char* a = “Hello”;
a is pointer to the memory location where ‘H’ is stored. Here “a” can be viewed as a character array of size 6, the only difference being that a can be reassigned another memory location.
char* a = “Hello”;
a         gives address of ‘H’
*a        gives ‘H’
a[0]      gives ‘H’
a++      gives address of ‘e’
*a++    gives ‘e’

Pointers as Function Parameters

A pointer can be a parameter. It works like a reference parameter to allow change to argument from within function

Pointers as Function Parameters
       void swap(int *x, int *y)
       {
          int temp;
                              temp = *x;
                              *x = *y;
                              *y = temp;
       }
      swap(&num1, &num2);

Pointers to Constants and Constant Pointers

Pointer to a constant: cannot change the value that is pointed at
Constant pointer: address in pointer cannot change once pointer is initialized

Pointers to Structures

We can create pointers to structure variables

            struct Student {int rollno; float fees;};
            Student stu1;
            Student *stuPtr = &stu1;
            (*stuPtr).rollno= 104;
-or-
Use the form ptr->member:
            stuPtr->rollno = 104;

Static allocation of memory

In the static memory allocation, the amount of memory to be allocated is predicted and preknown. This memory is allocated during the compilation itself. All the declared variables declared normally, are allocated memory statically.

Dynamic allocation of memory

In the dynamic memory allocation, the amount of memory to be allocated is not known. This memory is allocated during run-time as and when required. The memory is dynamically allocated using new operator.

Free store

Free store is a pool of unallocated heap memory given to a program that is used by the program for dynamic allocation during execution.

Dynamic Memory Allocation

We can allocate storage for a variable while program is running by using new operator

To allocate memory of type integer
int *iptr=new int;

To allocate array
double *dptr = new double[25];

To allocate dynamic structure variables or objects
Student sptr = new Student; //Student is tag name of structure

Releasing Dynamic Memory

Use delete to free dynamic memory
delete iptr;
To free dynamic array memory
delete [] dptr;
To free dynamic structure
delete Student;

Memory Leak

If the objects, that are allocated memory dynamically, are not deleted using delete, the memory block remains occupied even at the end of the program. Such memory blocks are known as orphaned memory blocks. These orphaned memory blocks when increase in number, bring adverse effect on the system. This situation is called memory leak

Self Referential Structure

The self referential structures are structures that include an element that is a pointer to another structure of the same type.

struct node
{
int data;
node* next;
}

TEXT & BINARY FILE

2011-10-09T08:40:00.000-07:00

TEXT & BINARY FILE

Program to write, read, display, count number of characters, words,lines in text file. In binary file write, display records, search, delete and modify a record

Program to write in a text file

#include<fstream.h>
int main()
{
     ofstream fout;
     fout.open("out.txt");
     char str[300]="Time is a great teacher but unfortunately it kills all its pupils. Berlioz";
     fout<<str;
     fout.close();
     return 0;
}

Program to read from text file and display it

#include<fstream.h>
#include<conio.h>
int main()
{
     ifstream fin;
     fin.open("out.txt");
     char ch;
     while(!fin.eof())
     {
          fin.get(ch);
          cout<<ch;
     }
     fin.close();
     getch();
     return 0;
}

Program to count number of characters.

#include<fstream.h>
#include<conio.h>
int main()
{
     ifstream fin;
     fin.open("out.txt");
     clrscr();
     char ch; int count=0;
     while(!fin.eof())
     {
          fin.get(ch);
          count++;
     }
     cout<<"Number of characters in file is "<<count;
     fin.close();
     getch();
     return 0;
}

Program to count number of words

#include<fstream.h>
#include<conio.h>
int main()
{
     ifstream fin;
     fin.open("out.txt");
     char word[30]; int count=0;
     while(!fin.eof())
     {
          fin>>word;
          count++;
     }
     cout<<"Number of words in file is "<<count;
     fin.close();
     getch();
     return 0;
}

Program to count number of lines

#include<fstream.h>
#include<conio.h>
int main()
{
     ifstream fin;
     fin.open("out.txt");
     char str[80]; int count=0;
     while(!fin.eof())
     {
          fin.getline(str,80);
          count++;
     }
     cout<<"Number of lines in file is "<<count;
     fin.close();
     getch();
     return 0;
}

Program to copy contents of file to another file.

#include<fstream.h>
int main()
{
     ifstream fin;
     fin.open("out.txt");
     ofstream fout;
     fout.open("sample.txt");
     char ch;
     while(!fin.eof())
     {
          fin.get(ch);
          fout<<ch;
     }
     fin.close();
     return 0;
}

BASIC OPERATION ON BINARY FILE IN C++

class student
{
          int admno;
          char name[20];
public:
          void getdata()
          {
                     cout<<"\nEnter The admission no. ";
                     cin>>admno;
                     cout<<"\n\nEnter The Name of The Student ";
                     gets(name);
          }
          void showdata()
          {
                     cout<<"\nAdmission no. : "<<admno;
                     cout<<"\nStudent Name : ";
                     puts(name);
          }
          int retadmno()
          {
                     return admno;
          }
};

function to write in a binary file

void write_data()
{
          student obj;
          ofstream fp2;
          fp2.open("student.dat",ios::binary|ios::app);
          obj.getdata();
          fp2.write((char*)&obj,sizeof(obj));
          fp2.close();
}

function to display records of file

void display()
{
          student obj;
          ifstream fp1;
          fp1.open("student.dat",ios::binary);
          while(fp1.read((char*)&obj,sizeof(obj)))
          {
                     obj.showdata();
          }
}
          fp.close();
}

Function to search and display from binary file

void search (int n)
{
          student obj;
          ifstream fp1;
          fp1.open("student.dat",ios::binary);
          while(fp1.read((char*)&obj,sizeof(obj)))
          {
                     if(obj.retadmno()==n)
                              obj.showdata();
          }
          fp1.close();
}

Function to delete a record

void deleterecord(int n)
{
          student obj;
          ifstream fp1;
          fp1.open("student.dat",ios::binary);
          ofstream fp2;
          fp2.open("Temp.dat",ios::out|ios::binary);
          while(fp1.read((char*)&obj,sizeof(obj)))
          {
                      if(obj.retadmno!=n)
                                  fp2.write((char*)&obj,sizeof(obj));
          }
          fp1.close();
          fp2.close();
          remove("student.dat");
          rename("Temp.dat","student.dat");
}

Function to modify a record

void modifyrecord(int n)
{
          fstream fp;
          student obj;
          int found=0;
          fp.open("student.dat",ios::in|ios::out);
          while(fp.read((char*)&obj,sizeof(obj)) && found==0)
          {
                     if(obj.retadmno()==n)
                     {
                              obj.showdata();
                              cout<<"\nEnter The New Details of student";
                              obj.getdata();
                              int pos=-1*sizeof(obj);
                              fp.seekp(pos,ios::cur);
                              fp.write((char*)&obj,sizeof(obj));
                              found=1;
                    }
          }
          fp.close();
}

DATA FILE HANDLING

2011-10-09T08:39:00.000-07:00

DATA FILE HANDLING

File, Stream, Text file, Binary file, ofstream, ifstream, fstream class, Opening a file, Closing file, Input and output operation, File pointer and their manipulation

File. The information / data stored under a specific name on a storage device, is called a file.

Stream. It refers to a sequence of bytes.

Text file. It is a file that stores information in ASCII characters. In text files, each line of text is terminated with a special character known as EOL (End of Line) character or delimiter character. When this EOL character is read or written, certain internal translations take place.

Binary file. It is a file that contains information in the same format as it is held in memory. In binary files, no delimiters are used for a line and no translations occur here.

Classes for file stream operation

ofstream: Stream class to write on files
ifstream: Stream class to read from files
fstream: Stream class to both read and write from/to files.

Opening a file

OPENING FILE USING CONSTRUCTOR
ofstream fout(“results”); //output only
ifstream fin(“data”); //input only

OPENING FILE USING open()
Stream-object.open(“filename”, mode)

      ofstream ofile;
      ofile.open(“data1”);

      ifstream ifile;
      ifile.open(“data2”);

File mode parameter	Meaning
ios::app	Append to end of file
ios::ate	go to end of file on opening
ios::binary	file open in binary mode
ios::in	open file for reading only
ios::out	open file for writing only
ios::nocreate	open fails if the file does not exist
ios::noreplace	open fails if the file already exist
ios::trunc	delete the contents of the file if it exist

All these flags can be combined using the bitwise operator OR (|). For example, if we want to open the file example.bin in binary mode to add data we could do it by the following call to member function open():

fstream file;
file.open ("example.bin", ios::out | ios::app | ios::binary);

CLOSING FILE

fout.close();
fin.close();

INPUT AND OUTPUT OPERATION

put() and get() function
the function put() writes a single character to the associated stream. Similarly, the function get() reads a single character form the associated stream.
example :
file.get(ch);
file.put(ch);

write() and read() function
write() and read() functions write and read blocks of binary data.
example:
file.read((char *)&obj, sizeof(obj));
file.write((char *)&obj, sizeof(obj));

ERROR HANDLING FUNCTION

FUNCTION	RETURN VALUE AND MEANING
eof()	returns true (non zero) if end of file is encountered while reading; otherwise return false(zero)
fail()	return true when an input or output operation has failed
bad()	returns true if an invalid operation is attempted or any unrecoverable error has occurred.
good()	returns true if no error has occurred.

FILE POINTERS AND THEIR MANIPULATION

All i/o streams objects have, at least, one internal stream pointer:
ifstream, like istream, has a pointer known as the get pointer that points to the element to be read in the next input operation.

ofstream, like ostream, has a pointer known as the put pointer that points to the location where the next element has to be written.

Finally, fstream, inherits both, the get and the put pointers, from iostream (which is itself derived from both istream and ostream).

These internal stream pointers that point to the reading or writing locations within a stream can be manipulated using the following member functions:

seekg()	moves get pointer(input) to a specified location
seekp()	moves put pointer (output) to a specified location
tellg()	gives the current position of the get pointer
tellp()	gives the current position of the put pointer

The other prototype for these functions is:

seekg(offset, refposition );
seekp(offset, refposition );

The parameter offset represents the number of bytes the file pointer is to be moved from the location specified by the parameter refposition. The refposition takes one of the following three constants defined in the ios class.

ios::beg          start of the file
ios::cur          current position of the pointer
ios::end          end of the file

example:
file.seekg(-10, ios::cur);

INHERITANCE

2011-10-09T08:38:00.000-07:00

INHERITANCE

Inheritance, Base Class, Derived Class, Single Inheritance, Multiple, Hierarchical, Multilevel and Hybrid Inheritance, Visibility Mode, Containership, Overriding of function in inheritance, Virtual Base Class

Inheritance:It is the capability of one class to inherit properties from another class.

Base Class: It is the class whose properties are inherited by another class. It is also called Super Class.

Derived Class:It is the class that inherit properties from base class(es).It is also called Sub Class.

FORMS OF INHERITANCE

Single Inheritance: It is the inheritance hierarchy wherein one derived class inherits from one base class.

Multiple Inheritance:It is the inheritance hierarchy wherein one derived class inherits from multiple base class(es)

Hierarchical Inheritance: It is the inheritance hierarchy wherein multiple subclasses inherits from one base class.

Multilevel Inheritance: It is the inheritance hierarchy wherein subclass acts as a base class for other classes.

Hybrid Inheritance:The inheritance hierarchy that reflects any legal combination of other four types of inheritance.

Visibility Mode:It is the keyword that controls the visibility and availability of inherited base class members in the derived class.It can be either private or protected or public.

Private Inheritance:It is the inheritance facilitated by private visibility mode.In private inheritance ,the protected and public members of base class become private members of the derived class.

Public Inheritance:It is the inheritance facilitated by public visibility mode.In public inheritance ,the protected members of base class become protected members of the derived class and public members of the base class become public members of derived class.;

Protected Inheritance:It is the inheritance facilitated by protected visibility mode.In protected inheritance ,the protected and public members of base class become protected members of the derived class.

Base Class Visibility	Derived class visibility
Base Class Visibility	Public derivation	Private derivation	Protected derivation
Private	Not inherited	Not inherited	Not inherited
Protected	Protected	Private	Protected
Public	Public	Private	Protected

Containership:When a class contains objects of other class types as its members, it is called containership.It is also called containment,composition, aggregation.

Execution of base class constructor

Method of inheritace	Order of execution
class B : public A { };	A(); base constructor B(); derived constructor
class A : public B, public C	B();base (first) C();base (second) A();derived constructor

When both derived and base class contains constructors, the base constructor is executed first and then the constructor in the derived class is executed. In case of multiple inheritances, the base classes are constructed in the order in which they appear in the declaration of the derived class.

Overriding of method(function) in inheritance

We may face a problem in multiple inheritance, when a function with the same name appears in more than one base class. Compiler shows ambiguous error when derived class inherited by these classes uses this function.

We can solve this problem, by defining a named instance within the derived class, using the class resolution operator with the function as below :

class P : public M, public N        //multiple inheritance
{
public :
   void display() //overrides display() of M and N
   {
      M::display()
   }
};

we can now used the derived class as follows :
void main()
{
P obj;
obj.display();
}

Virtual Base Class

Multipath inheritance may lead to duplication of inherited members from a grandparent base class. This may be avoided by making the common base class a virtual base class. When a class is made a virtual base class, C++ takes necessary care to see that only one copy of that class is inherited.

class A
{
....
....
};

class B1 : virtual public A

{
....
....
};
class B2 : virtual public A
{
....
....
};
class C : public B1, public B2
{
.... // only one copy of A
.... // will be inherited
};

CONSTRUCTOR

2011-10-09T08:36:00.000-07:00

CONSTRUCTOR

Constructor, Types of Constructor, Default Constructor, Para-meterized Constructor Copy Constructor, Constructor overloading, Destructor

CONSTURCTOR

It is a member function having same name as it’s class and which is used to initialize the objects of that class type with a legel initial value. Constructor is automatically called when object is created.

Types of Constructor

Default Constructor-: A constructor that accepts no parameters is known as default constructor. If no constructor is defined then the compiler supplies a default constructor.

student :: student()
{
rollno=0;
}

Parameterized Constructor -: A constructor that receives rguments/parameters, is called parameterized constructor.

student :: student(int r)
{
rollno=r;
}

Copy Constructor-: A constructor that initializes an object using values of another object passed to it as parameter, is called copy constructor. It creates the copy of the passed object.

student :: student(student &s)
{
rollno = s.rollno;
}

There can be multiple constructors of the same class, provided they have different signatures.

DESTRUCTOR

A destructor is a member function having sane name as that of its class preceded by ~(tilde) sign and which is used to destroy the objects that have been created by a constructor. It gets invoked when an object’s scope is over.

~student() { }

CLASSES & OBJECTS

2011-10-09T08:35:00.000-07:00

CLASSES & OBJECTS

Classes and Objects, declaring a class, private members, protected members, public members, Example of a class

A class is an expanded concept of a data structure: instead of holding only data, it can hold both data and functions. An object is an instantiation of a class. In terms of variables, a class would be the type, and an object would be the variable. Classes are generally declared using the keyword class, with the following format:

class class_name
{
   access_specifier_1:
      member1;
   access_specifier_2:
      member2;
...
}object_names;

Where class_name is a valid identifier for the class, object_names is an optional list of names for objects of this class. The body of the declaration can contain members, that can be either data or function declarations, and optionally access specifiers.

An access specifier is one of the following three keywords: private, public or protected. These specifiers modify the access rights that the members following them acquire:

private members of a class are accessible only from within other members of the same class or from their friends.
protected members are accessible from members of their same class and from their friends, but also from members of their derived classes.
Finally, public members are accessible from anywhere where the object is visible.

By default, all members of a class declared with the class keyword have private access for all its members. Therefore, any member that is declared before one other class specifier automatically has private access. For example:

class CRectangle
{
private :
   int x, y;
public:
   void set_values(int,int);
    int area(void);
} rect;

Declares a class (i.e., a type) called CRectangle and an object (i.e., a variable) of this class called rect. This class contains four members: two data members of type int (member x and member y) with private access and two member functions with public access: set_values() and area(), of which for now we have only included their declaration, not their definition.

Example of a class:

#include <iostream.h>
#include <conio.h>
#include <stdio.h>

class Employee
{
   private: // Access specifier
     int empcode;      // Data member
     char empname[20]; // . . . . . . . . . .
     char empdesig[15];      // . . . . . . . . . .
     float empsalary; // . . . . . . . . . .
     float hra, da;
     void cal_da(void) //Private member function not accessible outside class
     {
         cout << "\nDearness allowance : " << 1.2 * empsalary;
      }
    public:
      void input_data();            // Member function prototype declaration
      void display();
};
void Employee::input_data()
{
      cout << "Enter the employee code ";
      cin >> empcode;
      cout << "Enter the employee name ";
      gets(empname);
      cout << "Enter the employee designation ";
      gets(empdesig);
      cout << "Basic Salary ";
      cin >> empsalary;
}
void Employee::display()
{
      cout << "\nEmployee code : " << empcode;
      cout << "\nEmployee name : " << empname;
      cout << "\nDesignation : " << empdesig;
      cout << "\nBasic Salary : " << empsalary;
      cal_da(); // Calling private function in public function print_data
}

void main()
{
     clrscr();
     Employee emp;    // Declares Object of type employee
     emp.input_data();
     cout << "Here is the employee information : \n";
     emp.display();
}

OOP CONCEPTS

2011-10-09T08:32:00.002-07:00

OOP CONCEPTS

Procedural Paradigm, Object Oriented programming, Object, Class, Data Abstraction, Encapsulation, Modularity, Advantages of Object oriented programming

Paradigm-: It means organizing principle of a program. It is an approach to programming.

Procedural ParadigmIn procedural programming paradigm, the emphasis is on doing things i.e., the procedure or the algorithm. The data takes the back seat in procedural programming paradigm. Also, this paradigm does not model real world well.

Object Oriented programmingThe object oriented programming paradigm models the real world well and overcomes the shortcomings of procedural paradigm. It views a problem in terms of objects and thus emphasizes on both procedures as well as data.

The following are the basic concepts used in object-oriented programming.

Object-: An object is an identifiable entity with some characteristics and behavior.

Class-: A class represents a group of objects that share common properties, behavior and relationships.

Data Abstraction-: Abstraction refers to act of representing essential features without including the background details or explanations.

Encapsulation-: The wrapping up of data and associated functions into a single unit is known as Encapsulation. Encapsulation implements data abstraction.

Modularity-: Modularity is the property of a system that has been decomposed into a set of cohesive and loosely coupled modules.

Inheritance-: It is the capability of one class of things to inherit capabilities or properties from another class.

Base and sub classes-: The class whose properties are inherited is called base class (or superclass) and the class that inherits the properties is known as derived class(or subclass).

Derived Class :- The class, which inherits from other classes is called derived class or Subclass.

Polymorphism-: It is the ability for a message or data to be processed in more than one form. Polymorphism is a property by which the same message can be sent to objects of several different classes. Polymorphism is implemented in C++ through virtual functions and overloading- function overloading and operator overloading.

Advantages of Object oriented programming.
Software complexity can be easily managed
Object-oriented systems can be easily upgraded
It is quite easy to partition the work in a project based on object

class enforce data-hiding, abstraction & encapsulation
A class groups its members into three sections : private, protected, and public. The private and protected members remain hidden from outside world. Thus through private and protected members, a class enforces data-hiding.

The outside world is given only the essential and necessary information through public members, rest of the things remain hidden, which is nothing but abstraction. Abstraction means representation of essential features without including the background details and explanation.

STRUCTURE

2011-10-09T08:32:00.000-07:00

STRUCTURE

Defining a structure, Declaring Variables of Type struct, Accessing of its data members, Initialization of structure variable,Nested structure, typedef, Enumerated data type, #define, Macros

A structure is a collection of variable which can be same or different types. You can refer to a structure as a single variable, and to its parts as members of that variable by using the dot (.) operator. The power of structures lies in the fact that once defined, the structure name becomes a user-defined data type and may be used the same way as other built-in data types, such as int, double, char.

struct STUDENT
{
        int rollno, age;
        char name[80];
        float marks;
} ;

void main()
{
       // declare two variables of the new type
          STUDENT s1, s3;
       //accessing of data members
       cin>>s1.rollno>>s1.age>>s1.name>>s1.marks;
       cout<<s1.rollno<<s1.age<<s1.name<<s1.marks;
      //initialization of structure variable
      STUDENT s2 = {100,17,”Aniket”,92};
       cout<<s2.rollno<<s2.age<<s2.name<<s2.marks;
     //structure variable in assignment statement
     s3=s2;
      cout<<s3.rollno<<s3.age<<s3.name<<s3.marks;
}

Defining a structure

When dealing with the students in a school, many variables of different types are needed. It may be necessary to keep track of name, age, Rollno, and marks point for example.

struct STUDENT
{
        int rollno, age;
        char name[80];
        float marks;
};

STUDENT is called the structure tag, and is your brand new data type, like int, double or char.

rollno, name, age, and marks are structure members.

Declaring Variables of Type struct

The most efficient method of dealing with structure variables is to define the structureglobally. This tells "the whole world", namely main and any functions in the program, that a new data type exists. To declare a structure globally, place it BEFORE void main(). The structure variables can then be defined locally in main, for example…

struct STUDENT
{
        int rollno, age;
        char name[80];
        float marks;
};

void main()
{
       // declare two variables of the new type
          STUDENT s1, s3;
         ………
}

Alternate method of declaring variables of type struct:

struct STUDENT
{
        int rollno, age;
        char name[80];
        float marks;
} s1, s3;

Accessing of data members

The accessing of data members is done by using the following format:
structure variable.member name
for example
cin>>s1.rollno>>s1.age>>s1.name>>s1.marks;

Initialization of structure variable

Initialization is done at the time of declaration of a variable. For example
STUDENT s2 = {100,17,”Aniket”,92};

Structure variable in assignment statement
The statement
s3=s2;
assigns the value of each member of s2 to the corresponding member of s3. Note that one structure variable can be assigned to another only when they are of the same structure type, otherwise complier will give an error.

Nested structure (Structure within structure)

It is possible to use a structure to define another structure. This is called nesting of structure.
consider the following progrm

struct DAY
{
     int month, date, year;
};

struct STUDENT
{
        int rollno, age;
        char name[80];
        day date_of_birth;
        float marks;
};

typedef

It is used to define new data type for an existing data type. It provides and alternative name for standard data type. It is used for self documenting the code by allowing descriptive name for the standard data type.

The general format is:

typedef existing datatype new datatype

for example:
typedef float real;

Now, in a program one can use datatype real instead of float.
Therefore, the following statement is valid:
real amount;

Enumerated data type

The enum specifier defines the set of names which are stored internally as integer constant. The first name was given the integer value 0, the second value 1 and so on.

for example:
enum months{jan, feb, mar, apr, may} ;

It has the following features:

It is user defined.
It works if you know in advance a finite list of values that a data type can take.
The list cannot be input by the user or output on the screen.

#define preprocessor directive

The #define preprocessor allows to define symbolic names and constants e.g.
#define pi 3.14159
This statement will translate every occurrence of PI in the program to 3.14159

Macros

Macros are built on the #define preprocessor. Normally a macro would look like:
#define square(x) x*x
Its arguments substituted for replacement text, when the macro is expanded.

2-D ARRAY

2011-10-09T08:30:00.000-07:00

2-D ARRAY

read a 2-D array, display content of a 2-D array, sum of two 2-D arrays, multiply two 2-D arrays, sum of rows & sum of columns of 2-D array, sum of diagonal elements of square matrix, transpose of a 2-D array

Function to read the array A

void Read(int A[][20], int N, int M)
{
  for(int R=0;R<N;R++)
    for(int C=0;C<M;C++)
    {
      cout<<"(R<<','<<")?";
      cin>>A[R][C];
     }
}

Function to display content of a two dimensional array A

void Display(int A[][20],int N, int M)
{
  for(int R=0;R<N;R++)
  {
     for(int C=0;C<M;C++)
        cout<<setw(10)<<A[R][C];
     cout<<endl;
   }
}

Function to find the sum of two dimensional arrays A and B

void Addition(int A[][20], int B[][20],int N, int M)
{
  for(int R=0;R<N;R++)
    for(int C=0;C<M;C++)
      C[R][C]=A[R][C]+B[R][C];
}

Function to multiply two dimensional arrays A and B of order NxL and LxM

void Multiply(int A[][20], int B[][20], int C[][20],int N, int L, int M)
{
  for(int R=0;R<N;R++)
   for(int C=0;C<M;C++)
   {
      C[R][C]=0;
      for(int T=0;T<L;T++)
        C[R][C]+=A[R][T]*B[T][C];
    }
}

Function to find & display sum of rows & sum of cols. of a 2 dim. array A

void SumRowCol(int A[][20], int N, int M)
{
  for(int R=0;R<N;R++)
  {
     int SumR=0;
     for(int C=0;C<M;C++)
       SumR+=A[R][C];
     cout<<"Row("<<R<<")="<<SumR<<endl;
   }
  for(int R=0;R<N;R++)
  {
    int SumR=0;
    for(int C=0;C<M;C++)
      SumR+=A[R][C];
    cout<<"Row("<<R<<")="<<SumR<<endl;
   }
}

Function to find sum of diagonal elements of a square matrix A

void Diagonal(int A[][20], int N, int &Rdiag, int &LDiag)
{
  for(int I=0,Rdiag=0;I<N;I++)
    Rdiag+=A[I][I];
  for(int I=0,Ldiag=0;I<N;I++)
    Ldiag+=A[N-I-1][I];
}

Function to find out transpose of a two dimensional array A

void Transpose(int A[][20], int B[][20],int N, int M)
{
  for(int R=0;R<N;R++)
    for(int C=0;C<M;C++)
       B[R][C]=A[C][R];
}

STRINGS

2011-10-09T08:29:00.000-07:00

STRING

Declaration, Initializing, Reading strings, Printing strings, cin, gets(), cout, puts() counting number of characters in string, count number of words, length of string, copy contents of string, concatenate, compare string

STRING: It is an array of type char.

Syntax for declaration

char <array/string name> [max. number of characters to be stored +1];

The number of elements that can be stored in a string is always n-1, if the size of the array specified is n. This is because 1 byte is reserved for the NULL character '\0' i.e. backslash zero. A string is always terminated with the NULL character.

Example:
char str[80];
In the above example, str can be used to store a string with 79 characters.

Initializing a string

A string can be initialized to a constant value when it is declared.

char str[ ] = "Good";
Or
char str[]={'G','o','o','d','\0'};

Here. 'G' will be stored in str[0], 'o' in str[1] and so on.

Note: When the value is assigned to the complete string at once, the computer automatically inserts the NULL character at the end of the string. But, if it is done character by character, then we have to insert it at the end of the string.

Reading strings with/without embedded blanks

To read a string without blanks cin can be used, and to read a string with blanks gets() can be used.

cin>>str ;
Or
gets(str);

Printing strings

cout and puts() can be used to print a string.

cout<<str:
Or
puts(str);

Note: For gets( ) and puts(), the header file stdio.h has to be included. puts() can be used to display only strings. It takes a line feed after printing the string.

cin	gets()
It can be used to take input of a value of any data type.	It can be used to take input of a string.
It takes the white space i.e. a blank, a tab, or a new line character as a string terminator.	It does not take the white space i.e. a blank, a tab, or a new line character, as a string terminator.
It requires header file iostream.h	It requires the header file stdio.h
Example: char S[80]; cout<<"Enter a string:”; cin>>S;	Example: char S[80]; cout<<"Enter a string:"; gets(S);

cout	puts()
It can be used to display the value of any data type.	It can be used to display the value of a string.
It does not take a line feed after displaying the string.	It takes a line feed after displaying the string.
It requires the header file iostream.h	It requires the header file stdio.h
Example: char S[80]="Computers"; cout<<S<<S; Output: ComputersComputers	Example: char S[80]="Computers"; puts(S); puts(S); Output: Computers Computers

Counting the number of characters in a string and printing it backwards

#include<iostream.h>
#include<conio.h>
#include<stdio.h>

void main( )
{
            clrscr( );
            char str[80];
            cout<<"Enter a string:";
            gets(str);
            for(int l=0; str[l]!='\0';l++);    //Loop to find the length of the string
                        cout<<"The length of the string is : "<<l<<endl ;
            for(int i=l-1;i>=0;i--)            //Loop to display the string backwards
                        cout<<str[i];
            getch();
}

Function to count the number of words in a string

void count(char S[])
{
            int words=0;
            for(int i=0;S[i]!='\0';i++)
            {
                        if (S[i]==' ')
                                    words++;                   //Checking for spaces
            }
            cout<<"The number of words="<<words+1<<endl;
}

Function to find the length of a string

int length(char S[ ])
{
for(int i=0;S[i]!='\0';i++);
return i;
}

Function to copy the contents of string S2 to S1

void copy(char S1[ ], char S2[ ])
{
            for(int i=0;S2[i]!='\0';i++)
                        S1[i]=S2[i];
            S1[i]='\0';
}

Function to concatenate the contents of string S2 to S1

void concat(char S1[ ], char S2[ ])
{
            for(int l=0;S1[l]!='\0';l++);
            for(int i=0;S2[i]!='\0';i++)
                    S1[l++]=S2[i];
            S1[l]='\0';
}

Function to compare strings STR1 to STR2. The function returns a value>0 if //STR1>STR2, a value<0 if STR1<STR2, and value 0 if STR1=STR2

int compare(char STR1[ ],char STR2[])
{
for (int I=0; STR1[I]==STR2[I] && STR1[I]!= '\0' && STR2[I] != '\0'; I++);
return STR1[I]-STR2[I];
}

To reverse the contents of string S and store it in string Rev

void Reverse(char S[], char Rev[])
{
            for(int C1=0; S[C1]!='\0'; C1++);
            C1--;
            for(int C2=0;C1>=0;C2++,C1--)
                        Rev[C2]=S[C1];
            Rev[C2]='\0';
}

Function to check whether a string S is a palindrome or not

int Palin(char S[])
{
            for(int L=0;S[L]!='\0';L++);    //To find length of the string
            for(int C=0;(C<L/2) && (S[C]==S[L-C-1]);C++);
            return (C==L/2)?1:0;            //Returns 1 if Palindrome else 0
}

Function to change the case of string S to uppercase

void Upper(char S[])
{
for(int i=0;S[i]!='\0';i++)
S[i] = (S[i]>='a' && S[i]<='z')?(S[i]-32):S[i];
}

Function to change the case of string S to lower case

void Lower(char S[])
{
for(int i=0;S[i]!='\0';i++)
S[i] = (S[i]>='A' && S[i]<='Z')?(S[i]+32):S[i];
}

Function to extract n characters from left side of the string and store it in a different string. Example: 4 characters from ENVIRONMENT=ENVI

int SLeft(char S[ ], int n, char result[ ])
{
           for(int l=0;S[l]!='\0';l++);
           if(n<=I)                       //characters extracted should be <=length
           {
                      for(int i=0;i<n;i++)
                                  result[i]=S[i];
                       result[i]='\0';
                       return 1;
            }
            else
                       return 0;
}

Function to extract n characters from right side of the string and store it in a different string. Example: 4 characters from ENVIRONMENT=MENT

int SRight(char S[ ], int n, char result[ ])
{
            for(int l=0;S[l]!='\0';l++);
            if(n<=I)                       //characters extracted should be <=length
           {
                       for(int j=0;i=l-n;S[i]!=’/0’;i++,j++)
                                   result[j]=S[i];
                       result[j]='\0';
                       return 1;
          }
           else
                       return 0;
}

Function to extract n characters from specified location loc of the string and store it in a different string. Example: 4 characters from third location in string ENVIRONMENT= VIRO

int substring(char S[ ], int n, int loc, char result[ ])
{
            for(int l=0;S[l]!='\0';l++);
            if(n<=I)                       //characters extracted should be <=length
            {
                       for(int j=0;i=l-n;S[i]!=’/0’;i++,j++)
                                   result[j]=S[i];
                       result[j]='\0';
                       return 1;
            }
            else
                       return 0;
}

C++ Tutorials

Introduction To Programming CS201 Lecture_08

Introduction To Programming Lecture-08

Introduction To Programming CS201 Lecture_07

Introduction To Programming Lecture-07

Introduction To Programming CS201 Lecture_06

Introduction To Programming Lecture-06

Introduction To Programming CS201_Lecture-05

Introduction To Programming Lecture-05

Introduction To Programming CS201_Lecture-04

Introduction To Programming Lecture-04

Introduction To Programming CS201_Lecture-03

Introduction To Programming Lecture-03

Introduction To Programming CS201 Lecture-02

Introduction To Programming Lecture-02

Introduction To Programming CS201_Lecture01

Introduction To Programming Lecture-01

ROBERT LAFORE-OBJECT ORIENTED PROGRAMMING IN C++

RAILWAY SEAT RESERVATION PROJECT

RAILWAY SEAT RESERVATION PROJECT Description: This C++ program on RAILWAY SEAT RESERVATION is a simple text base program.We have used procedure oriented method to design this program. This program is without grahics to keep program simple for beginners.

RAILWAY SEAT RESERVATION PROJECT

MS Visual C++ 6.0 (standard version)

DYNAMIC QUEUE

DYNAMIC QUEUE

DYNAMIC STACK

DYNAMIC STACK

CIRCULAR QUEUE

CIRCULAR QUEUE

STATIC STACK

STATIC STACK

POINTER

POINTER

C++ Memory Map

Accessing address of a variable

POINTER

Pointer Arithmetic

Pointers and Arrays

Character Pointers and Strings

Pointers as Function Parameters

Pointers to Structures

Static allocation of memory

Dynamic allocation of memory

Free store

Dynamic Memory Allocation

Releasing Dynamic Memory

Memory Leak

Self Referential Structure

TEXT & BINARY FILE

TEXT & BINARY FILE

Program to write in a text file

Program to read from text file and display it

Program to count number of characters.

Program to count number of words

Program to count number of lines

Program to copy contents of file to another file.

BASIC OPERATION ON BINARY FILE IN C++

function to write in a binary file

function to display records of file

Function to search and display from binary file

Function to delete a record

Function to modify a record

DATA FILE HANDLING

DATA FILE HANDLING

Classes for file stream operation

Opening a file

CLOSING FILE

INPUT AND OUTPUT OPERATION

ERROR HANDLING FUNCTION

FILE POINTERS AND THEIR MANIPULATION

INHERITANCE

INHERITANCE

FORMS OF INHERITANCE

Execution of base class constructor

Overriding of method(function) in inheritance

Virtual Base Class

CONSTRUCTOR

CONSTRUCTOR

CONSTURCTOR

Types of Constructor

DESTRUCTOR

RAILWAY SEAT RESERVATION PROJECT

Description: This C++ program on RAILWAY SEAT RESERVATION is a simple text base program.We have used procedure oriented method to design this program. This program is without grahics to keep program simple for beginners.