How do unsigned integers work
When you assign a negative number
unsigned int = -1;
The number you got will be 4294967295, or 4^8 -1
because the size of integer is 4bytes, or 4^8 = 4294967296
The integer will wrap around this number if it is negative
How does C store negative numbers in signed vs unsigned integers?
Does it really matter if I declare the value as signed or unsigned int?
Yes.
For example, have a look at
#include <stdio.h>
int main()
{
int a = -4;
int b = -3;
unsigned int c = -4;
unsigned int d = -3;
printf("%f\n%f\n%f\n%f\n", 1.0 * a/b, 1.0 * c/d, 1.0*a/d, 1.*c/b);
}
and its output
1.333333
1.000000
-0.000000
-1431655764.000000
which clearly shows that it makes a huge difference if I have the same byte representation interpreted as signed or unsigned.
C++ - Unsigned integers
The difference between unsigned and signed integers on most platforms is a sign-bit ... other than that, the actual binary value is the same, it's just interpreted two different ways depending on the sign-ness of the type that the binary value represents. So you can definitely "represent" a negative value input as a unsigned value ... it won't be re-interpreted as that value, but it can definitely be input as that value without an error being set on the stream.
Dealing with unsigned integers
A lot of those "you shouldn't use unsigned integers" are just basically scared that you will mix up signed integers and unsigned ones, causing a wrap-around, or to avoid complex integer promotion rules.
But in your code, I see no reason not to use uint32_t
and std::size_t
, because m_X_AxisLen
and m_Y_AxisLen
should not contain negative values, and using uint32_t
and std::size_t
makes a lot more sense here:
So, I suggest changing m_X_AxisLen
and m_Y_AxisLen
to:
std::size_t m_Y_AxisLen;
std::size_t m_X_AxisLen; // for consistency
Change row
and column
to
std::size_t row = 0;
// and
std::size_t column = 0;
Make getX_AxisLen( )
returns an std::size_t
And make the for
loop:
for ( int column = 0; column < getX_AxisLen( ) - 1; ++column )
to:
for ( int column = 0; column + 1 < getX_AxisLen( ); ++column )
Because if getX_AxisLen()
returns 0
, getX_AxisLen( ) - 1
will cause a wrap-around.
Basically, use the thing that makes sense. If a value cannot be negative, use the unsigned
type.
How does C casting unsigned to signed work?
No part of the C standard guarantees that your code shall print -1 in general. As it says, the result of the conversion is implementation-defined. However, the GCC documentation does promise that if you compile with their implementation, then your code will print -1. It's nothing to do with bit patterns, just math.
The clearly intended reading of "reduced modulo 2^N" in the GCC manual is that the result should be the unique number in the range of signed int
that is congruent mod 2^N to the input. This is a precise mathematical way of defining the "wrapping" behavior that you expect, which happens to coincide with what you would get by reinterpreting the bits.
Assuming 32 bits, UINT_MAX
has the value 4294967295. This is congruent mod 4294967296 to -1. That is, the difference between 4294967295 and -1 is a multiple of 4294967296, namely 4294967296 itself. Moreover, this is necessarily the unique such number in [-2147483648, 2147483647]. (Any other number congruent to -1 would be at least -1 + 4294967296 = 4294967295
, or at most -1 - 4294967296 = -4294967297
). So -1 is the result of the conversion.
In other words, add or subtract 4294967296 repeatedly until you get a number that's in the range of signed int
. There's guaranteed to be exactly one such number, and in this case it's -1.
What does signed and unsigned values mean?
A signed integer can represent negative numbers; unsigned cannot.
Signed integers have undefined behavior if they overflow, while unsigned integers wrap around using modulo.
Note that that table is incorrect. First off, it's missing the -
signs (such as -128 to +127). Second, the standard does not guarantee that those types must fall within those ranges.
Related Topics
How to Building Static Qt with Static Openssl
C++: How to Implement Polymorphic Object Creator to Populate a Table
Which Stl Container Should I Use for a Fifo
Video Stabilization with Opencv
How to Tell Cmake to Use Clang on Windows
Determining Exception Type After the Exception Is Caught
Why Does Boost.Asio Not Support an Event-Based Interface
How Many Spaces for Tab Character(\T)
Cross Platform Format String for Variables of Type Size_T
Variadic Deduction Guide Not Taken by G++, Taken by Clang++ - Who Is Correct
Returning a Const Reference to an Object Instead of a Copy
Conventions for Accessor Methods (Getters and Setters) in C++
Using Hierarchy in Findcontours () in Opencv
Pros and Cons of Using Nested C++ Classes and Enumerations