溢出和取值范围
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。就是最小负数。
原码, 反码, 补码 详解
该如何选用类型

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++98标准，C++11整型的最大改变就是多了long long。但事实上，long long整型本来就离C++标准很近，早在1995年，long long就被提议写入C++98标准，却被C++标准委员会拒绝了。而后来，long long类型却进入了C99标准，而且也事实上也被很多编译器支持。于是辗转地，C++标准委员会又掉头决定将long long纳入C++11标准。



long long整型有两种：long long和unsigned long long。在C++11中，标准要求long long整型可以在不同平台上有不同的长度，但至少有64位。我们在写常数字面量时，可以使用LL后缀（或是ll）标识一个long long类型的字面量，而ULL（或ull、Ull、uLL）表示一个unsigned long long类型的字面量。比如：

long long int lli = -9000000000000000000LL;

unsigned long long int ulli = -9000000000000000000ULL;



就定义了一个有符号的long long变量lli和无符号的unsigned long long变量ulli。事实上，在C++11中，还有很多与long long等价的类型。比如对于有符号的，下面的类型是等价的：long long、signed long long、long long int、signed long long int；而unsigned long long和unsigned long long int也是等价的。



同其他的整型一样，要了解平台上long long大小的方法就是查看<climits>（或<limits.h>中的宏）。与long long整型相关的一共有3个：LLONG_MIN、LLONG_MAX和ULLONG_MIN，它们分别代表了平台上最小的long long值、最大的long long值，以及最大的unsigned long long值。可以看看下面这个例子，如代码清单2-5所示。

#include <climits>
#include <cstdio>
using namespace std;


int main()<span style="font-family: Arial, Helvetica, sans-serif;">{</span>

    long long ll_min = LLONG_MIN;
    long long ll_max = LLONG_MAX;
    unsigned long long ull_max = ULLONG_MAX;


    printf("min of long long: %lld\n", ll_min); // min of long long: -9223372036854775808
    printf("max of long long: %lld\n", ll_max); // max of long long: 9223372036854775807
    printf("max of unsigned long long: %llu\n", ull_max);   // max of unsigned long long: 18446744073709551615
}

在代码清单2-5中，将以上3个宏打印了出来，对于printf函数来说，输出有符号的long long类型变量可以用符号%lld，而无符号的unsigned long long则可以采用%llu。18446744073709551615用16进制表示是0xFFFFFFFFFFFFFFFF（16个F），可知在我们的实验机上，long long是一个64位的类型。

对源码进行了整理和排序加注释，方法体直接删除。除了部分重要代码我进行了保留
public final class Long extends Number implements Comparable<Long>, Constable, ConstantDesc {

    @java.io.Serial
    @Native private static final long serialVersionUID = 4290774380558885855L;// 序列化版本号
    @Native public static final long MIN_VALUE = 0x8000000000000000L;   // 最小值-2的63次方
    @Native public static final long MAX_VALUE = 0x7fffffffffffffffL;   // 最大值2的63次方
    private final long value;                                           // 存储值得成员变量
    @Native public static final int SIZE = 64;                          // 长度64bit
    public static final int BYTES = SIZE / Byte.SIZE;                   // 8个byte数
    public static final Class<Long> TYPE = (Class<Long>) Class.getPrimitiveClass("long"); // Class实例表示基本类型long

    /**
     * 缓存值
     */
    private static class LongCache {
        private LongCache() {}
        static final Long[] cache; // 缓存的long值存入数组
        static Long[] archivedCache; // 和 cache指向同一个地址
        static {
            int size = -(-128) + 127 + 1;  // 数组的长度256
            VM.initializeFromArchive(LongCache.class);
            if (archivedCache == null || archivedCache.length != size) {
                Long[] c = new Long[size]; // 创建长度256的数组
                long value = -128; // 最小值-128，最大值则是-128+256=127
                for(int i = 0; i < size; i++) { // 循环256次
                    c[i] = new Long(value++); // 将-128 到 127 存入数组中 因为size=256
                }
                archivedCache = c;
            }
            cache = archivedCache;
        }
    }

    /**
     * 构造方法
     */
    @Deprecated(since="9")
    public Long(long value) {} // 传入long得构造方法
    @Deprecated(since="9")
    public Long(String s) throws NumberFormatException {} // 传入String得构造方法

    /**
     * 转换其它类型的值：byte、short、int、float、double、long
     */
    public byte byteValue() {}      // 转换为btye
    public short shortValue() {}    // 转换为short
    public int intValue() {}        // 转换为int
    public float floatValue() {}    // 转换为float
    public double doubleValue() {}  // 转换为double
    @HotSpotIntrinsicCandidate
    public long longValue() {}      // 得到long类型的值

    /**
     * 其它常用的实例方法
     */
    public String toString() {}                 // 转换为字符串
    public int compareTo(Long anotherLong) {}   // 比较大小大于anthoerLong返回正值，-1是小于，0相等
    public boolean equals(Object obj) {}        // 判断当前值是否和obj相等
    @Override public int hashCode() {}          // 得到hash值
    @Override public Optional<Long> describeConstable() {} // 将当前值封装成Optional

    @Override public Long resolveConstantDesc(MethodHandles.Lookup lookup) {} // 返回当前对象

    /**
     * ==================================
     * 下面的都是静态方法，作为工具类对外使用
     * =================================
     */


