Access violation error

Discussion in 'C++' started by muser, Oct 27, 2003.

  1. muser

    muser Guest

    In the code I supplied before this one, the cause of the problem is an
    access violation error. When I run the debugger it skips into what I
    can only assume is the compilers version of my code. And I don't know
    where the problem lies in the code. Can anyone run it through there
    own compiler please and tell me where and what the problem is.


    #include <iostream>
    #include <iomanip>
    #include <fstream>
    #include <cstring>
    #include <cstdlib>


    using namespace std;

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

    };
    crecord Newcrecord;

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

    };
    irrecord Newirrecord;

    struct drecord {
    long customercode[5];
    };
    drecord Newdrecord;






    ////////////////////////////////////////////////////////////
    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* record)
    {
    int len;

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

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

    }


    return true;

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

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

    len = strlen(record);
    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;
    }

    ///////////////////////////////////////////////////////////////////////////
    irrecord* CheckDigit(ofstream& prnfile, ofstream& validdata, char*
    record )
    {
    char code[5];
    int weightingfactor = 5;
    int checkdigit;
    int remainder;
    int check1;

    strncpy(code, &record[2], 6);
    code[5] = '\0';
    Newirrecord.customercode[5] = atol( code );


    for(int i =0; i < 6; ++i)
    check1 += Newirrecord.customercode * weightingfactor;
    weightingfactor --;

    remainder = check1 % 11;

    checkdigit = 11 - remainder;

    if(! Newirrecord.customercode[5] == checkdigit){
    prnfile<< "Invalid customer number";
    prnfile<< record << endl;
    }
    return false;

    if(Newirrecord.customercode[5] == checkdigit){

    validdata.write((char*) record, Newirrecord.customercode[5]);
    }

    }
    /////////////////////////////////////////////////////////////////////////////////////

    drecord* checkdigit(ofstream& prnfile, ofstream& validdata, char*
    record )
    {
    char code[5];
    int weightingfactor = 5;
    int checkdigit;
    int remainder;
    int check1;

    strncpy(code, &record[2], 5);
    code[5] = '\0';
    Newdrecord.customercode[5] = atol( code );


    for(int i =0; i < 4; ++i)
    check1 += Newdrecord.customercode * weightingfactor;
    weightingfactor --;

    remainder = check1 % 11;

    checkdigit = 11 - remainder;

    if(! Newdrecord.customercode[5] == checkdigit){
    prnfile<< "Invalid customer number";
    prnfile<< record << endl;
    }
    return false;

    validdata.write((char*) record, Newdrecord.customercode[5]);


    }
    ////////////////////////////////////////////////////////////////////////////////

    ////////////////////////////////////////////////////////////////////////////////
    crecord* checkdigitforcustomercode( ofstream& prnfile, ofstream&
    validdata, char* record )
    {
    char code[5];
    int weightingfactor = 5;
    int checkdigit;
    int remainder;
    int check1;

    strncpy(code, &record[2], 5);
    code[5] = '\0';
    Newcrecord.customercode[5] = atol( code );


    for(int i =0; i < 6; ++i)
    check1 += Newcrecord.customercode * weightingfactor;
    weightingfactor --;

    remainder = check1 % 11;

    checkdigit = 11 - remainder;

    if(checkdigit == 11){
    checkdigit = 'X';
    }
    else
    if(checkdigit = checkdigit = 10){
    checkdigit = '0';
    }


    if(! Newcrecord.customercode[5] == checkdigit){
    prnfile<< "Invalid customer number";
    prnfile<< record << endl;
    }
    return false;

    validdata.write((char*) record, Newcrecord.customercode[5]);

    }
    ////////////////////////////////////////////////////////////////////////////////////
    irrecord* checkdigitforpartnum(ofstream& prnfile, ofstream& validdata,
    char* record)
    {
    int weightingfactor2;
    char part_num[6];
    int partnumcheck;
    int produce;
    int holdall;

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

    weightingfactor2 = 6;

    for(int i=0; i < 6; ++i)
    holdall += Newirrecord.partnum * weightingfactor2;
    weightingfactor2 --;

    produce = holdall % 11;

    partnumcheck = 11 - produce;


    if(partnumcheck == 11){
    partnumcheck = 'X';
    }
    else
    if(partnumcheck = 10){
    partnumcheck = '0';
    }

    if(! Newirrecord.partnum[5] == partnumcheck){
    prnfile<< "Invalid: Incorrect part number, check digit invalid";
    prnfile<< record << endl;
    }
    return false;

    validdata.write((char*) record, Newirrecord.partnum[5]);

    }

    ////////////////////////////////////////////////////////////////////////////////////
    bool CheckAddress( const 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, ofstream& validdata, char*
    record )
    {
    char customercode[6];
    char balance[10];
    char limit[10];


    crecord Newcrecord;

    //
    // process the customer code
    //
    strncpy( customercode, &record[1], 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], 61 );
    Newcrecord.customeraddress[61] = '\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 );


    validdata.write((char*) record, Newcrecord.customerbalance );

    //
    // 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 );

    validdata.write((char*) record, Newcrecord.creditlimit );

    return true;

    }

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

    bool processdrecord( char* record, ofstream& prnfile, ofstream&
    validdata )
    {
    drecord Newdrecord;
    char customercode[5];

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

    validdata.write((char*) record, Newdrecord.customercode[5] );


    return true;
    }

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


    char customer[6];
    char issue_rec[5];
    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 );

    validdata.write((char*) record, partnum[6]);

    return true;

    //
    // process the third number
    //
    strncpy( issue_rec, &record[13], 5 );
    issue_rec[5] = '\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;
    }

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


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

    int max = 256;

    char temp1[256];



    ifstream testdata;
    ofstream prnfile;
    ofstream validdata;

    testdata.open("A:\\514650TD.txt", ios::in);
    if(!testdata)
    {
    cout<<"The file does not already exist" << infile << endl;
    return EXIT_FAILURE;
    }

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

    prnfile.open("A:\\514650.TXT", ios::eek:ut);
    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;
    }
    if(!IRRecordvalidlength( temp1 )){
    prnfile<< "Invalid: record does not contain enough characters:\n";
    prnfile<< temp1 << endl;
    continue;
    }
    if(!Drecordvalidlength( temp1 )){
    prnfile<< "Invalid: record does not contain enough characters:\n";
    prnfile<< temp1 << endl;
    continue;
    };

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

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

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

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


    return EXIT_SUCCESS;

    };
     
    muser, Oct 27, 2003
    #1
    1. Advertisements

  2. muser

    Artie Gold Guest

    I'm not going to go through your code line by line, but at least a
    couple of things jump right out. See below:


    Your copying 6 `char's into an array of length 5.
    No, `code[5]' does not exist. The last element in the array is
    `code[4]' (arrays in C++ are zero-based, hence valid indices run
    from 0 to 4).


    Similarly, see above.


    The items noted above are sufficient to produce undefined behavior
    -- after which all bets are off.

    Also, in the future, pare down your code to the smallest possible
    compilable snippet *before* you post; in doing so, you will often
    find the error yourself!

    HTH,
    --ag
     
    Artie Gold, Oct 27, 2003
    #2
    1. Advertisements

  3. muser

    Kevin Saff Guest

    [SNIP WAY TOO MUCH INFORMATION]

    If you read the replies to your earlier post, you will see your problem.
    Maybe your news server is slow - even then try to keep posts about the same
    problem in the same thread; wait at least a day or two to see if your post
    went through.

    You frequently write past the end of an array, as in:

    char code[5]; // has 5 chars, numbered _0_ to _4_
    code[5] = '\0'; // you are writing to char _5_ which does not exist!

    Don't do this.
     
    Kevin Saff, Oct 27, 2003
    #3
  4. muser

    muser Guest

    Kevin, doesn't my code[5] contain a NULL character and isn't that
    housed in the fifth element?
     
    muser, Oct 28, 2003
    #4
  5. muser

    Ron Natalie Guest

    No, code[5] refers to the sixth element.

    code[0] is the first, code[1] is the scond, code[2] is the third, code[3] is the forth,
    code[4] is the fifth.

    These are the only locations you are allowed to access.

    code[5] is one past the end of the allocation. You touch it, you can't count
    on any specific behavior.
     
    Ron Natalie, Oct 28, 2003
    #5
  6. code[5] is the *sixth* element. char code[5] declares an array of five
    elements, numbered 0 to 4.

    James
     
    James Lothian, Oct 28, 2003
    #6
  7. muser

    muser Guest

    sorry kevin, posted my reply moments after getting up, disregard my
    reply, and thank you for the advance.
     
    muser, Oct 28, 2003
    #7
  8. muser

    Adam Fineman Guest

    I'd be very surprised if any compiler did, actually.

    - Adam
     
    Adam Fineman, Oct 30, 2003
    #8
  9. Be surprised, then :)

    $icc -w2 compilertest.cpp
    compilertest.cpp(3): warning #175: subscript out of range
    code[5] = '\0';

    $icc -V
    Intel(R) C++ Compiler for 32-bit applications, Version 7.0 Build 20030212Z
    Copyright (C) 1985-2003 Intel Corporation. All rights reserved.

    kind regards
    frank
     
    Frank Schmitt, Nov 3, 2003
    #9
  10. muser

    muser Guest

    Sorry to return to this thread, but when I made my character array
    char code[6]
    and put the code, code[6] = '\0';
    my compiler kept picking up something it shouldn't.
    I'm feeding this line into the array c12345stevelaw. the numbers is
    all I want to appear in the array, but when I check that code only
    contains numbers it produces an error. the char code[6] isn't assigned
    to the string terminator but to the 's' in steve. I've gone back to
    using char code[5] and it works perfectly. But I did that last time
    which caused an error after running the program a few times. why is
    char code[6] not being assigned the string terminator, even though the
    code explicitly implies this?
     
    muser, Nov 7, 2003
    #10
  11. muser

    lilburne Guest

    Its because you are using the wrong language try fortran.
     
    lilburne, Nov 7, 2003
    #11
    1. Advertisements

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 (here). After that, you can post your question and our members will help you out.