negative number evaluating greater than string.size()

[Jason]

Hi, below is example code which demonstrates a problem I have encountered.
When passing a number to a function I compare it with a string's size and
then take certain actions, unfortunately during the testing of it I
discovered that negative numbers were being treated as if they were > 0. I
compiled the following on mingw compiler/dev c++/windows xp.

If I replace string.size() for a ordinary number it behaves as expected? I
notice string.size() returns size type and not an int but how do I deal with
that?

Thanks in advance for any help

#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;

void something(int);

int main()
{
something(-1);
system("PAUSE") ;
return 0;
}

void something(int number) {
string str = "sdfjksdflksdjf kjsklfjsklfj";
if(number < str.size()) { cout << " hello" << endl; }
else { cout << " eek" << endl; }
}

[Gianni Mariani]

Jason wrote:

Hi, below is example code which demonstrates a problem I have encountered.
When passing a number to a function I compare it with a string's size and
then take certain actions, unfortunately during the testing of it I
discovered that negative numbers were being treated as if they were > 0. I
compiled the following on mingw compiler/dev c++/windows xp.

If I replace string.size() for a ordinary number it behaves as expected? I
notice string.size() returns size type and not an int but how do I deal with
that?

Thanks in advance for any help

GCC sez:

signed_probs.cp p: In function `void something(int)' :
signed_probs.cp p:17: warning: comparison between signed and unsigned
integer expressions

Changing line 17 to :

if(number < static_cast<int >(str.size()) ) { cout << " hello" << endl; }

solves the problem.

[John Harrison]

"Jason" <ja***********@ btinternet.com> wrote in message
news:c1******** **@titan.btinte rnet.com...

Hi, below is example code which demonstrates a problem I have encountered.
When passing a number to a function I compare it with a string's size and
then take certain actions, unfortunately during the testing of it I
discovered that negative numbers were being treated as if they were > 0. I compiled the following on mingw compiler/dev c++/windows xp.

If I replace string.size() for a ordinary number it behaves as expected? I notice string.size() returns size type and not an int but how do I deal with that?

Suggest you read the recent thread 'time to get rid of unsigned?', started
on 17/02/04.

john

[John Harrison]

"Gianni Mariani" <gi*******@mari ani.ws> wrote in message
news:c1******** @dispatch.conce ntric.net...

Jason wrote:

Hi, below is example code which demonstrates a problem I have encountered. When passing a number to a function I compare it with a string's size and then take certain actions, unfortunately during the testing of it I
discovered that negative numbers were being treated as if they were > 0. I compiled the following on mingw compiler/dev c++/windows xp.

If I replace string.size() for a ordinary number it behaves as expected? I notice string.size() returns size type and not an int but how do I deal with that?

Thanks in advance for any help

GCC sez:

signed_probs.cp p: In function `void something(int)' :
signed_probs.cp p:17: warning: comparison between signed and unsigned
integer expressions

Changing line 17 to :

if(number < static_cast<int >(str.size()) ) { cout << " hello" << endl; }

solves the problem.

Of course this is what the OP should do, but notice that the solution
effectively rules out strings where size() > INT_MAX. So why design for such
strings in the first place? Why not have size() return an int?

john

[lilburne]

John Harrison wrote:

"Gianni Mariani" <gi*******@mari ani.ws> wrote in message
news:c1******** @dispatch.conce ntric.net...

signed_probs.c pp: In function `void something(int)' :

signed_probs. cpp:17: warning: comparison between signed and unsigned
integer expressions

Changing line 17 to :

if(number < static_cast<int >(str.size()) ) { cout << " hello" << endl; }

solves the problem.

Of course this is what the OP should do, but notice that the solution
effectively rules out strings where size() > INT_MAX. So why design for such
strings in the first place? Why not have size() return an int?

Because its more flexible to have a type where someone can
hold a string thats over 2Gb in size. I remember something
like this being used as a justification for making size_t
unsigned some 15 years back, either in GCC documentation or
the "Standard C library", in relation to malloc().

Naturally someone will tell you that you should be coding
everything that deals with sizes and lengths with size_t.

[John Harrison]

"lilburne" <li******@godzi lla.net> wrote in message
news:c1******** *****@ID-179504.news.uni-berlin.de...

John Harrison wrote:

"Gianni Mariani" <gi*******@mari ani.ws> wrote in message
news:c1******** @dispatch.conce ntric.net...

signed_probs.c pp: In function `void something(int)' :

signed_probs. cpp:17: warning: comparison between signed and unsigned
integer expressions

Changing line 17 to :

if(number < static_cast<int >(str.size()) ) { cout << " hello" << endl; }
solves the problem.
Of course this is what the OP should do, but notice that the solution
effectively rules out strings where size() > INT_MAX. So why design for such strings in the first place? Why not have size() return an int?

Because its more flexible to have a type where someone can
hold a string thats over 2Gb in size. I remember something
like this being used as a justification for making size_t
unsigned some 15 years back, either in GCC documentation or
the "Standard C library", in relation to malloc().

Interestingly the following code

int main()
{
std::string s;
std::cout << std::hex << s.max_size() << '\n';
}

when compiled with gcc 3.3.1 prints

3ffffffc

I don't think its a serious limitation to restrict yourself to strings which
occupy less than half of the available memory.

Naturally someone will tell you that you should be coding
everything that deals with sizes and lengths with size_t.

But what happens when you need to subtract one size from another? What type
should be used to hold the type of that operation? I don't think there is a
good answer.

john

[John Harrison]

> What type should be used to hold the type of that operation?

I meant

What type should be used to hold the result of that operation?

[Rolf Magnus]

lilburne wrote:

Of course this is what the OP should do, but notice that the solution
effectively rules out strings where size() > INT_MAX. So why design
for such strings in the first place? Why not have size() return an
int?

Because its more flexible to have a type where someone can
hold a string thats over 2Gb in size.

I think it's not. You'd run into troubles if you need to calculate
offsets between two characters in your string. That offset might be
negative. Now you can't represent all possible offests anymore, no
matter whether you make the type for that offset signed or unsigned.
And further, if you mix signed and unsigned in your calculations, you
have to be very careful.

[Andre Kostur]

"John Harrison" <jo************ *@hotmail.com> wrote in news:c13cvl$1ds kq6$1
@ID-196037.news.uni-berlin.de:

What type should be used to hold the type of that operation?

I meant

What type should be used to hold the result of that operation?

size_t, assuming the programmer has done the sane thing and checked that
they are actually subtracting the smaller from the larger.

[Andrey Tarasevich]

John Harrison wrote:

...
Changing line 17 to :

if(number < static_cast<int >(str.size()) ) { cout << " hello" << endl; }

solves the problem.

Of course this is what the OP should do, but notice that the solution
effectively rules out strings where size() > INT_MAX. So why design for such
strings in the first place? Why not have size() return an int?
...

In my opinion, using a signed type to store an unsigned quantity is a
low-level design error. For this reason, in many practical applications
signed types in C/C++ are much less useful than unsigned types. And
'size()' must return an unsigned value.

As for correcting the OP's code, I would suggest doing it differently

if (number < 0 || (std::string::s ize_type) number < str.size())
{ cout << " hello" << endl; }

--
Best regards,
Andrey Tarasevich