要打印unsigned int 数字，可以使用%u符号。打印long数值，可以使用%d 格式说明符。如果系统的 int 和 long 类型具有同样的长度，使用%d 就可以打印 long 数值，但是这会给程序移植到其他系统（这两种数据类型的长度不一样的系统）带来麻烦，所以建议使用 %ld 打印 long 数值。在x和o符号前也可以使用l前缀，因此 %lx表示以十六进制格式打印长整数，%lo 表示以八进制格式打印长整数。请注意，尽管在C中常量后缀可以使用大写和小写，但格式说明符只能使用小写字母
 
C语言中还有其他几种printf（）格式。首先，可以对short 类型使用h 前缀，因此 %hd 表示以十进制显示short 整数，%ho 表示以八进制显示short 整数。h和 l 前缀都可以同u结合使用表示无符号整数。比如，%lu 表示打印unsigned long 类型。
 
  下面给出了个打印例子：
 
#include<stdio.h>
 int main(void)
 {
 unsigned int un =3000000000;/*int为32位*/
 short end = 200;
 long big = 65537;
 long long verybig = 12345678908642;
 printf("un =%uand not %d\n",un,un);
 printf("end =%hd and %d\n",end,end);
 printf("big = %ld and %hd\n",big,big);
 printf("verybig = %lld and %ld\n",verybig,verybig) ;
 return 0;

  


  } 
 
 

unsigned int 0～4294967295 
 int -2147483648～2147483647 
 unsigned long 0～4294967295 
 long -2147483648～2147483647 
 long long的最大值：9223372036854775807 
 long long的最小值：-9223372036854775808 
 unsigned long long的最大值：18446744073709551615
 
__int64的最大值：9223372036854775807 
 __int64的最小值：-9223372036854775808 
 unsigned __int64的最大值：18446744073709551615

溢出和取值范围
 
C语言的整型溢出问题
 整数溢出
 int、long int 、long long int 占用字节疑问
 
《C和指针》中写过：long与int：标准只规定long不小于int的长度，int不小于short的长度。
 
double与int类型的存储机制不同，long int的8个字节全部都是数据位，而double是以尾数，底数，指数的形式表示的，类似科学计数法，因此double比int能表示的数据范围更广。
 
long long在win32中是确实存在，长度为8个字节；定义为LONG64。
 为什么会出现long int呢？在win32现在系统中，长度为4；在历史上，或者其他某些系统中，int长度为2，是short int。
 即便是long long，在TI的有款平台中，长度为5也就是说，每种类型长度，需要sizeof才知道，如果可能，最好用union看看里面的数据，可以消除一些类型的假象长度。
 
类型名称        字节数    取值范围
signed char       1        -128～+127
short int         2        -32768～+32767
int               4        -2147483648～+2147483647
long int          4        -2147483648～+2141483647
long long long int  8      -9223372036854775808～+9223372036854775807
 
unsigned int  （unsigned long）
4字节8位可表达位数：2^32=42 9496 7296  
范围：0 ～ 42 9496 7295 (42*10^8)  
 
int  （long）
4字节8位可表达位数：2^32=42 9496 7296  
范围：-21 4748 3648 ～ 21 4748 3647 (21*10^8)
 
long long (__int64)
8字节8位可表达位数：2^64=1844 6744 0737 0960 0000  
范围：-922 3372 0368 5477 5808 ～ 922 3372 0368 5477 5807 (922*10^16)

unsigned long (unsigned __int64)
8字节8位可表达位数：2^64=1844 6744 0737 0960 0000  
范围：0 ～ 1844 6744 0737 0955 1615 (1844*10^16)

 
最大值、最小值
 
在#include<climits>存有各个类型的最大值和最小值
CHAR_MIN 　　　　　　char的最小值
SCHAR_MAX 　　　　　signed char 最大值
SCHAR_MIN 　　　　　 signed char 最小值
UCHAR_MAX 　　　　　unsigned char 最大值
SHRT_MAX 　　　　　　short 最大值
SHRT_MIN　　　　　　 short 最小值
USHRT_MAX　　　　　 unsigned short 最大值
INT_MAX　　　　　　　int 最大值
INT_MIN 　　　　　　　int 最小值
UINT_MAX 　　　　　　unsigned int 最大值
UINT_MIN  　　　　　　unsigned int 最小值
LONG_MAX　　　　　　long最大值
LONG_MIN 　　　　　　long最小值
ULONG_MAX 　　　　　unsigned long 最大值
FLT_MANT_DIG　　　　float 类型的尾数
FLT_DIG　　　　　　　  float 类型的最少有效数字位数
FLT_MIN_10_EXP　　　带有全部有效数的float类型的负指数的最小值（以10为底）
FLT_MAX_10_EXP 　　 float类型的正指数的最大值（以10为底）
FLT_MIN 　　　　　　　保留全部精度的float类型正数最小值
FLT_MAX　　　　　　　 float类型正数最大值
 
自己推算：
 
