整数（int、short、long）的具体介绍、不同进制表示、输出，sizeof、unsinged的使用

int、short、long的用法及区别。为什么要用short、long？

在现代操作系统中，int一般（注意，是一般）占用4个字节（Byte）的内存，共32位（bit）。如果不考虑正负数，当所有位都为1时，他的值最大，为2³²≈43亿。这是一个很大的数，实际开发中很少用到。而像1、99、12234等较小的数使用频率反而较高。

使用4个字节保存较小的整数绰绰有余，会空闲出两三个字节来，这些字节就白白浪费了，不能再被其他数据使用。现在电脑内存都比较大了，比较低的也有2G，浪费一些内存不会带来明显的损失。而在C语言发明的早期，或者在单片机和嵌入式系统中，内存都是非常稀缺的资源，所有程序都在尽力节省内存。

反过来再说，43亿虽然很大，但要表示全球人口数量还是不够，必须要让整数占用更多的内存，才能表示更大的值，比如占用6个或8个字节。

让整数占用更少的内存可以在int前面加short，让整数占用更多内存可以在int前面加long，例如：

    short int a = 10;
    long int b = 102929;

这样a只占用2个字节的内存，而b可能（是可能）会占用8个字节的内存。

也可以将int省略，只写short、long，如下：

    short a = 10;
    long b = 102929;

两者完全等价，写法更简洁，实际开发中常用。

int是基本的数据类型，short和long是在int的基础上进行的扩展，short可以节省内存，long可以容纳更大的值。

short、int、long是C语言中常见的整数类型，其中int称为整型，short称为短整型，long称为长整型。

整型的长度

上面我们在描述short、int、long类型的长度时，只对short使用肯定的说法，而对int、long使用了“一般”或者“可能”等不确定的说法。这种描述言外之意是，只有short的长度是确定的，即两个字节，而int和long的长度无法确定，在不同的环境下有不同的表现。

一种数据类型占用的字节数，称为该数据类型的长度。例如，short占用2个字节的内存，那么他的长度就是2.

C语言并没有严格规定short、int、long的长度，只做了宽泛限制：

• short至少占用2个字节
• int为一个机器字长。32位环境下为4字节，64位环境下为8字节
• short的长度不能大于int，long的长度不能小于int

所以，他们长度（所占字节数）的关系为：

2 <= short <= int <= long

可以看出，short不一定真的“短”，long也不一定真的“长”，他们可能和int占用相同的字节数。

在16位环境下，short长度为2byte，int也为2byte，long为4byte。16位的环境多用于单片机和嵌入式系统，在pc和服务器上已经见不到了。

对于32位的windows、linux、macos，short的长度为2byte，int为4byte、long也是4byte。

在64位环境下，不同操作系统会有不同的结果，如下：

操作系统	short	int	long
Win64（64位Windows）	2	4	4
类Unix系统（Unix、Linux、Mac OS、BSD、Solaris等）	2	4	8

目前我们使用较多的PC系统位Win7、Win8、Win10、Mac OS、Linux，在这些系统中，short和int的长度都是固定的，分别为2和4，可以放心使用。只有long的长度在Win64和类Unix系统下会有所不同，使用时要注意移植性。

sizeof操作符

获取某个数据类型的长度可以使用sizeof操作符，如下所示：

#include <stdio.h>
int main()
{
    short a = 10;
    int b = 100;
   
    int short_length = sizeof a;
    int int_length = sizeof(b);
    int long_length = sizeof(long);
    int char_length = sizeof(char);
   
    printf("short=%d, int=%d, long=%d, char=%d\n", short_length, int_length, long_length, char_length);
   
    return 0;
}

在32位环境已经Win64环境下的运行结果为：

short=2, int=4, long=4, char=1

在64位Linux和Mac OS下的运行结果为：

short=2, int=4, long=8, char=1

需要注意的是，sizeof是C语言中的操作符，不是函数，所以可以不带()，后面我们再详解。

不同整型的输出

使用不同的格式控制符可以输出不同类型的整数，他们分别是：

• %hd用来输出short int类型，hd是short decimal的简写
• %d用来输出int类型，d是decimal的简写
• %ld用来输出long int类型，ld是long decimal的简写

下面例子演示完整的输出：

#include <stdio.h>
int main()
{
    short a = 10;
    int b = 100;
    long c = 9999;

    printf("a=%hd, b=%d, c=%ld\n", a, b, c);
    return 0;
}

运行结果：
a=10,b=100,c=9999

在编写代码的过程中，我们应该将个师傅和数据类型严格对应起来。如果不严格对应，一般也不会导致错误，例如，很多人喜欢用%d输出所有整数类型：

