try-throw-catch

For some reason my throws are not handled. Would appreciate your help.

main()

Code:

---

int main()
{
        displayinfo();
        try
        {
                FileHandling operations;
                operations.ReadFile("data.txt"); //here I have the problem
                operations.CalculateValues();
                operations.printdata();
        }
        catch (int code)
        {
                cerr<<"error code number: "<<NoSuchFile<<endl;
                exit(1);
        }
        return 0;
}

---

The method

Code:

---

void FileHandling::ReadFile(const string& filename) throw(int)
{
        int numberOfRows;
        ifstream infile(filename.c_str());
        if(infile.fail())
                throw NoSuchFile; //this one is not handled
        infile>>numberOfRows;//get the number of records in the file
        if(!numberOfRows)
                throw numberOfRows;
        for (int i=0;i<numberOfRows;i++) //cycle through whole file
        {
                if(!infile.eof()) //check not eof()
                {
                        infile.ignore(); //have to ignore \n before getline
                        const int MaxLine = 80;
                        char str[MaxLine];
                        infile.getline(str, MaxLine);
                        if(infile.fail())
                                throw ErrGetLine;
                        if (str[0]!='#') //if line is not comment
                        {
                                numRecords++;
                                double number=atof(str);
                                vec.push_back(number);
                        }//end of if
                }
                else
                        throw WrongNumberOfLinesInHeader;
        }//end of for
}//getdata

---

and the header file, just in case

Code:

---

#ifndef __FILE_HANDLING__
#define __FILE_HANDLING__

#include <vector>
#include <iostream>
using namespace std;

enum ERRORS
{
        NoSuchFile,
        numberOfRows,
        WrongNumberOfLinesInHeader,
        ErrGetLine
};

class FileHandling
{
private:
        double numRecords, sum, average, minimum, maximum;
        vector<double> vec;
public:
        FileHandling();
        void ReadFile(const string& filename) throw(int);
        void CalculateValues();
    void printdata() const;
};

#endif

---

Code:

---

enum ERRORS
{
        NoSuchFile,
        numberOfRows,
        WrongNumberOfLinesInHeader,
        ErrGetLine
};

---

Shouldn't "numberOfRows" be different from your local variable of that name?

All the other error codes start with upper-case, why not this one [and perhaps call it BadNumberOfRows, and check for negative numers too?]

Code:

---

        catch (int code)
        {
                cerr<<"error code number: "<<NoSuchFile<<endl;
                exit(1);
        }

---

This will print "NoSuchFile" every single time, not the code...

--
Mats

You are absolutely right. I fixed what you said. Even though, the catch still doesn't work...

The problem is probably that you are throwing something of enum type (ERRORS) but hoping to catch an int. They are not the same type.

However, it would probably be better to either throw some of the standard exceptions (which are caught by reference) or your own custom error class (derived from std::except) as you can put much more info in them.

Another thing:

Code:

---

#ifndef __FILE_HANDLING__
#define __FILE_HANDLING__

---

Identifiers beginning with underscores are reserved for compiler implementers. You shouldn't use leading underscores as you may create a conflict with a current or future compiler-specific macro. Better use something like FILENAME_H.

I should have said that I didn't actually think it would fix any real problem [at this point].

Have you tried stepping through your read function to see if it actually gets to the "throw" part?

--
Mats

Are you sure that the throw is actually being called? Perhaps put a cout statement in the if block. Did you try throwing a plain int instead of an enum?

Also, you don't initialize numberOfRows, so if the input fails, it will be some garbage number that is probably not 0, so the if (!numberOfRows) part will probably never be true.

Quote:

---

Originally Posted by Daved

Are you sure that the throw is actually being called? Perhaps put a cout statement in the if block. Did you try throwing a plain int instead of an enum?

Also, you don't initialize numberOfRows, so if the input fails, it will be some garbage number that is probably not 0, so the if (!numberOfRows) part will probably never be true.

---

