============================MODULE19=======================================
|                                                                         |
|  The program examples' source codes have been arranged in the same      |
|  order that appeared in the Tutorial. This is unedited and unverified   |
|  compilation. Published as is basis for educational, reacretional and   |
|  brain teaser purposes. All trademarks, copyrights and IPs, wherever    |
|  exist, are the sole property of their respective owner and/or          |
|  holder. Any damage or loss by using the materials presented in this    |
|  tutorial is USER responsibility. Part or full distribution,            |
|  reproduction and modification is granted to any body.                  |
|     Copyright 2003-2005 © Tenouk, Inc. All rights reserved.		  |
|          Distributed through http://www.tenouk.com			        |
|        		                                                        |
|									                    |
===========================================================================
Originally programs compiled using Borland C++. Examples compiled using
VC++/VC++ .Net and gcc or g++ are given at the end of every Module.
For example if you want to compile C++ codes using VC++/VC++ .Net, change
the header file accordingly.  Just need some modification for the header
files...:

-------------------------------------------------
#include <iostream.h>
//for system()
#include <stdlib.h>

...
{
C++ codes...
}
-------------------------------------------------
should be changed to:
-------------------------------------------------
#include <iostream>
//use C++ wrapper to call C functions from C++ programs...
#include <cstdlib>
using namespace std;

...
{
C++ codes...
}
-------------------------------------------------
In VC++/VC++ .Net the iostream.h (header with .h) is not valid anymore.
It should be C++ header, <iostream> so that it comply to the standard.
In older Borland C++ compiler this still works, but not proper any more...
and for standard C/C++ the portability should be no problem or better
you read Module23 at http://www.tenouk.com/Module23.html to get
the big picture...For C codes, they still C codes :o)
=========================================================================
=========================================================================



---------------------------sampleread.txt-----------------------------
This is file sampleread.txt.   This file will be opened for reading
then its content will be written to another file and standard output
i.e screen/console...after you have executed this C++ program,
without error....this text should be output on your screen as well as
written to the samplewrite.txt file.  Don't forget to check the 
content of the samplewrite.txt.

--------------------------------------------------------------------------------------------

//Reading from available file content
//then writing the content to another
//file.  Firstly, create file for reading (can include path)
//let says "C:\sampleread.txt", at root on C drive.
//Type some text as shown…
//Then executes this program. For VC++/VC++ .Net or other C++ standard compliance compiler
//change the header files accordingly...

//#include <iostream>
//#include <fstream>
//#include <cstdlib>
//using namespace std;

#include <iostream.h>
#include <fstream.h>
#include <stdlib.h>

//function definition, to open file for reading...
void openinfile(ifstream &infile)
{
	char filename[100];
	cout<<"Enter the file name: ";
	//Enter the filename that you have created
	//(can include path). From the comment above
	//you have to enter "C:\sampleread.txt"
	//without the double quotes.

	cin>>filename;
	infile.open(filename);
}

void main(void)
{
	//declare the input file stream
	ifstream inputfile;
	//declare the output file stream
	ofstream outputfile;

	char chs;

	//function call for opening file for reading...
	openinfile(inputfile);
	//create, if not exist and open it for writing
	outputfile.open("C:\\samplewrite.txt");

	//test until the end of file
	while (!inputfile.eof())
	{
   		//read character until end of file
		inputfile.get(chs);
		if (!inputfile.eof())
		{
      		//output character by character (byte) on screen, standard output
		cout<<chs;
      		//write to output file, samplewrite.txt
      		outputfile<<chs;
    		}
	}
	cout<<"\nReading and writing file is completed!"<<endl;
	system("pause");
	//close the input file stream
	inputfile.close();
	//close the output file stream
	outputfile.close();
}

---------------------------------------------------------------------------------------
-------------------------readfile.txt---------------------

This is readfile.txt.  Just sample text, opening 
for reading by using getline() member function.  
There are four lines of text to be read from.  
This is just plain simple reading text from a file.

---------------------------------------------------------------------------------------

//using getline() member function
#include <iostream.h>
#include <fstream.h>
#include <stdlib.h>