#include <stdio.h>
int main()
{
    short a = 10;
    int b = 100;
    long c = 9999;

    printf("a=%d, b=%d, c=%d\n", a, b, c);
    return 0;
}

运行结果仍然为：
a=10,b=100,c=9999

当使用%d输出short或者使用%ld输出short、int时，不管值多大，都不会发生错误，因为格式控制符足够容纳这些值。

当使用%hd输出int、long，或者使用%d输出long时，如果要输出的值比较小，一般也不会发生错误，如果要输出的值比较大时，就可能发生错误，例如：

#include <stdio.h>
int main()
{
    int m = 306587;
    long n = 28166459852;
    printf("m=%hd, n=%hd\n", m, n);
    printf("n=%d\n", n);

    return 0;
}

在64位Linux和Mac OS下（long长度位8）运行结果为：
m=-21093, n=4556
n=-1898311220

输出结果完全是错误的。至于为什么会出现这个值，等我们聊到整数在内存中的存储时，详细和大家分析。

整数中的二进制数、八进制数和十六进制数的表示

C语言中的整数除了可以使用十进制，还可以使用二进制、八进制和十六进制。

一个数字默认是十进制的，表示一个十进制的数字不需要任何特殊的格式。但是，表示一个二进制、八进制或者十六进制就不一样了，为了和十进制数字区别开，必须采用某种特殊的写法。具体来说，就是在数字前面加上特定的字符，也就是加前缀。

二进制

二进制由0和1两个数字组成，使用时必须以0b或0B开头（不区分大小写），例如：

    //合法的二进制
    int a2 = 0b101;
    short b2 = -0b1010111;
    long c2 = 0B100001;
    
    //非法的二进制
    int m = 101010; //无前缀0B，相当于十进制
    int n = 0B410;  //4不是有效数字

请注意，标准的C语言并不支持二进制写法，有些编译器自己进行了扩展，才支持二进制数字。换句话说，并不是所有的编译器都支持二进制数字，这与编辑器的种类和版本都有关系。

八进制

八进制由0～7八个数字组成，使用时必须以0开头（注意是数字0，不是字母o），例如：

    //合法的八进制数
    int a = 015;  //换算成十进制为 13
    int b = -0101;  //换算成十进制为 -65
    int c = 0177777;  //换算成十进制为 65535

    //非法的八进制
    int m = 256;  //无前缀 0，相当于十进制
    int n = 03A2;  //A不是有效的八进制数字

十六进制

十六进制由数字0～9，字母A～F或a～f（不区分大小写）组成，使用时必须以0x或0X（不区分大小写）开头，例如：

    //合法的十六进制
    int a = 0X2A;  //换算成十进制为 42
    int b = -0XA0;  //换算成十进制为 -160
    int c = 0xffff;  //换算成十进制为 65535

    //非法的十六进制
    int m = 5A;  //没有前缀 0X，是一个无效数字
    int n = 0X3H;  //H不是有效的十六进制数字

二进制数、八进制数和十六进制数的输出

之前我们提到可以使用printf以十进制的形式输出short、int、long三种类型的整数。这里我们主要说说如何将他们以八进制、十进制、十六进制输出，下表列出了不同类型的整数，以不同形式输出时对应的格式控制符：

	short	int	long
八进制	%ho	%o	%lo
十进制	%hd	%d	%ld
十六进制	%hx或%hX	%x或%X	%lx或%lX

十六进制数字表示用到了英文字母，有大小写之分，要在格式控制符中体现出来：

• %hx、%x和%lx中的x小写，表示以小写字母的形式输出十六进制数
• %hX、%X和%lX中的x大写，表示以大写字母的形式输出十六进制数

八进制数字和十进制数字不区分大小写，所以格式控制符都用小写形式。如果你一定要试试大写形式，那么行为是未定义的：

• 有些编译器支持大写形式，只不过行为和小新形式一样
• 有些编译器不支持大写形式，可能会报错，也可能导致奇怪的输出

注意，虽然部分编译器支持二进制数字的表示，但是却不能使用printf输出二进制。当然，通过转换函数可以将其他进制数字转成二进制数字，并以字符串形式，然后在printf函数中使用%s输出即可。这点我们后面再说。

以不同进制输出整数：