1) I ran it using the debugger and the throw NoSuchFile is called but not handled.
2) I did if(!numberOfRows) to examine whether there is something different rather than a number in the first line of the file such as a string or char. Won't it work?

1) So the next step would be to catch the enum type instead of an int.

2) That won't work because the numberOfRows variable will not be changed if the read fails. This is what you should do:

Code:

---

if (!(infile>>numberOfRows))

---

That will evaluate to false if the read fails to read in an integer, and so it will execute the if block and throw your exception. Note that I moved the read into the if control. Don't try to read into numberOfRows twice.

The point that Daved makes is that the integer value when attempting to read some garbage is not set at all - it is left to be whatever it happened to be.

And I think the solution to "it's thrown but not caught" is exactly what Anon says: You are throwing an enum, but you are catching an int. Whilst you and I may think that enum and int are the same thing, the compiler doesn't.

--
Mats

Quote:

---

Originally Posted by anon

The problem is probably that you are throwing something of enum type (ERRORS) but hoping to catch an int. They are not the same type.

---

Solved.
You're the man! Thank you all!

Quote:

---

Originally Posted by matsp

The point that Daved makes is that the integer value when attempting to read some garbage is not set at all - it is left to be whatever it happened to be.

---

So how do I verify if the user inserted an int when I ask him to instead of a char for instance?
I thought the way is

int num;
cout<<"insert a num";
cin>>num;
if(!num)
cout<<"you moron, this is not an int";

>> So how do I verify if the user inserted an int when I ask him to instead of a char for instance?

I posted while you were posting. Check out my answer in post #8 if you haven't already.

Code:

---

enum ERRORS
{
        NoSuchFile,
        numberOfRows,
        WrongNumberOfLinesInHeader,
        ErrGetLine
} myerrors ;

---

Code:

---

        if(infile.fail()) {
                myerrors = NoSuchFile ;
                throw myerrors ;
                }

---

Todd

Quote:

---

Originally Posted by Todd Burch

Code:

---

enum ERRORS
{
        NoSuchFile,
        numberOfRows,
        WrongNumberOfLinesInHeader,
        ErrGetLine
} myerrors ;

---

Code:

---

        if(infile.fail()) {
                myerrors = NoSuchFile ;
                throw myerrors ;
                }

---

Todd

---

That will not help anything, except introduce a global variable, which I'm pretty sure isn't of any use here.

--
Mats

I don't think globals are necessary.

Code:

---

enum Error {SmallError, BigError };
...
throw BigError;
...
catch (Error err) {
    std::cout << "Error code: " << err << '\n';
}

---

Quote:

---

Originally Posted by matsp

That will not help anything, except introduce a global variable, which I'm pretty sure isn't of any use here.

--
Mats

---

misterwakka's (sp?) example failed for me too. Changing to this construct, it worked just fine. How will it not help anything?

Strange that it changes anything - what you should do to fix it would be to chage "int code" to "ERRORS code" in the catch statement.

--
Mats

Well, I copied it over incorrectly from my example to his code.

What I should have added was

Code:

---

        if(infile.fail()) {
                int myerror = NoSuchFile ; 
                throw myerror ;
                }

---

And the enum does not need the "myerrors" instantiation as well. Good catch.

Todd

Sure, you can also cast an enum to integer:

Code:

---

  throw static_cast<int>(NoSuchFile);

---

But what's the point of that, when the "correct" thing to do is to actually use the enum that is defined in the first place.

--
Mats

Quote:

---

Originally Posted by matsp

Strange that it changes anything - what you should do to fix it would be to chage "int code" to "ERRORS code" in the catch statement.

--
Mats

---

That works too. They both (throw and catch) need to be int, or they both need to be the enum. I'm surprised, since enums are ints, the catch won't work with int when throwing the enum.

Todd

Quote:

---

Originally Posted by Todd Burch

That works too. They both (throw and catch) need to be int, or they both need to be the enum. I'm surprised, since enums are ints, the catch won't work with int when throwing the enum.