以int类型为例：
 int为4字节32位，其中首位用0表示正数，用1表示为负数。因此对于
 最大正数可以表示为：0x7fff ffff（7的二进制为0111，f二进制为1111）
 最大负数（-1）可以表示为：0xffff ffff
 最小负数可以表示为：0x8000 0000（8的二进制为1000）
 
负数为正数的源码取反码再取补码，过程如下：
 1、-1的原码：10000000 00000000 00000000 00000001
 2、得反码： 11111111 11111111 11111111 11111110
 3、得补码： 11111111 11111111 11111111 11111111
 
最小负数没有并没有原码和反码表示，最高位为1，其余位为0。就是最小负数。
 原码, 反码, 补码 详解
 
该如何选用类型
 

long int
 
　　long int即long，给人的感觉好像是长整型，但实际上，它和int一样，只有32位。cppreference给出的定义是——
 
 
 
int - basic integer type. The keyword int may be omitted if any of the modifiers listed below are used. If no length modifiers are present, it’s guaranteed to have a width of at least 16 bits. However, on 32/64 bit systems it is almost exclusively guaranteed to have width of at least 32 bits.
 long - target type will have width of at least 32 bits.
 
 
　　在实际的使用中，long与int几乎没有区别，比如——
 
#include<stdio.h>

int main(){
	long l = 10000000;
	int i = 10000000;
	printf("size of long:%d\n",sizeof(long));
	printf("size of int:%d\n",sizeof(int));
 	printf("l = %d\n",l);
 	printf("i = %d\n",i);
	return 0;
}
 

 　　既然long int与int相同，那么为什么还有long int这种尴尬的类型呢？
 　　原因是早期的C编译器定义了long int占用4个字节，int占用2个字节，long int是名副其实的长整型。在ANSI C的标准中，对长整型的定义也是long int应该至少和int一样长，而不是long int 一定要比int占用存储字节长。所以，正确的关系应该是——
 $$long\ge int\ge short$$
 　　新版的C/C++标准兼容了早期的这一设定。
 
long long
 
　　long long则不同，long long是C++的64位整型的基本类型，“现任”长整型，从C99开始引入这个概念，在后续的标准中完善概念和定义，C++11官方正式标准如下——
 
 
 
long long - target type will have width of at least 64 bits.(since C++11)
 
 
　　long long占用8个字节，数据表示范围也从int的$[-2^{31},2^{31}-1]$，升级到$[-2^{63},2^{63}-1]$。
 
#include<stdio.h>

int main(){
	long l = 10000000;
	int i = 10000000;
	long long ll = 100000000000000;
	printf("size of long:%d\n",sizeof(long));
	printf("size of int:%d\n",sizeof(int));
	printf("size of long long:%d\n",sizeof(long long));
 	printf("l = %d\n",l);
 	printf("i = %d\n",i);
 	printf("ll = %lld\n",ll);
	return 0;
}
 

 　　long long是C++的正式标准，这也就意味着，该类型不会因为编译器或者开发平台的不同而有所差异，放之四海而皆准，而且与一些系统函数、类库都有很好的交互（如常见的printf、scanf、cin和cout等）。与之相反，出身MS的__int64就有点不受待见了，在不同的编译器上可能水土不服。 
 
__int64
 
　　在早期的代码中，可能会遇到__int64这种类型，这应该算是“历史遗留”问题。早期的C/C++标准中并没有规定64位长整型的规范，因此不同的编译器对这一模糊概念有不同的定义，我们熟知的VC6.0采用了__int64这种类型来表示64位长整型——
 
#include<iostream>
#include<cmath>
using namespace std;
int main(){
	__int64 i64 = -pow(2,63);
	cout<<"__int64:"<<sizeof(__int64)<<endl; 
	cout<<"i64 = "<<i64<<endl;
	return 0;
}
 

 　　与long long具有相同的效果，但是，__int64并不是正式规范，比如，如果你使用的是MinGW的编译器的话，打开__int64的定义会发现——
 
 　　VS 2017虽然把__int64作为了一种内置类型，但是也做了类似的处理，使得__int64与long long没有肉眼可见的差别。但如果你使用的开发环境比较早期，那么可能就要专门研究一下__int64了。比如说，古老的VC6.0并没有long long这种类型，而__int64的输入输出，又需要printf和%I64d的配合，而不是%lld或者直接用cout。
 
总结
 
　　C/C++与Java等语言不同，具有较高的自由度，由于某些历史原因，某些概念在不同的平台上有不同的解释，虽然现在新版本的C++标准和编译器都在做兼容性工作，你可以在__int64与long long之间无缝切换，但至少，我们要清楚两者的不同。
 
类型
存储字节
表示范围
int
4
-2147483648~2147483647
short int
2
-32768～+32767
long
4
-2147483648~2147483647（二十亿，约$10^{10}$）
long long
8
9223372036854775808～+9223372036854775807(九百亿亿，约$10^{19}$)
__int64
8
9223372036854775808～+9223372036854775807
参考链接
 
1.https://blog.csdn.net/qq_31736627/article/details/52912691
 2.https://en.cppreference.com/w/cpp/language/types
 3.https://www.cnblogs.com/ChenDinghao/p/6480937.html
 4.https://blog.csdn.net/sk18192449347/article/details/55000087