What is the correct way of iterating over a vector in C++?

Consider these two code fragments, this one works fine:

    for (unsigned i=0; i &lt; polygon.size(); i++) {
        sum += polygon[i];
    }

and this one:

    for (int i=0; i &lt; polygon.size(); i++) {
        sum += polygon[i];
    }

which generates `warning: comparison between signed and unsigned integer expressions`.

I&#39;m new in the world of C++, so the `unsigned` variable looks a bit frightening to me and I know `unsigned` variables can be dangerous if not used correctly, so - is this correct?


Iteration over std::vector: unsigned vs signed index variable

Am I correct to say the difference between a signed and unsigned integer is:

1. Unsigned can hold a larger positive value and no negative value.
2. Unsigned uses the leading bit as a part of the value, while the signed version uses the left-most-bit to identify if the number is positive or negative.
3. Signed integers can hold both positive and negative numbers.

Any other differences?

Signed versus Unsigned Integers

I can never understand how to print `unsigned long` datatype in C.

Suppose `unsigned_foo` is an `unsigned long`, then I try:

* `printf(&quot;%lu\n&quot;, unsigned_foo)`
* `printf(&quot;%du\n&quot;, unsigned_foo)`
* `printf(&quot;%ud\n&quot;, unsigned_foo)`
* `printf(&quot;%ll\n&quot;, unsigned_foo)`
* `printf(&quot;%ld\n&quot;, unsigned_foo)`
* `printf(&quot;%dl\n&quot;, unsigned_foo)`

And all of them print some kind of `-123123123` number instead of `unsigned long` that I have.

How to printf &quot;unsigned long&quot; in C?

Why doesn&#39;t Java include support for unsigned integers?  

It seems to me to be an odd omission, given that they allow one to write code that is less likely to produce overflows on unexpectedly large input.  

Furthermore, using unsigned integers can be a form of self-documentation, since they indicate that the value which the unsigned int was intended to hold is never supposed to be negative.  

Lastly, in some cases, unsigned integers can be more efficient for certain operations, such as division.  

What&#39;s the downside to including these?

Why doesn&#39;t Java support unsigned ints?

Is there a way to declare an unsigned int in Java?

Or the question may be framed as this as well:
What is the Java equivalent of unsigned?

_Just to tell you the context I was looking at Java&#39;s implementation of `String.hashcode()`. I wanted to test the possibility of collision if the integer were 32 unsigned int._


Declaring an unsigned int in Java

I am trying to convert a signed byte in unsigned. The problem is the data I am receiving is unsigned and Java does not support unsigned byte, so when it reads the data it treats it as signed.

I tried it to convert it by the following solution I got from Stack&amp;nbsp;Overflow.

    public static int unsignedToBytes(byte a)
    {
        int b = a &amp; 0xFF;
        return b;
    }

But when again it&#39;s converted in byte, I get the same signed data. I am trying to use this data as a parameter to a function of Java that accepts only a byte as parameter, so I can&#39;t use any other data type. How can I fix this problem?


Can we make unsigned byte in Java

So I know that the difference between a `signed int` and `unsigned int` is that a bit is used to signify if the number if positive or negative, but how does this apply to a `char`? How can a character be positive or negative?

Difference between signed / unsigned char

I know, the question seems to be strange. Programmers sometimes think too much. Please read on...

In C I use `signed` and `unsigned` integers a lot. I like the fact that the compiler warns me if I do things like assigning a signed integer to an unsigned variable. I get warnings if I compare signed with unsigned integers and much much more.

I like these warnings. They help me to keep my code correct.

Why don&#39;t we have the same luxury for floats? A square-root will definitely never return a negative number. There are other places as well where a negative float value has no meaning. Perfect candidate for an unsigned float.

Btw - I&#39;m not really keen about the single extra bit of precision that I could get by removing the sign bit from the floats. I&#39;m super happy with `float`s as they are right now.  I&#39;d just like to *mark a float as unsigned* sometimes and get the same kind of warnings that I get with integers.