void main(void)
{
	char filename[50];
	ifstream inputfile;
	char FirstLine[50];
	char SecondLine[50];
	char ThirdLine[50];

	//prompt user for file name to be opened...
	cout<<"Enter the filename to be opened: ";
	cin>>filename;

	//test open file for reading...
	inputfile.open(filename);
	//if not the end of file, do...
	if(!inputfile.eof())
	{
		cout<<"\nThe first line of text is: \n";
		inputfile.getline(FirstLine, 50);
		cout<<FirstLine<<'\n';
		cout<<"The second line of text is: \n";
		inputfile.getline(SecondLine, 50);
		cout<<SecondLine<<endl;
		cout<<"The third line of text is: \n";
		inputfile.getline(ThirdLine, 50);
		cout<<ThirdLine<<endl;
	}

system("pause");
}

---------------------------------------------------------------------------------------

//Simple file ‘exception handling’ when
//opening file for reading.
//There is no testfileio.txt at the root of
//drive C at the beginning.
 #include <iostream.h>
 #include <fstream.h>
 #include <stdlib.h>

 void main(void)
 {
 	char filename[] = "C:\\testfileio.txt";
 	ifstream inputfile;

 	inputfile.open(filename, ios::in);
	//test if fail to open fail for reading, do…
 	if(inputfile.fail())
 	{
 		cout<<"Opening "<<filename<<" file for reading\n";
 		cout<<"---------------------------------------\n";
 		cout<<"The "<<filename<<" file could not be opened!\n";
 		cout<<"Possible errors:\n";
 		cout<<"1.  The file does not exist.\n";
 		cout<<"2.  The path was not found.\n";
      		system("pause");
	 	exit(1);   //just exit
 		//0-normal, non zero - some error
 	}
 	//if successful opening file for reading, do…
	else
 	{
 		cout<<"The "<<filename<<" file was opened successfully!\n";
 		cout<<"\nDo some file processing here...\n";
 	}
 	inputfile.close();
	
	//test if fail to close the file, do…
 	if(inputfile.fail())
   	{
 		cout<<"\nThe file "<<filename<<" could not be closed!\n";
         	system("pause");
   		exit(1);
   	}
 	//else, do…
	else
 	cout<<"\nThe "<<filename<<" file was closed successfully!\n";
 	system("pause");
}

-------------------------------------------------------------------------------------------

 //Prompting user for filename
 //to be opened….others should be
 //same as the previous example.
 #include <iostream.h>
 #include <fstream.h>
 #include <stdlib.h>

 void main(void)
 {
 	char filename[100];
 	ifstream inputfile;

//Prompting user for filename to be opened…
//including the full path if necessary…
//e.g. c:\testfileio.txt, c:\Windows\Temp\testfile.txt etc
  cout<<"Enter the file name to be opened: ";
  
	  //store at an array filename...
  //Array without [] is a pointer to the
  //first array’s element...
  cin>>filename;
 
   //opened the file for input...
   inputfile.open(filename, ios::in);

		//test if fail to open file for reading, do…
 	if(inputfile.fail())
 	{
 		cout<<"Opening "<<filename<<" file for reading\n";
 		cout<<"---------------------------------------\n";
 		cout<<"The "<<filename<<" file could not be opened!\n";
 		cout<<"Possible errors:\n";
 		cout<<"1.  The file does not exist.\n";
 		cout<<"2.  The path was not found.\n";
      		system("pause");
	 		exit(1);   //just exit
 		//0-normal, non zero - some error
 	}
 	//if successful opening file for reading, do…
		else
 	{
 		cout<<"The "<<filename<<" file was opened successfully!\n";
 		cout<<"\nDo some file processing here...\n";
 	}
 	//close file for input…
		inputfile.close();
	
		//test if fail to close the file, do…
 	if(inputfile.fail())
   	{
 		cout<<"\nThe file "<<filename<<" could not be closed!\n";
           	system("pause");
   		exit(1);
   	}
 	//else, do…
		else
 	cout<<"\nThe "<<filename<<" file was closed successfully!\n";
system("pause");
}
//tested using the win32 console mode........
//provided the file testfileio.txt exists on the C: drive…

--------------------------------------------------------------------------------------

------------testfileio1.txt------------
100.23  56.33  67.12 89.10 55.45
23.12  56.11  43.24  65.32  45.00

