Compiler errors

Hey,

These seem like simple compiler errors but I have been unable to figure them out. Here are the errors I am getting:

Code:

5 routeData.h expected init-declarator before '<' token 
5 routeData.h expected `,' or `;' before '<' token 
6 routeData.h expected init-declarator before '<' token 
6 routeData.h expected `,' or `;' before '<' token 
7 routeData.h expected init-declarator before '<' token 
7 routeData.h expected `,' or `;' before '<' token 
8 routeData.h expected init-declarator before '<' token 
8 \routeData.h expected `,' or `;' before '<' token 
20 routeData.h expected `;' before '(' token 
22 routeData.h `iLst' does not name a type

My code is:

Code:

#ifndef ROUTE
#define ROUTE
#include <set>
#include <list>
typedef set<int>		    iSet; // line 5
typedef list<int> 		    iLst; // line 6
typedef set<int>::iterator	iSetPtr; // line 7
typedef list<int>::iterator	iLstPtr; // line 8

using namespace std;

class routeData
{
    public:
	
    	int readRouteData(istream & inSource);
    
    	int distance(int first, int second);
    
    	int distance(iLst route); // line 20
    
    	iLst bestRoute(iLst done, iSet left); // line 22
};

#endif

You want to move your "using namespace std" to before where you start declaring your types from that namespace.

--
Mats

Better yet would be to remove the namespace directive altogether from the header file, since such practice is very bad form.

Use the std:: prefix to all your standard namespace references.

Thanks!

One new one (a warning):

Code:

int routeData::readRouteData(istream & inSource)
{
    string temp;
    istringstream sstr;
    int ii;
    while(getline(inSource, temp))
    {
        // make sure string only contains digits and whitespace
        for(int aa = 0; aa < temp.length(); aa++) // line 20
        {
            if((!(isdigit(temp[aa]))) && (temp[aa] != ' '))
            {
                cerr << "Bad input on line ";
                exit(1);
            }
        }
    }
        
    return 0;
}

Code:

20 routeData.cpp [Warning] comparison between signed and unsigned integer expressions

Make aa a string::size_type, since that is the type returned by length().

or you can take the warning literally and make aa unsigned:

Code:

for(unsigned int aa = 0; aa < temp.length(); aa++)

I am not sure if that is a good practice though.

Originally Posted by cyberfish

or you can take the warning literally and make aa unsigned:

Code:

for(unsigned int aa = 0; aa < temp.length(); aa++)

I am not sure if that is a good practice though.

I'm guessing that would only suppress the warning if string::size_type is actually the same as unsigned int on the given platform (on a 64-bit box they might not be, for example). Also, the former is about the same number of characters to type anyway and is always the correct type.

Originally Posted by robatino

I'm guessing that would only suppress the warning if string::size_type is actually the same as unsigned int on the given platform (on a 64-bit box they might not be, for example). Also, the former is about the same number of characters to type anyway and is always the correct type.

Not only bitness of the system. Let's say for example that the current architecture has a performance problem with unsigned numbers [say for example they need to be promoted to unsigned long long and then compared], there would be a good argument for someone implementing that particular compiler to change the size_type to signed.

--
Mats

Originally Posted by Beowolf

Code:

20 routeData.cpp [Warning] comparison between signed and unsigned integer expressions

To clarify:
This is because you're comparing a signed and unsigned integer (which is not possible AFAIK). The compiler will convert both types to either signed or unsigned, not sure which.
To avoid this warning, only compare an unsigned integer to an unsigned and the same to signed. If you have one signed and one unsigned, cast one of them to unsigned/signed so you're comparing two of the same type.

> there would be a good argument for someone implementing that particular compiler to change the size_type to signed.

I'm fairly sure that the Standard guarantees that not only std::size_t but any of the size_type's are always some unsigned integral type, so that's not an option.

Yes, and this is only a problem when one of the numbers MAY be signed - if you know for sure that both numbers [despite one of them being signed] can never be (validly) negative, then you can safely ignore the warning.

--
Mats

Originally Posted by matsp

Yes, and this is only a problem when one of the numbers MAY be signed - if you know for sure that both numbers [despite one of them being signed] can never be (validly) negative, then you can safely ignore the warning.

--
Mats

Or cast one to unsigned so the compiler shuts up

Originally Posted by Elysia

Or cast one to unsigned so the compiler shuts up

Well, that is indeed a form of ignoring the warning. If one number is signed and the other unsigned and they both can be the full range of values, then there is no safe way to compare the values by casting. You will have to extend the size to the next level [e.g. going to (signed) long or long long] so that the unsigned number doesn't change sign.

JUST adding a cast without understanding the full usage of the two numbers isn't safe!

--
Mats