I&#39;m not aware of any programming language that supports unsigned floating-point numbers.

Any idea why they don&#39;t exist?

---

## EDIT:

I know that the x87 FPU has no instructions to deal with unsigned floats. Lets just use the signed float instructions. Misuse (e.g. going below zero) could be considered undefined behaviour in the same way as overflow of signed integers is undefined.


Why doesn&#39;t C have unsigned floats?

I know about `int` and `long` (32-bit and 64-bit numbers), but what are `uint` and `ulong`?

What is the difference between “int” and “uint” / “long” and “ulong”?

I am so confused about `size_t`. I have searched on the internet and everywhere mentioned that `size_t` is an unsigned type so, it can represent only non-negative values.

My first question is: if it is used to represent only non-negative values, why don&#39;t we use `unsigned int` instead of `size_t`?

My second question is: are `size_t` and `unsigned int` interchangeable or not? If not, then why?

And can anyone give me a good example of `size_t` and briefly its workings?

Difference between size_t and unsigned int?

In C++, I enjoyed having access to a 64 bit unsigned integer, via `unsigned long long int`, or via `uint64_t`. Now, in Java longs are 64 bits, I know. However, they are signed.

Is there an unsigned long (long) available as a Java primitive? How do I use it?

Java equivalent of unsigned long long?

I have come across code from someone who appears to believe there is a problem subtracting an unsigned integer from another integer of the same type when the result would be negative. So that code like this would be incorrect even if it happens to work on most architectures.

    unsigned int To, Tf;

    To = getcounter();
    while (1) {
        Tf = getcounter();
        if ((Tf-To) &gt;= TIME_LIMIT) {
            break;
        } 
    }

This is the only vaguely relevant quote from the C standard I could find.

&gt; A computation involving unsigned operands can never overﬂow, because a
&gt; result that cannot be represented by the resulting unsigned integer
&gt; type is reduced modulo the number that is one greater than the largest
&gt; value that can be represented by the resulting type.

I suppose one could take that quote to mean that when the right operand is larger the operation is adjusted to be meaningful in the context of modulo truncated numbers.

i.e.

0x0000 - 0x0001 == 0x **1** 0000 - 0x0001 == 0xFFFF

as opposed to using the implementation dependent signed semantics:

0x0000 - 0x0001 == (unsigned)(0 + -1) == (0xFFFF but also 0xFFFE or 0x8001)

Which or what interpretation is right? Is it defined at all?

Is unsigned integer subtraction defined behavior?

[C++20][1] introduced the `std::ssize()` free function as below:

```c++
template &lt;class C&gt;
    constexpr auto ssize(const C&amp; c)
        -&gt; std::common_type_t&lt;std::ptrdiff_t,
                              std::make_signed_t&lt;decltype(c.size())&gt;&gt;;
```

A possible implementation seems using `static_cast`, to convert the return value of the `size()` member function of cl*ass C* into its signed counterpart.

Since the `size()` member function of C always returns non-negative values, why would anyone want to store them in signed variables? In case one really wants to, it is a matter of simple `static_cast`. 

Why is `std::ssize()` introduced in C++20?

  [1]: https://en.wikipedia.org/wiki/C%2B%2B20


Why is std::ssize() introduced in C++20?

At my code, I do not use int or unsigned int. I only use size_t or ssize_t  for portable. For example:

    typedef size_t intc;    // (instead of unsigned int)
    typedef ssize_t uintc;  // (instead of int)

Because `strlen`, `string`, `vector`... all use `size_t`, so I usually use `size_t`. And I only use `ssize_t` when it may be negative.

But I find that:
&gt;    The unsigned integer types are ideal for uses that treat storage as a bit array. 
    Using an unsigned instead of an int to gain one more bit to represent positive integers is almost never a good idea. 
    Attempts to ensure that some values are positive by declaring variables unsigned will typically be defeated by the implicit conversion rules.