Todd

---

Actually, enum's and int's are not the same - they are very similar and can easily be converted back and forth, but enum's are distinctly different types from int's - even if the processor doesn't make much of a difference, the compiler thinks of them differently.

But the point of declaring an enum is to differentiate it from an int, so that's why the compiler sees it differently.

In plain C, the difference is even smaller.

--
Mats

OK, thanks for the in-depth!! (must get back to work...)

Are you saying that the only changes you made to your original code was to rename the numberOfRows enum and changethe catch to "catch (ERRORS code)"? What is the difference in behavior when you run the two versions?

I can't believe it. Damn. A few moments ago everything worked just fine. I made some changes and now when it is supposed to throw an exeption I get some memory leak and dbgdel.cpp is showing up!!! :-((
I think I'll just add the whole code...I really appreciate your help guys.

Header

Code:

---

#ifndef FILE_HANDLING__
#define FILE_HANDLING__

#include <vector>
#include <iostream>
using namespace std;

enum ERRORS
{
        NoSuchFile,
        BadNumberOfRows,
        WrongNumberOfLinesInHeader,
        ErrGetLine
};

class FileHandling
{
private:
        int numRecords;
        double sum, average, minimum, maximum;
        double* vec;
public:
        FileHandling();
        ~FileHandling();
        void ReadFile(const string& filename) throw(int);
        void CalculateValues();
    void printdata() const;

        //static const int NoSuchFile=1;
        //static const int BadNumberOfRows=2;
        //static const int WrongNumberOfLinesInHeader=3;
        //static const int ErrGetLine=4;
       
};

#endif

---

class CPP

Code:

---

#include "FileHandling.h"
#include <fstream>
using namespace std;

FileHandling::FileHandling()
{
        numRecords=0; sum=0; average=0; minimum=0; maximum=0; //zero all class variables
}

FileHandling::~FileHandling()
{
        delete vec;
}

void FileHandling::ReadFile(const string& filename) throw(int)
{
        int numberOfRows=0;
        ifstream infile(filename.c_str());
        if(infile.fail())
                throw NoSuchFile; //The problem
        infile>>numberOfRows;//get the number of records in the file
        infile.ignore(); //have to ignore \n before getline
        if(!numberOfRows)
                throw BadNumberOfRows;
        vec = new double[numberOfRows]; //assign maximal needed space for array. The loop won't acceed this value anyway
        for (int i=0;i<numberOfRows;i++) //cycle through whole file
        {
                if(!infile.eof()) //check not eof()
                {
                        const int MaxLine = 80;
                        char str[MaxLine];
                        infile.getline(str, MaxLine);
                        if(infile.fail())
                                throw ErrGetLine;
                        if (str[0]!='#') //if line is not comment
                        {
                                double number=atof(str);
                                vec[numRecords]=number;
                                numRecords++;
                        }//end of if
                }
                else
                        throw WrongNumberOfLinesInHeader;
        }//end of for
}//getdata

void FileHandling::CalculateValues()
{
        minimum=vec[0];
        maximum=vec[0];

        for(int counter=0; counter<numRecords; counter++) //sum up whole vector
        {       
                sum+=vec[counter];
                if (vec[counter]<minimum)
                        minimum=vec[counter];
                if (vec[counter]>maximum)
                        maximum=vec[counter];
        }
        average=sum/numRecords;
}//CalculateValues

void FileHandling::printdata() const
{
        cout<<"**** FILE AUDIT RESULTS ***"<<endl
                <<"Total records:"<< numRecords <<endl
                <<"Sum: "<<sum<<endl<<"Average of the records: "<< average<<endl
                <<"Minimum value found: "<<minimum<<endl<<"Maximum value found: "<<maximum<<endl;
}//printdata

---

main CPP

Code:

---

#include "FileHandling.h"

void displayinfo(){
cout << "----------------------------------------" << endl;
cout << endl<<endl;
}


