Reading a file.

M

muser

With the following code I'm trying to read a text file (infile) and
output inaccuracies to the error file (printerfile). The text file is
written and stored on disk, while the printerfile has to be created
when the program executes. But the compile keeps reading that it can't
find the text file.
Karl you wrote the original program from which this one is but a poor
copy, can you or anyone else enlighten me as to why yours worked and
mine didn't.
The full program code follows beneath what I consider to be the main
problem.


int main()
{
const char infile[] = "A:\\514650TD.txt";
const char outfile[] = "A:\\514650VD.DAT";
const char printerfile[] = "A:\\514650EO.TXT";

char temp1[256];

ifstream testdata;
ofstream validdata;
ofstream prnfile;

testdata.open("infile", ios::in);
if(!testdata.is_open())
{
cout<<"The file does not already exist" << infile << '\n';
return EXIT_FAILURE;
}

validdata.open("outfile", ios::eek:ut || ios::binary);
if(!validdata.is_open())
{
cout<<" The file could not be opened " << outfile <<endl;
return EXIT_FAILURE;
}

prnfile.open("printerfile", ios::eek:ut || ios::binary);
if(!prnfile)
{
cout<< "File could not be opened" << prnfile << endl;
return EXIT_FAILURE;
};


/////////////////////////////////////////////////////////////////////////////
Full program code.

#include <iostream>
#include <iomanip>
#include <fstream>
#include <cstring>
#include <cstdlib>
#include<string.h>

using namespace std;

struct crecord {
long customercode[5];
char customername[21];
char customeraddress[61];
double customerbalance;
double creditlimit;
};

struct irrecord {
long customercode[5];
long partnum[6];
long issue_rec;
};

struct drecord {
long customercode;
};

////////////////////////////////////////////////////////////
bool IRRecordvalidlength(char* record)
{
int len;

switch(record[0])
{
case'i':
case'I':
case'r':
case'R':

len= strlen(record);
if(len<17)
return false;
break;


}

return true;
};
////////////////////////////////////////////////////////////
bool CRecordvalidlength(char* cstring)
{
int len;

switch(cstring[0])
{
case'c':
case'C':

len = strlen(cstring);
if(len<103)
return false;
break;

}


return true;

}
////////////////////////////////////////////////////////
bool Drecordvalidlength(char* dstring)
{
int len;

switch(dstring[0])
{
case'd':
case'D':

len = strlen(dstring);
if(len<7)
return false;
break;

}



return true;
}
//////////////////////////////////////////////////////////
bool CheckAllNumeric( const char * string )
{
int Len = strlen( string );

for( int i = 0; i < Len; ++i )
if( !isdigit( string ) )
return false;

return true;
}

////////////////////////////////////////////////////////////////
bool CheckFloatNumber( const char* string )
{
int Len = strlen( string );

for( int i = 0; i < Len; ++i )
if( !isdigit( string ) &&
string != '.' )
return false;

return true;
}

/////////////////////////////////////////////////////////////////
crecord Newcrecord;
bool CheckAddress( char* alpha )
{

int max_alpha = 60;

for( int i = 0; i < max_alpha; ++i )
if( !isalpha( alpha ) && ( alpha != ';' ) && ( alpha != ' '
))
if(Newcrecord.customeraddress[61] != (alpha))
return false;

return true;


}


////////////////////////////////////////////////////////////////

bool Processcrecord( ofstream& prnfile, char* record )
{
char customercode[6];
char balance[10];
char limit[10];

crecord Newcrecord;

//
// process the customer code
//
strncpy( customercode, &record[2], 5 );
customercode[5] = '\0';
if( !CheckAllNumeric( customercode ) ) {
prnfile << "Invalid: customer code needs to be all numeric
[position 3 - 5 characters]:\n";
prnfile << record << endl;
return false;
}
Newcrecord.customercode[5] = atol( customercode );

//
// process the customer name
//
strncpy( Newcrecord.customername, &record[7], 20 );
Newcrecord.customername[20] = '\0';

//
// process the customer address
//
strncpy( Newcrecord.customeraddress, &record[27], 60 );
Newcrecord.customeraddress[60] = '\0';

//
// process the customer balance
//
strncpy( balance, &record[87], 9 );
balance[9] = '\0';
if( !CheckFloatNumber( balance ) ) {
prnfile << "Invalid: balance field is not a valid number [position
88 - 9 characters]:\n";
prnfile << record << endl;
return false;
}
Newcrecord.customerbalance = atof( balance );

//
// process the customer limit
//
strncpy( limit, &record[97], 9 );
limit[9] = '\0';
if( !CheckFloatNumber( limit ) ) {
prnfile << "Invalid: limit field is not a valid number [position
98 - 9 characters]:\n";
prnfile << record << endl;
return false;
}
Newcrecord.creditlimit = atof( limit );

