cannot write to output file

[scu1casper]

#include <iostream>
#include <fstream>
#include <iomanip>
#include <string>
using namespace std;

// global constants
const int MAX_CUSTOMERS = 1000;

// function prototypes
bool OpenAndValidateInputFile (ifstream& textIn);
void ReadAndStoreInputFile (ifstream& textIn, string Customer[], double Charge[], int& counter, string customerCode, double utilityCharge);
void SelectionSort (string Customer[], double Charge [], int counter);
bool OpenAndValidateOutputFile (ofstream& textOut);
void WriteToSortedFile (ofstream& textOut, string customerCode, double utilityCharge);

//********************************************************************* 
//  FUNCTION: main
//  DESCRIPTION: XXXX
//  INPUT: 
//      Parameters: XXXX
//      File: XXXX
//  OUTPUT:  
//      Return Val: XXXX
//      Parameters: XXXX
//      File: XXXX
//  CALLS TO: XXXX
//**********************************************************************
int main()
{
	// local variables
	ifstream textIn;														// input file stream variable
	ofstream textOut;
	string Customer [MAX_CUSTOMERS];
	double Charge [MAX_CUSTOMERS];
	int counter = 0;
	string customerCode;													// customer ID code - unique 4 capital letters followed by 4 digits
	double utilityCharge = 0;												// utility charge per unit

	if (OpenAndValidateInputFile (textIn) && OpenAndValidateOutputFile (textOut))
	{
		ReadAndStoreInputFile (textIn, Customer, Charge, counter, customerCode, utilityCharge);

		SelectionSort (Customer, Charge, counter);

		OpenAndValidateOutputFile (textOut);

		WriteToSortedFile (textOut, customerCode, utilityCharge);

		cout << Customer[0] << endl;
		cout << Customer[1] << endl;
		cout << Customer[2] << endl;
		cout << Customer[3] << endl;
		
		cout << Charge[0] << endl;
		cout << Charge[1] << endl;
		cout << Charge[2] << endl;
		cout << Charge[3] << endl;

		system ("PAUSE");
		return 0;
	}
	else
	{
		return 1;
	}

	// CLOSE FILE!!!!!!
}

//********************************************************************* 
//  FUNCTION: OpenAndValidateInputFile
//  DESCRIPTION: Function opens data file CUSTOMERS.TXT and validates that
//               it can be open.  If succesful, function returns true.
//				 If unsuccessful, function returns false in order to
//				 exit program from main with a return code 1.
//  INPUT: 
//      Parameters: textIn - CUSTOMERS.TXT file
//      File: None
//  OUTPUT:  
//      Return Val: None
//      Parameters: None
//      File: None
//  CALLS TO: main function calls OpenAndValidateInputFile
//**********************************************************************
bool OpenAndValidateInputFile (ifstream& textIn)
{
    // open input file
    textIn.open ("CUSTOMERS.TXT");

	// check if file opens successfully
	// if not, print a warning and exit program from main with a return code 1
	if (!textIn.is_open ())
	{
		return false;
	}
	else
	{
		return true;
	}
}// end OpenAndValidateInputFile

//********************************************************************* 
//  FUNCTION: ReadAndStoreInputFile
//  DESCRIPTION: Function reads data from CUSTOMERS.TXT and stores data
//				 appropriately according to customerCode and utilityCharge
//				 in parallel arrays Customer[] and Charge[]
//  INPUT: 
//      Parameters: textIn - CUSTOMERS.TXT file
//      File: None
//  OUTPUT:  
//      Return Val: None
//      Parameters: Customer[] - array for stored customer codes
//					Charge[] - array for stored utility charges
//      File: None
//  CALLS TO: main function calls ReadAndStoreInputFile
//**********************************************************************
void ReadAndStoreInputFile (ifstream& textIn, string Customer[], double Charge[], int& counter, string customerCode, double utilityCharge)
{
	// while file is still readable, and peek does not find end-of-file
	while (textIn.good () && textIn.peek () != EOF)
	{
		// read in data from CUSTOMERS.TXT
		textIn >> customerCode;
		textIn >> utilityCharge;

		// if the file contains too many lines of data, stop reading data and issue warning
		if (counter >= MAX_CUSTOMERS)
		{
			cout << "Error: file contains too many lines of data" << endl;
		}
		else
		{
			Customer [counter] = customerCode;

			Charge [counter] = utilityCharge;

			counter++;
		}
			
		// read newline
		textIn.get ();
	}
}// end ReadAndStoreInputFile

