What is the behaviour on converting a negative floating point value into an unsigned int?

Question

What happens if a negative floating point value is converted into a value of unsigned integral type? Standard quotes would be appreciated. The problem I'm facing is conversion into values of unsigned integral types from a variant class, that contains an object of floating-point type.

EXAMPLE:

unsigned i = -.1;

@jtbandes: this is a deep question. It will be, at best, implementation defined. — Bathsheba, Apr 06 '16 at 06:57
@SouravGhosh I would assume the C standard definition of conversion, as explained in chapter 6.3. — Lundin, Apr 06 '16 at 06:57
The code in example is not C :/ is this supposed to be a C or C++ or which question? — Antti Haapala -- Слава Україні, Apr 06 '16 at 07:52
It's easy: there is only one line of code in the question and that line is nonsensical if interpreted at C. This is not a C question. — Pascal Cuoq, Apr 06 '16 at 11:44
OMG people, so I'll change the code, but one could argue, that it is java code now. — user1095108, Apr 06 '16 at 12:03
@user1095108 It's fine as long as you don't tag your question java. — Pascal Cuoq, Apr 06 '16 at 12:08
@Bathsheba Why should `unsigned i = -.1;` (yes it's a new example in the current version of the question) be implementation-defined? The conversion of `-0.1` to `unsigned` is perfectly well defined: http://port70.net/~nsz/c/c11/n1570.html#6.3.1.4p1 Unless you are saying that `0.1` could represent a value that's not between -1 exclusive and 0 inclusive — Pascal Cuoq, Apr 06 '16 at 12:15
My understanding (and I'm not an expert on this, I learned the answer "parrot fashion" when I was at university), that anything on and above -1.0 is fine (so long as you don't exceed the unsigned size), but all values below -1.0 are UB. I think the little negative portion is to allow for boolean representations. — Bathsheba, Apr 06 '16 at 12:17

Lundin · Accepted Answer · 2016-04-07T06:37:45.100

41

In case the negative value is -1.0 or lower, it invokes undefined behavior since the integral part then cannot be represented by an unsigned number. Otherwise, (as in the case of -0.1), if it can be represented by an integer type, it is well-defined behavior. See the C11 standard, ISO 9899:2011:

6.3.1.4

When a finite value of real floating type is converted to an integer type other than _Bool, the fractional part is discarded (i.e., the value is truncated toward zero). If the value of the integral part cannot be represented by the integer type, the behavior is undefined. 61)

And then there is a non-normative foot note explaining the above text:

61) The remaindering operation performed when a value of integer type is converted to unsigned type need not be performed when a value of real floating type is converted to unsigned type. Thus, the range of portable real floating values is (−1, Utype_MAX+1).

ISO/IEC 9899:1999 (C99) contains exactly the same text.

edited Apr 07 '16 at 06:37

answered Apr 06 '16 at 06:56

Lundin

195,001
40
254
396

2

Is that the C standard? Actually I've noticed the question is multi-tagged. Have an upvote. – Bathsheba Apr 06 '16 at 06:57
1

@Bathsheba the question is labeled both C and C++ so either standard would be relevant. But it's a good question. – Mark Ransom Apr 06 '16 at 06:57
7

@Lundin but the question explicitly does -.1, which, truncated would be representable. – Antti Haapala -- Слава Україні Apr 06 '16 at 07:51
9

As Antti points out `(unsigned)-.1` is within the range (−1, Utype_MAX+1), so this particular case is not undefined behaviour. We could re-write the answer pedantically, ***With the execption of negative values above -1.0**, it invokes undefined behaviour*. – Toby Speight Apr 06 '16 at 10:24
3

@TobySpeight Perhaps you mean "With the execption of negative values **below/less than** -1.0" – nalzok Apr 06 '16 at 16:37
1

@sunqingyao The range (-1, Utype_MAX+1) is exclusive at both ends (inclusive would have been notated with square brackets [,]), so the inequality is in fact `<= 1.0`. – Iwillnotexist Idonotexist Apr 06 '16 at 16:49
1

@sun, of course not - values of -1.0 and less produce undefined behaviour. Values strictly between -1.0 and UINT_MAX+1 have specified behaviour. [atturri's answer](/a/36443699/4850040) phrases it better... – Toby Speight Apr 06 '16 at 16:59
@TobySpeight I mean -0.5 is above -1.0, because it's **greater** than the later. – nalzok Apr 06 '16 at 17:30
@sun - Yes, -0.5 is a value above -1.0, so *it's an exception* to the statement, "it invokes undefined behaviour". As I said, atturri's wording is better than mine ("it is undefined ... if the [number] is less than or equal to -1.0") – Toby Speight Apr 06 '16 at 17:36
1

A later answer sites the same standard paragraphs and points out that it is well defined. Your opening sentence contradicts the evidence you give! – JDługosz Apr 07 '16 at 03:08
I changed the wording of this answer. – Lundin Apr 07 '16 at 06:38

atturri · Answer 2 · 2016-04-06T07:09:32.310

It is undefined behaviour in C99 if the floating point number is less than or equal to -1.0. If it's in the range (-1.0, 0.0), the resulting value will be 0.

From C99, §6.3.1.4, paragraph 1

When a finite value of real floating type is converted to an integer type other than _Bool, the fractional part is discarded (i.e., the value is truncated toward zero). If the value of the integral part cannot be represented by the integer type, the behavior is undefined

Footnote 50 clarifies the behaviour for the (-1.0, 0.0) range.

score 5 · Answer 3 · edited Apr 06 '16 at 17:03

Your example, unsigned i = -.1; is well-defined by both C11 and C99, and the result is i == 0.

Quoted from N1570, 6.3.1.4 Real floating and integer:

When a finite value of real floating type is converted to an integer type other than _Bool, the fractional part is discarded (i.e., the value is truncated toward zero). If the value of the integral part cannot be represented by the integer type, the behavior is undefined.61)

_{61) The remaindering operation performed when a value of integer
type is converted to unsigned type need not be performed when a value
of real floating type is converted to unsigned type. Thus, the range
of portable real floating values is (-1, Utype_MAX+1).}

Quoted from N869, 6.3.1.4 Real floating and integer:

#1

When a finite value of real floating type is converted to an integer type other than _Bool, the fractional part is discarded (i.e., the value is truncated toward zero). If the value of the integral part cannot be represented by the integer type, the behavior is undefined.43)

_{43)The remaindering operation performed when a value of integer
type is converted to unsigned type need not be performed when a value
of real floating type is converted to unsigned type. Thus, the range
of portable real floating values is (-1, Utype_MAX+1).}

However, as you can see from the quotations, trying to convert floating-point constants outside the range (-1, Utype_MAX+1) invokes undefined behaviour.

What is the behaviour on converting a negative floating point value into an unsigned int?

3 Answers3

Linked