#include <stdio.h>
int main()
{
    short a = 0b1010110;  //二进制数字
    int b = 02713;  //八进制数字
    long c = 0X1DAB83;  //十六进制数字
   
    printf("a=%ho, b=%o, c=%lo\n", a, b, c);  //以八进制形似输出
    printf("a=%hd, b=%d, c=%ld\n", a, b, c);  //以十进制形式输出
    printf("a=%hx, b=%x, c=%lx\n", a, b, c);  //以十六进制形式输出（字母小写）
    printf("a=%hX, b=%X, c=%lX\n", a, b, c);  //以十六进制形式输出（字母大写）

    return 0;
}

运行结果：
a=126, b=2713, c=7325603
a=86, b=1483, c=1944451
a=56, b=5cb, c=1dab83
a=56, b=5CB, c=1DAB83

这里我们可以看到，一个数字不管用什么进制来表示，都能以任意进制形式输出。数字在内存中始终以二进制形式存储，其他进制数字在存储前必须转换为二进制形式；同理，一个数字在输出时要进行逆向的转换，也就是从二进制转成其他进制。

注意看上面的例子，会发现有一点不完美，如果只看输出结果：

• 对于八进制的数字，他没法和十进制、十六进制区分。因为八进制、十进制、十六进制都包括0～7这几个数字
• 对于十进制数字，他没法和十六进制区分，因为十六进制也包含0～9这几个数字。如果十进制数字中不包含8和9，那么也不能和八进制区分
• 对于十六进制数字，如果没有包含a～f或A～F，那么就无法和十进制区分。如果不包含8和9，那么也不能和八进制区分了

区分不同进制数字的一个简单方法就是，在输出时带上特定的前缀。在格式控制符中加上#即可输出前缀，例如%#x、%#o、%#ho等，如下：

#include <stdio.h>
int main()
{
    short a = 0b1010110;  //二进制数字
    int b = 02713;  //八进制数字
    long c = 0X1DAB83;  //十六进制数字
   
    printf("a=%#ho, b=%#o, c=%#lo\n", a, b, c);  //以八进制形似输出
    printf("a=%hd, b=%d, c=%ld\n", a, b, c);  //以十进制形式输出
    printf("a=%#hx, b=%#x, c=%#lx\n", a, b, c);  //以十六进制形式输出（字母小写）
    printf("a=%#hX, b=%#X, c=%#lX\n", a, b, c);  //以十六进制形式输出（字母大写）
   
    return 0;
}

运行结果：
a=0126, b=02713, c=07325603
a=86, b=1483, c=1944451
a=0x56, b=0x5cb, c=0x1dab83
a=0X56, b=0X5CB, c=0X1DAB83

十进制数字没有前缀，所以不用加#。如果你加上了，那么他的行为是未定义的，有些编译器支持十进制加#，只不过输出结果和没有加#一样，有的编译器不支持加#，可能会报错，也可能会导致奇怪的输出。大部分编译器都能正常输出，不至于当成一种错误。

C语言中的正负数及输出

在数学中，数字有正负之分。在C语言中也是一样，short、int、long都可以带上正负号，如：

    //负数
    short a1 = -10;
    short a2 = -0x2dc9;  //十六进制
    //正数
    int b1 = +10;
    int b2 = +0174;  //八进制
    int b3 = 22910;
    //负数和正数相加
    long c = (-9) + (+12);

如果不带正负号，默认就是正数。

符号也是数字的一部分，也要在内存中体现出来。符号只有正负两种情况，用1位（Bit）就足以表示；C语言规定，把内存的最高位作为符号位。以int为例，他占用32位的内存，31位表示正负号，如下：

在编程语言中，计数一般是从0开始，如字符串“abc123”，我们称第0个字符是a，第一个字符是b。

C语言规定，在符号位中，用0表示正数，用1表示负数。例如int类型的-10和+16在内存中表示如下：

short、int、long默认都是带符号位的，符号位以外才是数值位。如果只考虑正数，那么各种类型能表示的数值范围（取值范围）就比原来小了一半。

很多情况下，我们能确定某个数字就是正数，比如某物品的数量，某学校学生人数，字符串长度等，这时候符号位就是多余的了，不如删掉符号位，把所有位都用来存储数值，这样能表示的数值范围会比原来大一倍。

C语言中规定，如果不希望设置符号位，可以在数据类型前加上unsigned关键字，如：

    unsigned short a = 10;
    unsigned int b = 100;
    unsigned long c = 284902;

这样，short、int、long中就没有符号位了，所有位都用来表示数值，正数取值范围更大了。但是，这也意味着unsigned只能用来表示正数，不能直接表示负数。

如果将一个数字分为符号和数值两部分，那么不加unsigned的数字称为有符号数，能表示正数和负数。加了unsigned的数字称为无符号数，只能表示正数。

如果是unsigned int类型，那么可以省略int，只写unsigned，如：

