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?

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 can&#39;t export signed or unsigned application package

    *Export Aborted
    Export aborted because fatal Lin error were founds. These are listed in the
    problems view. Either fix these before running Export Again, or turn off &quot;Run
    full error check when exporting app&quot; in the Android &gt; Lint Error Cheking preference page.*

----

**Solution**:

    Window&gt;Preferences&gt;Android&gt;Lint Error Checking
    
    uncheck Run full error check when exporting app

Android Export aborted because fatal error were founds

I have below a simple program:

    #include &lt;stdio.h&gt;
    
    #define INT32_MIN        (-0x80000000)
    
    int main(void) 
    {
    	long long bal = 0;
    	
    	if(bal &lt; INT32_MIN )
    	{
    		printf(&quot;Failed!!!&quot;);
    	}
    	else
    	{
    		printf(&quot;Success!!!&quot;);
    	}
    	return 0;
    }

The condition `if(bal &lt; INT32_MIN )` is always true. How is it possible?

It works fine if I change the macro to:

    #define INT32_MIN        (-2147483648L)

Can anyone point out the issue?

Why is 0 &lt; -0x80000000?

In the book &quot;Complete Reference of C&quot; it is mentioned that `char` is by default unsigned.

But I am trying to verify this with GCC as well as Visual Studio. It is taking it as *signed* by default.

Which one is correct?

Is char signed or unsigned by default?

Does this code always evaluate to false? Both variables are two&#39;s complement signed ints.

    ~x + ~y == ~(x + y)

I feel like there should be some number that satisfies the conditions. I tried testing the numbers between `-5000` and `5000` but never achieved equality. Is there a way to set up an equation to find the solutions to the condition? 

Will swapping one for the other cause an insidious bug in my program?



~x + ~y == ~(x + y) is always false?

I want to convert a hex string to a 32 bit signed integer in C++.  

So, for example, I have the hex string &quot;fffefffe&quot;.  The binary representation of this is 11111111111111101111111111111110.  The signed integer representation of this is: -65538.  

How do I do this conversion in C++?  This also needs to work for non-negative numbers.  For example, the hex string &quot;0000000A&quot;, which is 00000000000000000000000000001010 in binary, and 10 in decimal.

C++ convert hex string to signed integer

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”?

[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

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

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

At first glance, this question may seem like a duplicate of https://stackoverflow.com/questions/199333/best-way-to-detect-integer-overflow-in-c-c, however it is actually significantly different.

I&#39;ve found that while detecting an unsigned integer overflow is pretty trivial, detecting a *signed* overflow in C/C++ is actually more difficult than most people think.

The most obvious, yet naive, way to do it would be something like:

    int add(int lhs, int rhs)
    {
     int sum = lhs + rhs;
     if ((lhs &gt;= 0 &amp;&amp; sum &lt; rhs) || (lhs &lt; 0 &amp;&amp; sum &gt; rhs)) {
      /* an overflow has occurred */
      abort();
     }
     return sum; 
    }

The problem with this is that according to the C standard, signed integer overflow is *undefined behavior.*  In other words, according to the standard, as soon as you even cause a signed overflow, your program is just as invalid as if you dereferenced a null pointer.  So you can&#39;t cause undefined behavior, and then try to detect the overflow after the fact, as in the above post-condition check example.

Even though the above check is likely to work on many compilers, you can&#39;t count on it.  In fact, because the C standard says signed integer overflow is undefined, some compilers (like GCC) will [optimize away the above check][1] when optimization flags are set, because the compiler assumes a signed overflow is impossible.  This totally breaks the attempt to check for overflow.

So, another possible way to check for overflow would be:

    int add(int lhs, int rhs)
    {
     if (lhs &gt;= 0 &amp;&amp; rhs &gt;= 0) {
      if (INT_MAX - lhs &lt;= rhs) {
       /* overflow has occurred */
       abort();
      }
     }
     else if (lhs &lt; 0 &amp;&amp; rhs &lt; 0) {
      if (lhs &lt;= INT_MIN - rhs) {
       /* overflow has occurred */
       abort();
      }
     }
     
     return lhs + rhs;
    }

This seems more promising, since we don&#39;t actually add the two integers together until we make sure in advance that performing such an add will not result in overflow.  Thus, we don&#39;t cause any undefined behavior.  

However, this solution is unfortunately a lot less efficient than the initial solution, since you have to perform a subtract operation just to test if your addition operation will work.  And even if you don&#39;t care about this (small) performance hit, I&#39;m still not entirely convinced this solution is adequate.  The expression `lhs &lt;= INT_MIN - rhs` seems exactly like the sort of expression the compiler might optimize away, thinking that signed overflow is impossible.  

So is there a better solution here?  Something that is guaranteed to 1) not cause undefined behavior, and 2) not provide the compiler with an opportunity to optimize away overflow checks?  I was thinking there might be some way to do it by casting both operands to unsigned, and performing checks by rolling your own two&#39;s-complement arithmetic, but I&#39;m not really sure how to do that.

  [1]: http://patrakov.blogspot.com/2008_10_01_archive.html

Detecting signed overflow in C/C++

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?

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 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)?

When I switched from my debug map key to my signed map key my maps stop working. I get the following errors in logcat:


    09-03 18:18:04.112: WARN/System.err(4073): IOException processing: 26
    09-03 18:18:04.112: WARN/System.err(4073): java.io.IOException: Server returned: 3
    09-03 18:18:04.112: WARN/System.err(4073):     at android_maps_conflict_avoidance.com.google.googlenav.map.BaseTileRequest.readResponseData(BaseTileRequest.java:115)
    09-03 18:18:04.112: WARN/System.err(4073):     at android_maps_conflict_avoidance.com.google.googlenav.map.MapService$MapTileRequest.readResponseData(MapService.java:1473)
    09-03 18:18:04.112: WARN/System.err(4073):     at android_maps_conflict_avoidance.com.google.googlenav.datarequest.DataRequestDispatcher.processDataRequest(DataRequestDispatcher.java:1117)
    09-03 18:18:04.112: WARN/System.err(4073):     at android_maps_conflict_avoidance.com.google.googlenav.datarequest.DataRequestDispatcher.serviceRequests(DataRequestDispatcher.java:994)
    09-03 18:18:04.112: WARN/System.err(4073):     at android_maps_conflict_avoidance.com.google.googlenav.datarequest.DataRequestDispatcher$DispatcherServer.run(DataRequestDispatcher.java:1702)
    09-03 18:18:04.112: WARN/System.err(4073):     at java.lang.Thread.run(Thread.java:1019)

I&#39;ve double checked everything, permissions and library are in place. I&#39;ve recreated the singed key and no luck. 

Any ideas?


Google map signed api key errors in Android

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)

All Signed Solutions on Gang of Coders

Total of 19 Signed Solutions

When should I just use "int" versus more sign-specific or size-specific types?