return true;

}

///////////////////////////////////////////////////////

bool processdrecord(ofstream& prnfile, char* dstring)
{
drecord NewDrecord;
char customercode[6];

strncpy( customercode, &dstring[2], 5);
customercode[6] = '\0';
if(!CheckAllNumeric( customercode )){
prnfile<< "Invalid: D record customer code does not contain
numerical format"<<endl;
prnfile<< dstring <<endl;
return false;
}
NewDrecord.customercode = atol( customercode );

return true;
}


bool ProcessIRecord( ofstream& prnfile, char* record )
{


char customer[6];
char issue_rec[5];
char code[4];
char part[6];

long customer_code;
long issuerec;
long partnum[6];



//
// process the customer code
//
strncpy( customer, &record[2], 5 );
customer[6] = '\0';
if( !CheckAllNumeric( customer ) ) {
prnfile << "Invalid: customer code needs to be all numeric
[position 3 - 5 characters]:\n";
prnfile << record << endl;
return false;
}
customer_code = atol( customer );

//
// process the part number
//
strncpy( part, &record[7], 6 );
part[6] = '\0';
if( !CheckAllNumeric( part ) ) {
prnfile << "Invalid: part number needs to be all numeric [position
9 - 6 characters]:\n";
prnfile << record << endl;
return false;
}
partnum[6] = atol( part );

//
// process the third number
//
strncpy( issue_rec, &record[13], 4 );
code[4] = '\0';
if( !CheckAllNumeric( issue_rec ) ) {
prnfile << "Invalid: the code needs to be all numeric [position 16
- 4 characters]:\n";
prnfile << record << endl;
return false;
}
issuerec = atol( issue_rec );


return true;
}

bool CheckDigit(long part_num[6], char* record)
{

int weightingfactor;
int remainder;
int weightitem1, weightitem2, weightitem3, weightitem4, weightitem5;
int product;
int Mod11 = 11;
int checkdigit;
char partnum[6];


strncpy(partnum, &record[7], 6);
partnum[6] = '\0';
part_num[6] = atol( partnum );



weightingfactor = 6;

weightitem1 = (part_num[1] * weightingfactor);

weightingfactor = 5;

weightitem2 = (part_num[2] * weightingfactor);

weightingfactor = 4;

weightitem3 = (part_num[3] * weightingfactor);

weightingfactor = 3;

weightitem4 = (part_num[4] * weightingfactor);

weightingfactor = 2;

weightitem5 = (part_num[5] * weightingfactor);




product = (weightitem1 + weightitem2 + weightitem3 + weightitem4 +
weightitem5);

remainder = (product % Mod11);

checkdigit = (Mod11 - remainder);
if(!part_num[6] == checkdigit)
return false;


return true;

}



bool CheckDigitForCustomerCode(ofstream& prnfile, char* record)
{
int weightfactor;
int counter1, counter2, counter3, counter4;
int remainder;
int prod;
int Mod11 = 11;
int check_digit;
char custcode[5];



strncpy(custcode, &record[2], 5);
custcode[5] = '\0';
weightfactor = 5;

counter1 = (custcode[1] * weightfactor);

weightfactor = 4;

counter2 = (custcode[2] * weightfactor);

weightfactor = 3;

counter3 = (custcode[3] * weightfactor);

weightfactor = 2;

counter4 = (custcode[4] * weightfactor);

prod = (counter1 + counter2 + counter3 + counter4);

remainder = (prod % Mod11);

check_digit = (Mod11 - remainder);

if(!custcode[5] == check_digit)
return false;


return true;

}






