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

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

HerbalMart
• 1,669
• 3
• 27
• 50
Difference Engine
• 12,025
• 5
• 21
• 11

The primitive data types prefixed with "u" are unsigned versions with the same bit sizes. Effectively, this means they cannot store negative numbers, but on the other hand they can store positive numbers twice as large as their signed counterparts. The signed counterparts do not have "u" prefixed.

The limits for int (32 bit) are:

``````int: –2147483648 to 2147483647
uint: 0 to 4294967295
``````

And for long (64 bit):

``````long: -9223372036854775808 to 9223372036854775807
ulong: 0 to 18446744073709551615
``````
Julius Depulla
• 1,493
• 1
• 12
• 27
Isak Savo
• 34,957
• 11
• 60
• 92
• This is quite fun to work out by hand. A 32-bit signed variable uses 1 bit for the sign (positive or negative) so can store values between -2^31 and +2^31 - 1 – Jaco Pretorius Sep 16 '10 at 08:29
• when comparing int and uint for usage, which one is feasible? – Arun Prasad May 26 '16 at 05:27
• What's the c++ equivalent? – Darkgaze Jan 18 '18 at 17:40
• @JacoPretorius Thats wrong. 8 bit int has a range from –128 to 127. The 9th bit represents 256. So with 8 bits you can represent all values up to 255 (9th val - 1). The range from -128 to 127 has a length of exactly 255. So there is no bit that holds the sign. All values up to 127 are positive. Values above get displayed negative. 255 would be -1. 254 would be -2 and so one way down to 128. – C4d Dec 19 '18 at 11:03
• I think it's also worth noting that specifically for int vs uint, the unsigned integer is not CLS-compliant, and it's recommended to use int as often as possible. – db2 Apr 12 '19 at 15:31

`uint` and `ulong` are the unsigned versions of `int` and `long`. That means they can't be negative. Instead they have a larger maximum value.

```Type    Min                           Max                           CLS-compliant
int     -2,147,483,648                2,147,483,647                 Yes
uint    0                             4,294,967,295                 No
long    –9,223,372,036,854,775,808    9,223,372,036,854,775,807     Yes
ulong   0                             18,446,744,073,709,551,615    No
```

To write a literal unsigned int in your source code you can use the suffix `u` or `U` for example `123U`.

You should not use uint and ulong in your public interface if you wish to be CLS-Compliant.

By the way, there is also short and ushort and byte and sbyte.

Peter Majeed
• 5,304
• 2
• 32
• 57
Mark Byers
• 811,555
• 193
• 1,581
• 1,452
• This is interesting - what do you mean about CLS compliant? The link goes to the MSDN documentation for int. If by "CLS" you mean C# language spec then I don't understand - the spec clearly describes both uint and ulong (section 1.3) – Isak Savo Sep 16 '10 at 10:58
• @Isak Savo: It is important to be CLS-compliant if you are writing interface that could be used by other .NET languages than C#. – Mark Byers Sep 16 '10 at 11:24
• Curious that you mention short and ushort but leave out byte and sbyte :) – Roman Starkov Sep 19 '10 at 12:00

The difference is that the `uint` and `ulong` are unsigned data types, meaning the range is different: They do not accept negative values:

``````int range: -2,147,483,648 to 2,147,483,647
uint range: 0 to 4,294,967,295

long range: –9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
ulong range: 0 to 18,446,744,073,709,551,615
``````
Peter Mortensen
• 30,738
• 21
• 105
• 131
srodriguez
• 1,937
• 2
• 24
• 42

`u` means `unsigned`, so `ulong` is a large number without sign. You can store a bigger value in `ulong` than `long`, but no negative numbers allowed.

A `long` value is stored in 64-bit,with its first digit to show if it's a positive/negative number. while `ulong` is also 64-bit, with all 64 bit to store the number. so the maximum of ulong is 2(64)-1, while long is 2(63)-1.

Cheng Chen
• 42,509
• 16
• 113
• 174

Based on the other answers here and a little review you can understand it this way: unsigned is in reference to the assignment of a negative or positive explicit assignment (think the "-" in -1) and the inability to have negative versions of said numbers.

And because of this capacity on the negative end being removed as an option they instead allocated that capacity to the positive end hence the doubling of the positive valuation's maximum value. So instead of the bit range being split along positive and negative valuations, they are instead for ushort, uint, along, etc allocated to the positive end of the valuation.

It's been a while since I C++'d but these answers are off a bit.

As far as the size goes, 'int' isn't anything. It's a notional value of a standard integer; assumed to be fast for purposes of things like iteration. It doesn't have a preset size.

So, the answers are correct with respect to the differences between int and uint, but are incorrect when they talk about "how large they are" or what their range is. That size is undefined, or more accurately, it will change with the compiler and platform.

It's never polite to discuss the size of your bits in public.

When you compile a program, int does have a size, as you've taken the abstract C/C++ and turned it into concrete machine code.

So, TODAY, practically speaking with most common compilers, they are correct. But do not assume this.

Specifically: if you're writing a 32 bit program, int will be one thing, 64 bit, it can be different, and 16 bit is different. I've gone through all three and briefly looked at 6502 shudder

A brief google search shows this: https://www.tutorialspoint.com/cprogramming/c_data_types.htm This is also good info: https://docs.oracle.com/cd/E19620-01/805-3024/lp64-1/index.html

use int if you really don't care how large your bits are; it can change.

Use size_t and ssize_t if you want to know how large something is.

If you're reading or writing binary data, don't use int. Use a (usually platform/source dependent) specific keyword. WinSDK has plenty of good, maintainable examples of this. Other platforms do too.

I've spent a LOT of time going through code from people that "SMH" at the idea that this is all just academic/pedantic. These ate the people that write unmaintainable code. Sure, it's easy to use type 'int' and use it without all the extra darn typing. It's a lot of work to figure out what they really meant, and a bit mind-numbing.

It's fragile coding when you mix int and assume sizes.

use int and uint when you just want a fast integer and don't care about the range (other than signed/unsigned).

J. Gwinner
• 931
• 10
• 15