int main()
{
        displayinfo();
        try
        {
                FileHandling operations;
                operations.ReadFile("data.txt");
                operations.CalculateValues();
                operations.printdata();
        }
        //catch (int code)
        catch (ERRORS code)
        {
                cerr<<"error code number: "<<code<<endl;
                exit(1);
        }
        return 0;
}

---

An attached working file should of course be called data.txt
otherwise one of the errors occurs.

Perhaps this:

Code:

---

public:
        FileHandling();
        ~FileHandling();
        void ReadFile(const string& filename) throw(int);
        void CalculateValues();
    void printdata() const;

        //static const int NoSuchFile=1;
        //static const int BadNumberOfRows=2;
        //static const int WrongNumberOfLinesInHeader=3;
        //static const int ErrGetLine=4;
       
};

---

Code:

---

void FileHandling::ReadFile(const string& filename) throw(int)

---

Again you are saying you would throw int's. Either don't use a throw specification at all or be honest about it. The compiler won't forgive.

Concerning error specifications, you are using new which might throw std::bad_alloc, so the specs are wrong.

Instead of allocating memory with new you should use a std::vector, or otherwise you'll leak the allocated memory when the function throws (or handle that clean-up manually - your choice).

Quote:

---

Originally Posted by Todd Burch

Perhaps this:

Code:

---

public:
        FileHandling();
        ~FileHandling();
        void ReadFile(const string& filename) throw(int);
        void CalculateValues();
    void printdata() const;

        //static const int NoSuchFile=1;
        //static const int BadNumberOfRows=2;
        //static const int WrongNumberOfLinesInHeader=3;
        //static const int ErrGetLine=4;
       
};

---

---

Really good idea, which I was sure will solve the problem...But most unfortunatly it didn't...Bummer...

Code:

---

void ReadFile(const string& filename) throw(ERRORS);
void FileHandling::ReadFile(const string& filename) throw(ERRORS)

---

Do you still get the same issue if you remove the throw specifications?

A couple notes on your code. First, you should still change the if (!numberOfRows) part. It will work better now that you have initialized the variable, but it isn't as correct as it could be.

Second, you should probably be using the string class instead of C style strings unless you have a specific reason for limiting lines to 80 characters or less. The string class is generally safer and easier to use than C style strings, and in this case you wouldn't have to limit line length to 80 characters.

Third, you should use the standard vector container rather than a dynamic array of doubles for your vec array, unless your class/instructor requires you not to. The reason is that the vector container is safer and easier to use than a plain dynamic array. For example, your code will crash if you create a FileHandling object but don't call ReadFile, or if you try to copy a FileHandling object. If you used a vector, then you probably wouldn't have either of those bugs.

Quote:

---

Originally Posted by Daved

Do you still get the same issue if you remove the throw specifications?

A couple notes on your code. First, you should still change the if (!numberOfRows) part. It will work better now that you have initialized the variable, but it isn't as correct as it could be.

Second, you should probably be using the string class instead of C style strings unless you have a specific reason for limiting lines to 80 characters or less. The string class is generally safer and easier to use than C style strings, and in this case you wouldn't have to limit line length to 80 characters.

Third, you should use the standard vector container rather than a dynamic array of doubles for your vec array, unless your class/instructor requires you not to. The reason is that the vector container is safer and easier to use than a plain dynamic array. For example, your code will crash if you create a FileHandling object but don't call ReadFile, or if you try to copy a FileHandling object. If you used a vector, then you probably wouldn't have either of those bugs.

---

The problem is caused while performing the throws...I can't check otherwise because I have no other way to control errors rather than try-catch...

About the other issues, thank you, and yes these are the requirements of this stupid exarcise. I'm not familiar with catch=throw becuase I usually work with win32 and now I'm taking c++ course and should learn all the console abilities.

The throw specification is the part at the end of the function declaration:

Code:

---

void ReadFile(const string& filename) throw(int);