in the book [The C++ Programming Language](http://www.amazon.com/dp/0321563840).

So I am puzzled. Am I wrong? Why does the STL not abide by the suggest on the book?


should use size_t or ssize_t

I&#39;ve seen this `unsigned` &quot;typeless&quot; type used a couple of times, but never seen an explanation for it. I suppose there&#39;s a corresponding `signed` type. Here&#39;s an example:

&lt;pre&gt;&lt;code&gt;static unsigned long next = 1;
/* RAND_MAX assumed to be 32767 */
int myrand(void) {
    next = next * 1103515245 + 12345;
    return((&lt;b&gt;unsigned&lt;/b&gt;)(next/65536) % 32768);
}
void mysrand(&lt;b&gt;unsigned seed&lt;/b&gt;) {
    next = seed;
}&lt;/code&gt;&lt;/pre&gt;

What I have gathered so far:  
- on my system, `sizeof(unsigned) = 4` (hints at a 32-bit unsigned int)  
- it might be used as a shorthand for casting another type to the unsigned version:
&lt;pre&gt;&lt;code&gt;signed long int i = -42;
printf(&quot;%u\n&quot;, (unsigned)i);
&lt;/code&gt;&lt;/pre&gt;

Is this ANSI C, or just a compiler extension?

what is the unsigned datatype?

Does the unsigned keyword default to a specific data type in C++?  I am trying to write a function for a class for the prototype:

    unsigned Rotate(unsigned object, int count)

But I don&#39;t really get what `unsigned` means. Shouldn&#39;t it be like `unsigned int` or something?

Unsigned keyword in C++

Let&#39;s say I have this number `i = -6884376`.
How do I refer to it as to an unsigned variable?
Something like `(unsigned long)i` in C.

How to convert signed to unsigned integer in python

I&#39;m trying to understand why the following code doesn&#39;t issue a warning at the indicated place.

    //from limits.h
    #define UINT_MAX 0xffffffff /* maximum unsigned int value */
    #define INT_MAX  2147483647 /* maximum (signed) int value */
                /* = 0x7fffffff */
    
    int a = INT_MAX;
    //_int64 a = INT_MAX; // makes all warnings go away
    unsigned int b = UINT_MAX;
    bool c = false;
    
    if(a &lt; b) // warning C4018: &#39;&lt;&#39; : signed/unsigned mismatch
        c = true;
    if(a &gt; b) // warning C4018: &#39;&lt;&#39; : signed/unsigned mismatch
        c = true;
    if(a &lt;= b) // warning C4018: &#39;&lt;&#39; : signed/unsigned mismatch
        c = true;
    if(a &gt;= b) // warning C4018: &#39;&lt;&#39; : signed/unsigned mismatch
        c = true;
    if(a == b) // no warning &lt;--- warning expected here
        c = true;
    if(((unsigned int)a) == b) // no warning (as expected)
        c = true;
    if(a == ((int)b)) // no warning (as expected)
        c = true;

I thought it was to do with background promotion, but the last two seem to say otherwise.

To my mind, the first `==` comparison is just as much a signed/unsigned mismatch as the others?

Signed/unsigned comparisons

I was curious to know what would happen if I assign a negative value to an unsigned variable.

The code will look somewhat like this.

    unsigned int nVal = 0;
    nVal = -5;

It didn&#39;t give me any compiler error. When I ran the program the `nVal` was assigned a strange value! Could it be that some 2&#39;s complement value gets assigned to `nVal`?




What happens if I assign a negative value to an unsigned variable?

In the Oracle &quot;Primitive data types&quot; [page](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html), it mentions that Java 8 adds support for unsigned ints and longs: 

&gt;`int`: By default, the `int` data type is a 32-bit signed two&#39;s complement integer, which has a minimum value of −2&lt;sup&gt;31&lt;/sup&gt; and a maximum value of 2&lt;sup&gt;31&lt;/sup&gt;−1. **In Java SE 8 and later, you can use the `int` data type to represent an unsigned 32-bit integer, which has a minimum value of 0 and a maximum value of 2&lt;sup&gt;32&lt;/sup&gt;−1.** Use the `Integer` class to use `int` data type as an unsigned integer. See the section The Number Classes for more information. Static methods like `compareUnsigned`, `divideUnsigned` etc have been added to the `Integer` class to support the arithmetic operations for unsigned integers.
&gt;
&gt;`long`: The `long` data type is a 64-bit two&#39;s complement integer. The signed `long` has a minimum value of −2&lt;sup&gt;63&lt;/sup&gt; and a maximum value of 2&lt;sup&gt;63&lt;/sup&gt;−1. **In Java SE 8 and later, you can use the `long` data type to represent an unsigned 64-bit `long`, which has a minimum value of 0 and a maximum value of 2&lt;sup&gt;64&lt;/sup&gt;−1.** Use this data type when you need a range of values wider than those provided by int. The `Long` class also contains methods like `compareUnsigned`, `divideUnsigned` etc to support arithmetic operations for unsigned `long`.

However, I find no way to declare an unsigned long or integer. The following code, for example, gives a compiler error message of &quot;the literal is out of range&quot; (I&#39;m using Java 8, of course), when it should be in range (the value assigned is precisely 2&lt;sup&gt;64&lt;/sup&gt;−1):

    public class Foo {
        static long values = 18446744073709551615L;
        
        public static void main(String[] args){
            System.out.println(values);
        }  
    }

So, is there any way to declare an unsigned int or long?

How to use the unsigned Integer in Java 8 and Java 9?

Is there any performance gain/loss by using unsigned integers over signed integers?

If so, does this goes for short and long as well?

performance of unsigned vs signed integers

I work with a lot of calculation code written in [tag:C++] with high-performance and low memory overhead in mind. It uses STL containers (mostly `std::vector`) a lot, and iterates over that containers almost in every single function.

The iterating code looks like this:

    for (int i = 0; i &lt; things.size(); ++i)
    {
        // ...
    }

But it produces the **signed/unsigned mismatch** warning (**C4018 in Visual Studio**).

Replacing `int` with some `unsigned` type is a problem because we frequently use `OpenMP` pragmas, and it requires the counter to be `int`.

I&#39;m about to suppress the (hundreds of) warnings, but I&#39;m afraid I&#39;ve missed some elegant solution to the problem.

**On iterators**. I think iterators are great when applied in appropriate places. The code I&#39;m working with will _never_ change random-access containers into `std::list` or something (so iterating with `int i` is already container agnostic), and will _always_ need the current index. And all the additional code you need to type (iterator itself and the index) just complicates matters and obfuscates the simplicity of the underlying code.

How do I deal with &quot;signed/unsigned mismatch&quot; warnings (C4018)?

I am currently writing a C program that requires frequent comparisons of string lengths so I wrote the following helper function:

    int strlonger(char *s1, char *s2) {
        return strlen(s1) - strlen(s2) &gt; 0;
    }

I have noticed that the function returns true even when `s1` has shorter length than `s2`. Can someone please explain this strange behavior?

&quot;strlen(s1) - strlen(s2)&quot; is never less than zero

I have seen these mentioned in the context of C and C++, but what is the difference between signed and unsigned variables? 

What is the difference between signed and unsigned variables?

Why doesn&#39;t C++ support unsigned double syntax?

Unsigned double in C++?

How can I declare an `unsigned short` value in Java?

Unsigned short in Java

For certain hash functions in Java it would be nice to see the value as an unsigned integer (e.g. for comparison to other implementations) but Java supports only signed types.  We can convert a signed `int` to an &quot;unsigned&quot; `long` as such:

&lt;!-- language: lang-java --&gt;

    public static final int BITS_PER_BYTE = 8;
    public static long getUnsignedInt(int x) {
      ByteBuffer buf = ByteBuffer.allocate(Long.SIZE / BITS_PER_BYTE);
      buf.putInt(Integer.SIZE / BITS_PER_BYTE, x);
      return buf.getLong(0);
    }
    getUnsignedInt(-1); // =&gt; 4294967295

However, this solution seems like overkill for what we&#39;re really doing.  Is there a more efficient way to achieve the same thing?

Best way to convert a signed integer to an unsigned long?

In Java, there is no such thing as an unsigned byte.

Working with some low level code, occasionally you need to work with bytes that have unsigned values greater than 128, which causes Java to interpret them as a negative number due to the MSB being used for sign.

What&#39;s a good way to work around this? (Saying don&#39;t use Java is not an option)

What is the best way to work around the fact that ALL Java bytes are signed?

I have a [little VM for a programming language](https://github.com/munificent/wren) implemented in C. It supports being compiled under both 32-bit and 64-bit architectures as well as both C and C++.

I&#39;m trying to make it compile cleanly with as many warnings enabled as possible. When I turn on `CLANG_WARN_IMPLICIT_SIGN_CONVERSION`, I get a cascade of new warnings.

I&#39;d like to have a good strategy for when to use `int` versus either explicitly unsigned types, and/or explicitly sized ones. So far, I&#39;m having trouble deciding what that strategy should be.

It&#39;s certainly true that mixing them—using mostly `int` for things like local variables and parameters and using narrower types for fields in structs—causes lots of implicit conversion problems.

I do like using more specifically sized types for struct fields because I like the idea of explicitly controlling memory usage for objects in the heap. Also, for hash tables, I rely on unsigned overflow when hashing, so it&#39;s nice if the hash table&#39;s size is stored as `uint32_t`.

But, if I try to use more specific types *everywhere*, I find myself in a maze of twisty casts everywhere.

What do other C projects do?




When should I just use &quot;int&quot; versus more sign-specific or size-specific types?

I am wondering whether 

    std::is_unsigned&lt;bool&gt;::value

is well defined according to the standard or not? 

I ask the question because `typename std::make_unsigned&lt;bool&gt;::type` is not well defined.

Is std::is_unsigned&lt;bool&gt;::value well defined?

See this code snippet

    int main()
    { 
     unsigned int a = 1000;
     int b = -1;
     if (a&gt;b) printf(&quot;A is BIG! %d\n&quot;, a-b);
     else printf(&quot;a is SMALL! %d\n&quot;, a-b); 
     return 0;
    }   

This gives the output: a is SMALL: 1001

I don&#39;t understand what&#39;s happening here. How does the &gt; operator work here? Why is &quot;a&quot; smaller than &quot;b&quot;? If it is indeed smaller, why do i get a positive number (1001) as the difference? 


Comparison operation on unsigned and signed integers

I&#39;m working on a page that processes IP address information, but it&#39;s choking on the fact that integers are signed. I am using bitwise operators to speed it up, but the 64th bit (signed/unsigned flag) is messing it up.

Is there any way to force a number to be unsigned in Javascript? It seems to work fine, until subnet is greater than 30, or less than 2.

Try this:

&lt;!-- begin snippet: js hide: false console: true babel: false --&gt;

&lt;!-- language: lang-html --&gt;

    &lt;html&gt;
        &lt;body&gt;
        
        &lt;script type=&#39;text/javascript&#39;&gt;
        document.write( (1 &lt;&lt; 30) +&quot;&lt;br/&gt;&quot;);
        document.write( (1 &lt;&lt; 31) +&quot;&lt;br/&gt;&quot;);
        document.write( (1 &lt;&lt; 32) +&quot;&lt;br/&gt;&quot;);
        &lt;/script&gt;
        
        &lt;/body&gt;
    &lt;/html&gt;

&lt;!-- end snippet --&gt;

Result:

&gt; 1073741824
&gt; -2147483648 
&gt; 1

All Unsigned Solutions on Gang of Coders

Total of 32 Unsigned Solutions