int main()
{
const char infile[] = "A:\\514650TD.txt";
const char outfile[] = "A:\\514650VD.DAT";
const char printerfile[] = "A:\\514650EO.TXT";

char temp1[256];

ifstream testdata;
ofstream validdata;
ofstream prnfile;

testdata.open("infile", ios::in);
if(!testdata.is_open())
{
cout<<"The file does not already exist" << infile << '\n';
return EXIT_FAILURE;
}

validdata.open("outfile", ios::eek:ut || ios::binary);
if(!validdata.is_open())
{
cout<<" The file could not be opened " << outfile <<endl;
return EXIT_FAILURE;
}

prnfile.open("printerfile", ios::eek:ut || ios::binary);
if(!prnfile)
{
cout<< "File could not be opened" << prnfile << endl;
return EXIT_FAILURE;
};


prnfile << "C_RECORD, I-R RECORD, D_RECORD ERRORS" << endl;

while( testdata.getline( temp1, sizeof(temp1)))
{
if(!CRecordvalidlength( temp1 )){
prnfile<<"Invalid: record does not contain enough characters:\n";
prnfile<< temp1 <<endl;
continue;
};

switch( temp1[0] )
{
case 'c':
case 'C':
Processcrecord( prnfile, temp1 );
break;

case 'i':
case 'I':
case 'r':
case 'R':
ProcessIRecord( prnfile, temp1 );
break;

case 'd':
case 'D':
processdrecord( prnfile, temp1 );
break;
default: prnfile<< "Unknown record";
prnfile<< temp1 << endl;
};


testdata.close();
validdata.close();
prnfile.close();

};
return EXIT_SUCCESS;

};
 
M

Mike Wahler