---

I just meant to remove those, since those aren't mandatory and you can still use try/catch/throw without them (and many would suggest that you not use them).

Quote:

---

Originally Posted by anon

Code:

---

void FileHandling::ReadFile(const string& filename) throw(int)

---

Again you are saying you would throw int's. Either don't use a throw specification at all or be honest about it. The compiler won't forgive.

Concerning error specifications, you are using new which might throw std::bad_alloc, so the specs are wrong.

Instead of allocating memory with new you should use a std::vector, or otherwise you'll leak the allocated memory when the function throws (or handle that clean-up manually - your choice).

---

You're right , but not thoroughly. I use new only after those two first throws, and the error happens on the first throw, before using new...

Quote:

---

Originally Posted by Daved

The throw specification is the part at the end of the function declaration:

Code:

---

void ReadFile(const string& filename) throw(int);

---

I just meant to remove those, since those aren't mandatory and you can still use try/catch/throw without them (and many would suggest that you not use them).

---

I already tried changing it. (#27) and it didn't work...

Did you try removing it? Like this:

Code:

---

void ReadFile(const string& filename);

---

Quote:

---

Originally Posted by Daved

Did you try removing it? Like this:

Code:

---

void ReadFile(const string& filename);

---

---

Yep. Still, the same problem. While performing throw it says

Unhandled exception at 0x00435768 in HW0.exe: 0xC0000005: Access violation reading location 0xccccccc0.

and shows me dbgdel.cpp, with a line contains "_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));"

I tried running the code and found the problem. The issue was the same as the crash I mentioned earlier when you create a FileHandling object but don't call ReadFile. When you exit from ReadFile early (before the dynamic array is created) you get the same problem, it causes a crash when the FileHandling object is destroyed.

The reason is that you don't initialize vec, so when the destructor tries to delete it then it tries to call delete on a garbage memory location. The best solution of course is to use the vector class. But if you aren't allowed to, then just initialize vec to 0 in the constructor and the delete will not cause any problems if it is never set to another value.

Also, if you must keep the dynamic array, you should disable copying so that you don't get crashes when your class is copied.

Quote:

---

Originally Posted by Daved

I tried running the code and found the problem. The issue was the same as the crash I mentioned earlier when you create a FileHandling object but don't call ReadFile. When you exit from ReadFile early (before the dynamic array is created) you get the same problem, it causes a crash when the FileHandling object is destroyed.

The reason is that you don't initialize vec, so when the destructor tries to delete it then it tries to call delete on a garbage memory location. The best solution of course is to use the vector class. But if you aren't allowed to, then just initialize vec to 0 in the constructor and the delete will not cause any problems if it is never set to another value.

Also, if you must keep the dynamic array, you should disable copying so that you don't get crashes when your class is copied.

---

You little... :-)))
Oh man...you're the best. It's 1:20Am here, I hardly see, almost lost hope and you did it. You've got no idea how much I thank you.

Another thing: you use delete, but new[]. You must match the array and non-array forms of new and delete correctly. If you allocate with new[], you must deallocate with delete[].

Quote:

---

Originally Posted by CornedBee

Another thing: you use delete, but new[]. You must match the array and non-array forms of new and delete correctly. If you allocate with new[], you must deallocate with delete[].

---

Correct! Thanks!

Another note about throw(type):
Visual Studio doesn't support throw(type), so rather you should use throw(...) if anything at all. Unless you don't want your code to compile with Visual Studio.

The code will compile fine, it will just generate warnings. If you want exception specifications for whatever reason, then you'll have no problems porting your code to Visual Studio.

throw(int) doesn't work.
throw(...) does, though.
Visual Studio doesn't support throw(type) specifications, for whatever reason...

It compiles and runs for me (VC++ 7.1). Not sure why you think it doesn't work.

OK, so that's weird because I'm sure it didn't work in 2005.
In 2008 I just get a warning that the compiler ignores it because it's not implemented.