//********************************************************************* 
//  FUNCTION: SelectionSort
//  DESCRIPTION: Function sorts Customer [] in descending order based on
//				 customer code (Z -> A) and aligns parallel arrays. 
//  INPUT: 
//      Parameters: XXXX
//      File: XXXX
//  OUTPUT:  
//      Return Val: XXXX
//      Parameters: XXXX
//      File: XXXX
//  CALLS TO: main function calls SelectionSort
//**********************************************************************
void SelectionSort (string Customer [], double Charge [], int counter)
{
	// local variables
	int i;																	// integer place holder i
	int j;																	// integer place holder j
	int max;																// place holder for highest letter found for sort

	// setting parameter for i
	for (i = 0; i < counter - 1; i++)
	{
		max = i;

		// setting parameter for j
		for (j = i + 1; j < counter; j++)
		{
			// searching through array, and replacing lower value higher value if found
			if (Customer [j] > Customer [max])
			{
				max = j;

				string tempString = Customer[i];
				Customer[i] = Customer[j];
				Customer[j] = tempString;

				// aligning Charge [] with Customer []
				double tempDouble = Charge[i];
				Charge[i] = Charge[j];
				Charge[j] = tempDouble;
			}
		}
	}
} // end SelectionSort

//********************************************************************* 
//  FUNCTION: OpenAndValidateOutputFile
//  DESCRIPTION: Function opens output data file SORTED.TXT and validates
//				 that it can be open.  If succesful, function returns true.
//				 If unsuccessful, function returns false in order to
//				 exit program from main with a return code 1.
//  INPUT: 
//      Parameters: textOut - SORTED.TXT file
//      File: None
//  OUTPUT:  
//      Return Val: None
//      Parameters: None
//      File: None
//  CALLS TO: main function calls OpenAndValidateOutputFile
//**********************************************************************
bool OpenAndValidateOutputFile (ofstream& textOut)
{
    // open input file
    textOut.open ("SORTED.TXT");

	// check if file opens successfully
	// if not, print a warning and exit program from main with a return code 1
	if (!textOut.is_open ())
	{
		return false;
	}
	else
	{
		return true;
	}
}// end OpenAndValidateOutputFile

//********************************************************************* 
//  FUNCTION: WriteToSortedFile
//  DESCRIPTION: XXXX
//  INPUT: 
//      Parameters: XXXX
//      File: None
//  OUTPUT:  
//      Return Val: None
//      Parameters: XXXX
//      File: None
//  CALLS TO: main function calls WriteToSortedFile
//**********************************************************************
void WriteToSortedFile (ofstream& textOut, string customerCode, double utilityCharge)
{
    textOut << customerCode << endl;
}// end WriteToSortedFile 

I am not sure why, but I nothing is being written to my output file "SORTED.TXT" Any ideas??

[o3hC5Di1]

Hi there,

Not entirely sure why - can't test it without the input file.
Try adding std::cin statements like so:

bool OpenAndValidateOutputFile (ofstream& textOut)
{
    // open input file
    textOut.open ("SORTED.TXT");

	// check if file opens successfully
	// if not, print a warning and exit program from main with a return code 1
	if (!textOut.is_open ())
	{
		std::cin << "file not opened";
               return false;
	}
	else
	{
		std::cin << "file opened";
		return true;
	}
}// end OpenAndValidateOutputFile 

That allows you to see what happens when.
Or run a debugger step by step to see every action and state of the variables.

Hope that helps.

All the best,
NwN