muser said:
With the following code I'm trying to read a text file (infile) and
output inaccuracies to the error file (printerfile). The text file is
written and stored on disk, while the printerfile has to be created
when the program executes. But the compile keeps reading that it can't
find the text file.
Karl you wrote the original program from which this one is but a poor
copy, can you or anyone else enlighten me as to why yours worked and
mine didn't.
The full program code follows beneath what I consider to be the main
problem.
Click to expand...
int main()
{
const char infile[] = "A:\\514650TD.txt";
const char outfile[] = "A:\\514650VD.DAT";
const char printerfile[] = "A:\\514650EO.TXT";

char temp1[256];

ifstream testdata;
ofstream validdata;
ofstream prnfile;

testdata.open("infile", ios::in);
Click to expand...

You're trying to open a file named "infile", not
named as the string contained in your array with
an identifier of 'infile'.


testdata.open(infile); /* Note: ios::in is default of 'ifstream' */
if(!testdata.is_open())
{
cout<<"The file does not already exist" << infile << '\n';
return EXIT_FAILURE;
}

validdata.open("outfile", ios::eek:ut || ios::binary);
Click to expand...

validdata.open(outfile, ios::eek:ut || ios::binary);

Note: ios::eek:ut is default of 'ofstream'.

Question: Why binary?

if(!validdata.is_open())
{
cout<<" The file could not be opened " << outfile <<endl;
return EXIT_FAILURE;
}

prnfile.open("printerfile", ios::eek:ut || ios::binary);
Click to expand...

Same issues here.
if(!prnfile)
{
cout<< "File could not be opened" << prnfile << endl;
return EXIT_FAILURE;
};
Click to expand...

I didn't look at anything else, this is what jumped out at me.

HTH,
-Mike
 
T

Thomas Matthews

muser said:
With the following code I'm trying to read a text file (infile) and
output inaccuracies to the error file (printerfile). The text file is
written and stored on disk, while the printerfile has to be created
when the program executes. But the compile keeps reading that it can't
find the text file.
Karl you wrote the original program from which this one is but a poor
copy, can you or anyone else enlighten me as to why yours worked and
mine didn't.
The full program code follows beneath what I consider to be the main
problem.
Click to expand...

Sorry if I'm not Karl, but this is a public forum.
int main()
{
const char infile[] = "A:\\514650TD.txt";
const char outfile[] = "A:\\514650VD.DAT";
const char printerfile[] = "A:\\514650EO.TXT";

char temp1[256];

ifstream testdata;
ofstream validdata;
ofstream prnfile;

testdata.open("infile", ios::in);
if(!testdata.is_open())
Click to expand...

if (!testdata)
{
cout<<"The file does not already exist" << infile << '\n';
return EXIT_FAILURE;
}

validdata.open("outfile", ios::eek:ut || ios::binary);
if(!validdata.is_open())
Click to expand...

if (!validdata)
{
cout<<" The file could not be opened " << outfile <<endl;
return EXIT_FAILURE;
}

prnfile.open("printerfile", ios::eek:ut || ios::binary);
if(!prnfile)
{
cout<< "File could not be opened" << prnfile << endl;
return EXIT_FAILURE;
};


/////////////////////////////////////////////////////////////////////////////
Full program code.

#include <iostream>
#include <iomanip>
#include <fstream>
#include <cstring>
#include <cstdlib>
#include<string.h>

using namespace std;

struct crecord {
long customercode[5];
Click to expand...

Is this 5 long integers or 5 characters?
char customername[21];
char customeraddress[61];
double customerbalance;
double creditlimit;
};
Click to expand...

Don't use "magic numbers". Prefer named constants:
const unsigned int MAX_CUSTOMER_CODES = 5;
const unsigned int MAX_CUSTOMER_NAME_LENGTH = 21;
const unsigned int MAX_CUSTOMER_ADDR_LENGTH = 61;

struct crecord
{
long customercode[MAX_CUSTOMER_CODES];
char customername[MAX_CUSTOMER_NAME_LENGTH];
char customeraddress[MAX_CUSTOMER_ADDR_LENGTH];
// ...
};

struct irrecord {
long customercode[5];
long partnum[6];
long issue_rec;
};
Click to expand...

See above comment about magic numbers.

struct drecord {
long customercode;
};

////////////////////////////////////////////////////////////
bool IRRecordvalidlength(char* record)
{
int len;

switch(record[0])
{
case'i':
case'I':
case'r':
case'R':

len= strlen(record);
if(len<17)
return false;
break;


}

return true;
};
Click to expand...

Perhaps this could be simplified:
if ( (std::toupper(record[0]) == 'I')
|| (std::toupper(record[0]) == 'R'))
{
if (strlen(record) < MAGIC_NUMBER_17)
return false;
}
else
return true;

////////////////////////////////////////////////////////////
bool CRecordvalidlength(char* cstring) [snip]

////////////////////////////////////////////////////////
bool Drecordvalidlength(char* dstring)
Click to expand...
[snip]

In the above functions:
1. Use std::toupper() or std::tolower() to convert the case
of a character before comparison. This reduces the number
of comparisons and makes the code easier to read.
2. Don't use a switch statement for only one case. The
switch statement in the above functions will reduce to
one case when using either character case conversion
function.
3. You may want to simplify the contents into a single return
statement that uses boolean logic.
4. Magic numbers again.

//////////////////////////////////////////////////////////
bool CheckAllNumeric( const char * string )
{
int Len = strlen( string );

for( int i = 0; i < Len; ++i )
if( !isdigit( string ) )
return false;

return true;
}
Click to expand...


Look at the library function "strtol()".
////////////////////////////////////////////////////////////////
bool CheckFloatNumber( const char* string )
{
int Len = strlen( string );

for( int i = 0; i < Len; ++i )
if( !isdigit( string ) &&
string != '.' )
return false;

return true;
}
Click to expand...


The above function is not correct.
Use this test string "1..64"
Look at the library function "strtod()".

/////////////////////////////////////////////////////////////////
crecord Newcrecord;
bool CheckAddress( char* alpha )
{

int max_alpha = 60;

for( int i = 0; i < max_alpha; ++i )
if( !isalpha( alpha ) && ( alpha != ';' ) && ( alpha != ' '
))
if(Newcrecord.customeraddress[61] != (alpha))
return false;

return true;


}
Click to expand...

I don't think this is a valid function either.
Try this test case "; ; ; ; ;aa"
Is this a valid address: "630 Mango Lane"?

////////////////////////////////////////////////////////////////

bool Processcrecord( ofstream& prnfile, char* record )
{
char customercode[6];
char balance[10];
char limit[10];

crecord Newcrecord;

//
// process the customer code
//
strncpy( customercode, &record[2], 5 );
customercode[5] = '\0';
if( !CheckAllNumeric( customercode ) ) {
prnfile << "Invalid: customer code needs to be all numeric
[position 3 - 5 characters]:\n";
prnfile << record << endl;
return false;
}
Newcrecord.customercode[5] = atol( customercode );
Click to expand...

The above code could be simplified by using the library
function sscanf() or using stringstream and the extraction
operators.

Magic numbers again.

//
// process the customer name
//
strncpy( Newcrecord.customername, &record[7], 20 );
Newcrecord.customername[20] = '\0';
Click to expand...

Magic Numbers again.
//
// process the customer address
//
strncpy( Newcrecord.customeraddress, &record[27], 60 );
Newcrecord.customeraddress[60] = '\0';
Click to expand...

Magic Numbers again. What about validating the customer address?
//
// process the customer balance
//
strncpy( balance, &record[87], 9 );
balance[9] = '\0';
if( !CheckFloatNumber( balance ) ) {
prnfile << "Invalid: balance field is not a valid number [position
88 - 9 characters]:\n";
prnfile << record << endl;
return false;
}
Newcrecord.customerbalance = atof( balance );
Click to expand...

A better method is to use sscanf or strtod.

//
// process the customer limit
//
strncpy( limit, &record[97], 9 );
limit[9] = '\0';
if( !CheckFloatNumber( limit ) ) {
prnfile << "Invalid: limit field is not a valid number [position
98 - 9 characters]:\n";
prnfile << record << endl;
return false;
}
Newcrecord.creditlimit = atof( limit );
Click to expand...

A better method is to use sscanf or strtod.

return true;

}

