Problem with I/O program

[nj1995]

When I compile and run my program after I input my file names, the names fail the if(fin.fail()) and if(fout.fail()) statements and I am unsure why this is.

#include <iostream>
#include <fstream>	// for ifstream and ofstream classes
#include <cassert>	// for assert() macro
#include <cstdlib>	// for exit()
#include <cmath>
using namespace std;

class rational
{
	friend istream& operator>>(istream&, rational&);
	// User is prompted to enter values for numerator then denominator of a rational number
	//  Precondition: denominator of rational number must not be zero
	// Postcondition: reference rational object passed to the function is filled with values entered by user

	friend ostream& operator<<(ostream&, rational&);
	// Postcondition: displays the contents of the rational object passed to the function 
	//  Must be displayed in the format of  a / b, e.g., 1 / 2,  -5 /9 (not 5 / -9), 1 / 4 (not 2 / 8), etc.
	//  Moreover, if the rational number is 1, display just 1 (not 1 / 1 or 5 / 5, etc.). If the rational number is 0 / 5, etc., display just 0.

public:
	rational();
	// default constructor
	// Postcondition: declared rational object is initialized to 1 (i.e., 1 / 1)

	rational(int aa, int bb);
	// second constructor
	// Postcondition: numerator & denominator of the declared rational object is initialized to parameters aa and bb, respectively; 
	//                          program exits if bb = 0

	int getNum();
	// Accessor 
	// Postcondition: returns the numerator of the calling rational object

	int getDenom();
	// accessor
	// Postcondition: returns the denominator of the calling rational object

	void set(int aa, int bb);
	// Postcondition: calling rational object is set to aa / bb

	rational operator+(const rational &r2) const;
	// Postcondition: sum of calling rational object and r2 is returned (notice the return type is rational!)

	rational operator-(const rational &r2) const;
	// Postcondition: (calling rational object - r2) is returned 

	rational operator*(const rational &r2) const;
	// Postcondition: product of calling rational object and  r2 is returned
 
	rational operator/(const rational &r2) const;
	// Postcondition: (calling rational object / r2) is returned

	int operator>(const rational&r2) const;
	// Postcondition: returns 1 if calling object is greater than r2; 0 if r1 is equal to r2; -1 is r1 is less than r2 
private:
	int GCD() const;
	// Helper function; not intended for clients of class, so  it is kept in private section. You must use the Euclidean algorithm. 
	// Postcondition: returns the "greatest common divisor" between the numerator and denominator of the calling rational object
	int a;	// numerator
	int b;	// denominator
};

// External function prototypes
int fillArrayFromDiskFile(istream &fin, rational r[]);		
//  Precondition: address & physical size of the rational array declared in the calling function must be passed to the function
// Postcondition: returns the actual # of rational numbers entered by user which must be less than or equal to size

void displayArray(rational r[], int n);
// Postcondition: display n rational numbers

void writeArrayToDiskFile(rational r[], int n);
// Postcondition: 

void selectionSort(rational r[], int n);
//  Precondition: address of the rational array declared in the calling function and the # of elements to be sorted must be 
//                          passed to the function
// Postcondition: n rational number is the array are sorted in ascending order

int findSmallestRationalNumber(rational r[], int first, int n);
//  Precondition: accepts address, subscript value of the first element of the unsorted sub-list, and the # of array elements n 
// Postcondition: returns subscript value of the smallest rational number in the unsorted sub-list of the array

void swap(rational &r1, rational &r2);
// Postcondition: contents of memory locations referenced by r1 and r2 are swapped

// main function

rational::rational()
{
}

rational::rational(int aa, int bb)
{
	if (b == 0)
	{
		cout << "Denominator cannot equal 0\n";
		
		exit(1);
	}
	
	a = aa;
	b = bb;
}

int rational :: getNum()
{
	return (a);
}

int rational :: getDenom()
{
	return (b);
}

void rational::set(int aa, int bb)
{
	cout << "Enter numerator and denominator: \n";
	cin >> aa >> bb;
}