--------------------------------------------------------------------------------------

 //Simple processing data from external file.
 //Read the data in sequential mode, do some
 //calculation and display to the standard output.
 //Create file testfileio1.txt on drive C, and
 //type some data as shown
 #include <iostream.h>
 #include <fstream.h>
 #include <stdlib.h>

 void main(void)
 {
 	char filename[] = "C:\\testfileio1.txt";
 	ifstream inputfile;

 	//-------opening input file for reading--------
 	inputfile.open(filename, ios::in);
 	//test if fail to open the file, do…
        //error handling for file opening
 	if(inputfile.fail())
  	{
 		cout<<"Opening file "<<filename<<" for reading\n";
 		cout<<"------------------------------------------\n";
 		cout<<"The file could not be opened!\n";
 		cout<<"Possible errors:\n";
 		cout<<"1.  The file does not exist.\n";
 		cout<<"2.  The path was not found.\n";
 		system("pause");
 		exit(1);   //just exit
 		//0-normal, non zero - some error
 	}
        //if successful, do the following...
 	else
 	{
 	cout<<"The "<<filename<<" file was opened successfully!\n";

      		//declare some variables for simple calculation
		float  price, total = 0;
		int count = 0;

		cout<<"Reading data and do some calculation\n\n";
      		//read data from input stream...
		inputfile>>price;

      		//test, if end of file not found, do the following...
		while(!inputfile.eof())
		{
			//total = total + price
			total += price;
			count++;
			cout<<"Item price # "<<count<<" is "<<price<<endl;
         		//re read the next item price within the loop
			inputfile>>price;
		}
		cout<<"The total price for "<<count<<" items is: "<<total<<endl;
		cout<<"\n-------DONE-------\n"<<endl;
  	//close the input file
 	inputfile.close();
  	
		//test closing file, if fail to close the file, do...
   	//error handling for file closing
 	if(inputfile.fail())
   	{
 		cout<<"The "<<filename<<" file could not be closed!\n";
   		system("pause");
                //something wrong, just exit...
   		exit(1);
   	}
   	
	//if successful closes the file, do....
 	else
 	  cout<<"The "<<filename<<" file was closed successfully!\n";

	system("pause");
 	}
 }

------------------------------------------------------------------------------------------------

----------testfileio2.txt---------------

Writing some data in this file
------------------------------
0  1  2  3  4  5  6  7  8  9  10  

------------------------------------------------------------------------------------------------

//Simple processing data from external file.
//Creating, opening and writing some data in file
//and appending data at the end of file...
#include <iostream.h>
#include <fstream.h>
#include <stdlib.h>

void main(void)
{
	char filename[] = "C:\\testfileio2.txt";
	ofstream outputfile;

	//----creating, opening and writing/appending data to file-----
	outputfile.open(filename, ios::out|ios::app);
	//simple error handling for file creating/opening for writing
	//test if fail to open the file, do…
	if(outputfile.fail())
	{
		cout<<"Creating and opening file "<<filename<<" for writing\n";
		cout<<"------------------------------------------\n";
		cout<<"The "<<filename<<" file could not be created/opened!\n";
		cout<<"Possible errors:\n";
		cout<<"1.  The file does not exist.\n";
		cout<<"2.  The path was not found.\n";
		system("pause");
		exit(1);   //just exit
		//0-normal, non zero - some error
	}
	//else, if the file can be opened, do…
	else
	{
		cout<<"The "<<filename<<" file was created and opened successfully!\n";
		cout<<"\nDo some file writing....\n\n";

		outputfile<<"Writing some data in this file\n";
		outputfile<<"------------------------------\n";
		cout<<"Check the "<<filename<<" file contents :-)"<<endl;
		cout<<"If the file already have had data, the new data will be appended\n";

		int sampledata;
		//write some integers to the file...
		for(sampledata=0; sampledata<=10; sampledata++)
		outputfile<<sampledata<<"  ";
		outputfile<<endl;
		//close the output file
		outputfile.close();
		//test if fail to close the file, do the following...
		//simple error handling for output files closing
		if(outputfile.fail())
		{
			cout<<"The "<<filename<<" file could not be closed!\n";
			system("pause");
			exit(1);
		}
		//test if successful to close the file, do the following...
		else
		cout<<"\nThe "<<filename<<" file was closed successfully!\n";

	system("pause");
	}
}