///////////////////////////////////////////////////////

bool processdrecord(ofstream& prnfile, char* dstring)
{
drecord NewDrecord;
char customercode[6];

strncpy( customercode, &dstring[2], 5);
customercode[6] = '\0';
if(!CheckAllNumeric( customercode )){
prnfile<< "Invalid: D record customer code does not contain
numerical format"<<endl;
prnfile<< dstring <<endl;
return false;
}
NewDrecord.customercode = atol( customercode );
Click to expand...

A better method is to use sscanf or strtol.

return true;
}
Click to expand...
[snip]

1. Convert all the magic numbers into named constants.
2. Prefer strtol over atol.
3. The strtol, sscanf and stringstream have error checking.
Use them.
4. Since you are using C++, prefer std::string to char *.


--
Thomas Matthews

C++ newsgroup welcome message:
http://www.slack.net/~shiva/welcome.txt
C++ Faq: http://www.parashift.com/c++-faq-lite
C Faq: http://www.eskimo.com/~scs/c-faq/top.html
alt.comp.lang.learn.c-c++ faq:
http://www.raos.demon.uk/acllc-c++/faq.html
Other sites:
http://www.josuttis.com -- C++ STL Library book
 
K

Kevin Goodsell

muser said:
With the following code I'm trying to read a text file (infile) and
output inaccuracies to the error file (printerfile). The text file is
written and stored on disk, while the printerfile has to be created
when the program executes. But the compile keeps reading that it can't
find the text file.
Karl you wrote the original program from which this one is but a poor
copy, can you or anyone else enlighten me as to why yours worked and
mine didn't.
The full program code follows beneath what I consider to be the main
problem.


int main()
{
const char infile[] = "A:\\514650TD.txt";
const char outfile[] = "A:\\514650VD.DAT";
const char printerfile[] = "A:\\514650EO.TXT";

char temp1[256];

ifstream testdata;
ofstream validdata;
ofstream prnfile;

testdata.open("infile", ios::in);
if(!testdata.is_open())
{
cout<<"The file does not already exist" << infile << '\n';
return EXIT_FAILURE;
}

validdata.open("outfile", ios::eek:ut || ios::binary);
Click to expand...

In addition to what others said, that's supposed to be a bitwise OR
operator: '|' Single bar, not double bar.

ios::eek:ut | ios::binary

Of course, ios::eek:ut is redundant for an ofstream.
if(!validdata.is_open())
{
cout<<" The file could not be opened " << outfile <<endl;
return EXIT_FAILURE;
}

prnfile.open("printerfile", ios::eek:ut || ios::binary);
Click to expand...

Same issue.
if(!prnfile)
{
cout<< "File could not be opened" << prnfile << endl;
return EXIT_FAILURE;
};
Click to expand...

-Kevin
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Similar Threads

Reading a file 1
The program/ header file contents 2
function error 6
Access violation error 10
passing a parameter 2
inialisation problem. 2
Logical error/ whole program contained within. 4
Register Question 0

Members online

No members online now.
Total: 106 (members: 0, guests: 106)
Robots: 465

Forum statistics

Threads
473,995
Messages
2,570,230
Members
46,818
Latest member
Brigette36

Latest Threads

Top