    /**
     * 常用方法：求和。最大值，最小值
     */
    public static int hashCode(long value) {}             // 得到value的hash值
    public static long sum(long a, long b) {}             // 求和
    public static long divideUnsigned(long dividend,long divisor) {}// 除法。返回dividend 除以 divisor 的值
    public static long remainderUnsigned(long dividend,long divisor) {}// 求余。返回dividend 对divisor的余数
    public static long max(long a, long b) {}             // 两数最大值
    public static long min(long a, long b) {}             // 两数最小值
    public static int compare(long x, long y) {}          // 比较x，y的大小
    public static int compareUnsigned(long x, long y) {}  // 比较无符号的x，y的大小
    /**
     * 数字转字符串
     */
    public static String toString(long i, int radix) {}         // 按照基数radix将long类型的i转换成utf16字符串
    private static String toStringUTF16(long i, int radix) {}   // 被上面的toString调用
    public static String toUnsignedString(long i, int radix) {} // 按进制radix(2、4、8、10、16、32)转换成无符号字符串
    private static BigInteger toUnsignedBigInteger(long i) {}   // 将long类型的i转换为BigInteger对象
    public static String toString(long i) {}                    // 将i转换成字符串
    public static String toBinaryString(long i) {}              // 将long类型的i转换为2进制字符串
    public static String toOctalString(long i){}                // 将long类型的i转换为10进制字符串
    public static String toHexString(long i) {}                 // 将long类型的i转换为16进制字符串
    public static String toUnsignedString(long i) {}            // 将long类型的i转换为无符号字符串

    /**
     * 字符串转数字（前面的逆作用）
     *
     * 转换过程都可能 throws NumberFormatException
     */
    public static Long decode(String nm){}                      // 解析字符串中代表的long值，例如：0x开头、0开头
    public static long parseLong(String s, int radix)  {}       // 按基数radix解析字符串s中代表的long值
    public static long parseLong(String s){}                    // 默认10进制为基数，调用上面的方法进行解析
    public static long parseUnsignedLong(String s, int radix){} // 按基数radix解析字符串s中代表的无符号long值
    public static long parseUnsignedLong(String s) {}           // 默认10 进制，调用上面一个的方法
    // 以radix进制解析字符串中索引值从beginIndex到endIndex内表示的字符串
    public static long parseLong(CharSequence s, int beginIndex, int endIndex, int radix) {}
    // 以radix进制解析字符串中索引值从beginIndex到endIndex内表示的字符串（返回无符号long值）
    public static long parseUnsignedLong(CharSequence s, int beginIndex, int endIndex, int radix) {}
    @HotSpotIntrinsicCandidate
    public static Long valueOf(long l) {}                 // 得到l的包装对象
    public static Long valueOf(String s, int radix){}     // 按基数radis解析s为Long对象
    public static Long valueOf(String s) {}               // 得到字符串s中代表的Long对象
    public static Long getLong(String nm) {}              // 得到系统定义的值例如传入：sun.arch.data.model 会得到64
    /**
     * 例如：
     * Long aLong = Long.getLong("sun.arch.data.model",100); 得到的是64不是100
     * Long aLong = Long.getLong("系统变量的值",100); // 因为前面没有所以返回100
     * Long aLong = Long.getLong("100"); // 返回null，因为100在系统变量中获取不到值
     *
     */
    public static Long getLong(String nm, long val) {}    // 如果nm所代表的系统值由则返回nm所代表的值，否则返回val值
    public static Long getLong(String nm, Long val) {}    // 被getLong(String nm, long val)调用，实际上它才是真正处理的函数

    /**
     * 位操作
     * 左移、右移、反转
     */
    public static int signum(long i) {}                    // 返回符合位，负数返回-1，正数返回1，0返回0
    public static long rotateLeft(long i, int distance){}  // 将i所代表的2进制进行左移distance位（相当于将 i * 2的distance次方法）
    public static long rotateRight(long i, int distance){} // 将i（二进制表示）右移distance位
    public static long reverse(long i) {}                  // 将i(二进制表示)进行反转
    public static long highestOneBit(long i) {}            // 返回最高位的值，例如：100(需要二进制表示的最高位) 得到的是64，128得到的是128
    public static long lowestOneBit(long i) {}             // 返回最低位的值，例如：5（2进制表示101） 返回1
    @HotSpotIntrinsicCandidate
    public static int bitCount(long i) {}                  // 返回i表示的二进制中1的个数
    @HotSpotIntrinsicCandidate
    public static long reverseBytes(long i) {}             // 将i存储的8个字节内容进行逆序排序得到新的long值
    @HotSpotIntrinsicCandidate
    public static int numberOfLeadingZeros(long i) {}      // 返回i表示的二进制左边0的个数（总共64位，将i用二进制表示，返回最高位1左边0的个数）
    @HotSpotIntrinsicCandidate
    public static int numberOfTrailingZeros(long i) {}     // 返回i表示的二进制右边0的个数（总共64位，将i用二进制表示，返回最低位1左边0的个数）




    /**
     * 不对外使用的方法
     */
    static String toUnsignedString0(long val, int shift) {}     // 将long类型的val按照shift进制进行转换得到字符串
    private static void formatUnsignedLong0(long val, int shift, byte[] buf, int offset, int len) {}
    private static void formatUnsignedLong0UTF16(long val, int shift, byte[] buf, int offset, int len) {}
    static String fastUUID(long lsb, long msb) {}
    static int getChars(long i, int index, byte[] buf) {}
    static int stringSize(long x) {}
    
}