---------------------------------------------------------------------------------------------------

//using seekg()
#include <iostream.h>
#include <fstream.h>
#include <stdlib.h>

void main(void)
{
 	char filename[] = "C:\\testfileio3.txt";
 	fstream inputfile, outputfile;

 	//--------create, open and write data to file--------
 	outputfile.open(filename, ios::out);
 	//----write some text-------
 	outputfile<<"This is just line of text."<<endl;
 	//--------close the output file------------
 	outputfile.close();

 	//----opening and reading data from file-----
 	inputfile.open(filename, ios::in);
 	//simple error handling for files creating/opening for writing
 	if(inputfile.fail())
  	{
 		cout<<"Opening "<<filename<<" file for reading\n";
 		cout<<"------------------------------------------\n";
 		cerr<<"The file "<<filename<<" could not be created/opened!\n";
 		cerr<<"Possible errors:\n";
 		cerr<<"1.  The file does not exist.\n";
 		cerr<<"2.  The path was not found.\n";
 		system("pause");
 		exit(1);   //just exit
 		//0-normal, non zero - some error
 	}
 	else
 	{

      		cout<<"The "<<filename<<" file was opened successfully!\n";
      		cout<<"\nMove the pointer to the end\n"
      			<<"Then back to the beginning with\n"
            		<<"10 offset.  The pointer now at...\n"<<endl;
         	//flush the stream buffer explicitly...
        	cout<<flush;
	    	
		//get length of file
       		int length;
       		char * buffer;

      		//move the get pointer to the end of the stream
      		inputfile.seekg(0, ios::end);
		//The tellg() member function returns
      		//the current stream position.
      		//there is 27 characters including white space
      		length = inputfile.tellg();
      		//move back the pointer to the beginning with
      		//offset of 10
      		inputfile.seekg(10, ios::beg);

      		//dynamically allocate some memory storage
            	//for type char...
      		buffer = new char [length];

      		//read data as block from input file...
		inputfile.read(buffer, length);
      		cout<<buffer<<endl;
            	//free up the allocated memory storage...
      		delete[] buffer;
   		//close the input file
 		inputfile.close();
   		//simple error handling for output files closing
         	//test if fail to close the file, do...
 		if(inputfile.fail())
   		{
 			cerr<<"The "<<filename<<" file could not be closed!\n";
   			system("pause");
   			exit(1);
   		}
      		//test if successful to close the file, do...
 		else
 		cout<<"\nThe file "<<filename<<" was closed successfully!\n";

	system("pause");
 		}
 	}

--------------------------------------------------------------------------------------------------

//using seekp()
#include <iostream.h>
#include <fstream.h>
#include <stdlib.h>

void main(void)
{
	char filename[] = "C:\\testfileio4.txt";
	ofstream outputfile;

	//----creating, opening and writing data to file-----
	outputfile.open(filename, ios::out);
	//simple error handling for file creating/opening
	//test if fail to open, do...
	if(outputfile.fail())
  	{
 		cout<<"Creating and opening "<<filename<<" file for writing\n";
		cout<<"----------------------------------------------------\n";
		cout<<"The "<<filename<<" file could not be created/opened!\n";
 		cout<<"Possible errors:\n";
 		cout<<"1.  The file does not exist.\n";
 		cout<<"2.  The path was not found.\n";
 		system("pause");
 		exit(1);   //just exit
 		//0-normal, non zero - some error
 	}
 	//test if successful creating/opening the file, do...
 	else
 	{
 		cout<<"The "<<filename<<" file was created and opened successfully!\n";
   		cout<<"\nDo some file writing....\n\n";

        	int locate;

		outputfile.write("Testing: Just simple example.", 29);
      	//tell the pointer position...
      	locate = outputfile.tellp();
      	//seek the pointer position with offset...
      	outputfile.seekp(locate-16);
      	outputfile.write(" rumble", 7);
      	//close the output file
 	outputfile.close();
   	//simple error handling for output files closing
    	//test if fail to close the file, do...
 	if(outputfile.fail())
   	{
 		cout<<"The "<<filename<<" file could not be closed!\n";
   		system("pause");
   		exit(1);
   	}
   	//if successful to close the file, do...
 	else
 	cout<<"\nThe "<<filename<<" file was closed successfully!\n";

system("pause");
 	}

 }