int rational::operator>(const rational&r2) const
{
	double r1total, r2total;
	
	r1total = (double) a/b;
	r2total = (double) r2.a/r2.b;
	
	if (r1total > r2total)
		return 1;
	else if (r1total == r2total)
		return 0;
	else 
		return -1;
}

int rational::GCD() const
{
	int n = abs(a);
	int d = abs(b);
	
	while(d != 0)
	{
		int temp = d;
		d = n % d;
		n = temp;
	}
	
	return n;
}

istream& operator>>(istream &in, rational &r2)
{
	in >> r2.a >> r2.b;
	
	return in;
}

ostream& operator<<(ostream &out, rational &r2)
{
	int gcd = r2.GCD();
	
	if (r2.b < 0)
	{
		r2.b = -(r2.b);
		r2.a = -(r2.a);
	}
	out << r2.a / gcd << "/" << r2.b / gcd;
	
	return out;
}

int fillArrayFromDiskFile(istream &fin, rational r[])
{
	int i = 0;
	char more = 'Y';
	do
	{
			cout << "Please enter numerator and denominator: ";
			cin >> r[i];
			cout << endl;
			cout << "More rational numbers (Y/N)? ";
			cin >> more; 
			cout << endl << endl;
		
			++i;
	}
	while(more == 'Y'|| more == 'y');
	
	return (i);
}

void displayArray(rational r[], int n)
{   
	cout << endl;
	
	for(int i = 0; i < n; i++)
	{
		cout << r[i] << " ";
	}
	
}

void writeArrayToDiskFile(rational r[], int n)
{
	for (int i = 0; i < n; i++)
	{
		cout << r[i];
		cout << " ";
	}
}

void selectionSort(rational r[], int n)
{
	int i, pos;
	
	for(i = 0; i < n; i++)
	{
		pos = findSmallestRationalNumber(r, i, n);
		swap(r[i], r[pos]);
	}
	
}

int findSmallestRationalNumber(rational r[], int first, int n)
{
	int pos = first;
	rational smallest = r[pos];
	
	for(int i = first + 1; i < n; i++)
	{
		if((r[i] > smallest) == -1)
		{
			smallest = r[i];
			pos = i;
		}
	
	}
	return pos;
}

void swap(rational &r1, rational &r2)
{
	rational temp;
	
	temp = r1;
	r1 = r2;
	r2 = temp;
	
}


int main()
{
	ifstream fin;		// fin is an ifstream object used to call member functions open(), close(), fail(), etc
   	ofstream fout;	// fout is an ofstream object used to call member function close(), fail(), etc.
	
	const int SIZE = 50, FILE_NAME_SIZE = 16;
	rational r[SIZE];
	char inputFileName[FILE_NAME_SIZE], outputFileName[FILE_NAME_SIZE];
	
	cout << "Enter the name of the input disk file (up to 15 characters): ";
	cin >> inputFileName;
	cout << "Enter the name of the output disk file (up to 15 characters): ";
    cin >> outputFileName;
	
	fin.open(inputFileName);
    if (fin.fail())
    {
    	cout << "Input file opening failed.\n";
    	exit(1);
	}
	
	fout.open(outputFileName);
	if (fout.fail())
	{
		cout << "Output file opening failed.\n";
		exit(1);
	}
	
	int insize = fillArrayFromDiskFile(fin, r);
    
    cout << "Aray contains " << insize << " rational numbers read from the disk file named in.txt" << endl;
    
    cout << "Before sort, the array contains:\n";
    
	selectionSort(r, insize);
	
	displayArray(r, insize);
	
	
	cout << "After sort, the array cotains:\n";
	
	displayArray(r, insize);

	
	cout << "Open output disk file to store the sorted array:\n";
	
    fout << "The contents of the array is now written to a disk file named out.txt\n";
    
    fout << "We now open the out.txt, read and display its contents:\n";
    
    writeArrayToDiskFile(r, insize);

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

		
	return 0;
}