unsigned n = 100;

他等价于：

unsigned int n = 100;

无符号数的输出

无符号数可以以八进制、十进制和十六进制的形式输出，他们对应的控制符为：

	unsigned short	unsigned int	unsigned long
八进制	%ho	%o	%lo
十进制	%hu	%u	%lu
十六进制	%hx或%hX	%x或%X	%lx或%lX

我们之前提到了不同进制形式的输出，但是却没有提到正负数，所以没有关心这一点。我们现在讲到了正负数，所以我们在深入的说一下。

严格来说，格式控制符和整数的符号是紧密相关的，具体就是：

• %d以十进制形式输出有符号数
• %u以十进制形式输出无符号数
• %o以八进制形式输出无符号数
• %x以十六进制形式输出无符号数

我要说的是，printf并不支持以八进制或十六进制输出有符号数，他没有对应的控制符。在实际开发中，也基本没有“输出负的八进制或者十六进制数”这样的需求。

下表全面的总结了不同类型的整数，以不同形式输出时对应的格式控制符（–表示没有对应的格式控制符）

	short	int	long	unsigned short	unsigned int	unsigned long
八进制	–	–	–	%ho	%o	%lo
十进制	%hd	%d	%ld	%hu	%u	%lu
十六进制	–	–	–	%hx或%hX	%x或%X	%lx或%lX

之前我们也使用了%o和%x来输出有符号数了，他并没有发生错误，这是因为：

• 当以有符号数的形式输出时，printf会读取数字所占用的内存，并把最高位作为符号位，把剩下的内存作为数值位
• 当以无符号数的形式输出时，printf也会读取数字所占用的内存，并把所有内存都作为数值位对待

对于一个有符号的正数，他的符号位是0，当按照无符号数的形式读取时，符号位就变成了数值位，但是该位刚好是0不是1，所以对数值不会产生影响。这就相当于在一个数字前加0，无论加多少个0，都不会影响数字的大小。

如果对一个有符号的负数使用%o或者%x输出，那么结果就会大相径庭。

可以说，“有符号的正数最高位是0”这个巧合才使得%o和%x输出有符号数时才不会出错。

再次强调，无论是以%o、%u、%x输出有符号数，还是以%d输出无符号数，编译器都不会报错，只是对内存的解释不同了。%o、%d、%u、%x这些格式控制符不会关心数字在定义时到底是有符号的还是无符号的：

• 你让我输出无符号数，那我在读取内存时就不区分符号位和数值位了，我会把所有内存都看作数值位
• 你让我输出有符号数，我在读取内存时会把最高位作为符号位，把剩下内存作为数值位

说的再直接一些，我管你在定义时是有符号数还是无符号数呢，我只关心内存，有符号数也可以按照无符号数输出，无符号数也可以按照有符号数输出，至于输出结果对不对，那我就不管了。

下面进行全面的演示：

#include <stdio.h>
int main()
{
    short a = 0100;  //八进制
    int b = -0x1;  //十六进制
    long c = 720;  //十进制
   
    unsigned short m = 0xffff;  //十六进制
    unsigned int n = 0x80000000;  //十六进制
    unsigned long p = 100;  //十进制
   
    //以无符号的形式输出有符号数
    printf("a=%#ho, b=%#x, c=%ld\n", a, b, c);
    //以有符号数的形式输出无符号类型（只能以十进制形式输出）
    printf("m=%hd, n=%d, p=%ld\n", m, n, p);

    return 0;
}

运行结果：
a=0100, b=0xffffffff, c=720
m=-1, n=-2147483648, p=100

我们可以看到，b、m、n的输出结果看起来非常奇怪。照着一般的推理，b、m、n这三个整数在内存中的存储形式分别为：

当以%x输出b时，结果应该是0x80000001；当以%hd、%d输出m、n时，结果应该分别时-7fff，-0。实际却不是这样。

注意，-7fff 是十六进制形式。%d 本来应该输出十进制，这里只是为了看起来方便，才改为十六进制。

这其实跟整数在内存中的存储形式和读取方式有关。b是一个有符号的负数，他在内存中并不是像上图演示的那样存储，而是需要经过一定的转换才能写入内存。m、n的内存虽然没有错误，但是当以%d输出时，并不是原样输出，而是有一个逆向的转换过程。

总之，整数在写入内存之前可能会发生转换，在读取时也可能会发生转换，我们没有考虑这种转换，所以导致推理错误。那么整数在写入内存前究竟发生了怎样的转换呢？我们将在整数在内存中是如何存储的？数值溢出的本质是什么？从源头了解奇怪的整数输出问题详细说说。