---------------------------------------------------------------------------------------------------

//istream ignore()
#include <iostream>
#include <stdlib.h>

int main ()
{
  char firstword, secondword;

  cout<<"Enter your first and last names: ";

  firstword = cin.get();
  cin.ignore(30,' ');
  secondword = cin.get();

  cout<<"The initials letters are: "<<firstword<<secondword<<endl;

  system("pause");
  return 0;
}

------------------------------------------------VC++/VC++ .Net-------------------------------------------------

//Reading from available file content
//then writing the content to another
//file.  Firstly, create file for reading (can include path)
//let says "C:\sampleread.txt", at root on C drive.
//Type some text as shown…
//Then executes this program.
#include <iostream>
#include <fstream>
using namespace std;

//function definition, to open file for reading...
void openinfile(ifstream &infile)
{
	char filename[100];
	cout<<"Enter the file name: ";
	//Enter the filename that you have created
	//(can include path). From the comment above
	//you have to enter "C:\sampleread.txt"
	//without the double quotes.

	cin>>filename;
	infile.open(filename);
}

void main(void)
{
	//declare the input file stream
	ifstream inputfile;
	//declare the output file stream
	ofstream outputfile;

	char chs;

	//function call for opening file for reading...
	openinfile(inputfile);
	//create, if does not exist and open it for writing
	outputfile.open("C:\\samplewrite.txt");

	//test until the end of file
	while (!inputfile.eof())
	{
   		//read character until end of file
		inputfile.get(chs);
		if (!inputfile.eof())
		{
      	//output character by character (byte) on screen, standard output
		cout<<chs;
      	//write to output file, samplewrite.txt
      	outputfile<<chs;
    		}
	}
	cout<<"\nReading and writing file is completed!"<<endl;
	//close the input file stream
	inputfile.close();
	//close the output file stream
	outputfile.close();
}

-----------------------------------------------G++-------------------------------------------------------

//Simple processing data from external file.
//Read the data in sequential mode, do some
//calculation and display to the standard output.
//Create file testfileio.txt in the current
//working directory and type some int data in it...
#include <iostream>
#include <fstream>
using namespace std;

int main(void)
{
        char filename[] = "testfileio.txt";
        ifstream inputfile;

        //-------opening input file for reading--------
        inputfile.open(filename, ios::in);
        //test if fail to open the file, do...
        //error handling for file opening
        if(inputfile.fail())
        {
                cout<<"Opening file "<<filename<<" for reading\n";
                cout<<"------------------------------------------\n";
                cout<<"The file could not be opened!\n";
                cout<<"Possible errors:\n";
                cout<<"1.  The file does not exist.\n";
                cout<<"2.  The path was not found.\n";
                exit(1);   //just exit
                //0-normal, non zero - some error
        }
        //if successful, do the following...
        else
        {
        cout<<"The "<<filename<<" file was opened successfully!\n";

        //declare some variables for simple calculation
        float price, total = 0;
        int count = 0;
        cout<<"Reading data and do some calculation\n\n";
        //read data from input stream...
        inputfile>>price;

        //test, if end of file not found, do the following...
        while(!inputfile.eof())
        {
               //total = total + price
               total += price;
               count++;
        	cout<<"Item price # "<<count<<" is "<<price<<endl;
        	//re read the next item price within the loop
        	inputfile>>price;
        }
        cout<<"The total price for "<<count<<" items is: "<<total<<endl;
        cout<<"\n-------DONE-------\n"<<endl;
        //close the input file
        inputfile.close();

        //test closing file, if fail to close the file, do
        //simple error handling for file closing
        if(inputfile.fail())
        {
        cout<<"The "<<filename<<" couldn't be closed!\n";
        exit(1);
        }

        //if fail, do....
        else
        cout<<"The "<<filename<<" file closed successfully!\n";
        return 0;
        }
}

==============================================================================================