精华内容
下载资源
问答
  • int、long int 、long long int 占用字节疑问 《C和指针》中写过:long与int:标准只规定long不小于int的长度,int不小于short的长度。 double与int类型的存储机制不同,long int的8个字节全部都是数据位,而...

    溢出和取值范围

    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。就是最小负数。
    原码, 反码, 补码 详解

    该如何选用类型

    在这里插入图片描述

    展开全文
  • int、longlong long取值范围

    万次阅读 多人点赞 2018-08-07 11:23:18
    unsigned int 0~4294967295 int -2147483648~2147483647 unsigned long 0~4294967295 long -2147483648~...long long的最大值:9223372036854775807 long long的最小值:-9223372036854775808 unsigned...

    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

    展开全文
  • 数据类型long long ,unsigned long long

    千次阅读 2019-08-02 16:58:09
    相比于C++98标准,C++11整型的最大改变就是多了long long。但事实上,long long整型本来就离C++标准很近,早在1995年,long long就被提议写入C++98标准,却被C++标准委员会拒绝了。而后来,long long类型却进入了C99...

    相比于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 longunsigned 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位的类型。

    展开全文
  • 简化 java.lang.Long 类的源码

    万次阅读 2020-09-28 02:20:27
    public final class Long extends Number implements Comparable<Long>, Constable, ConstantDesc { @java.io.Serial @Native private static final long serialVersionUID = 4290774380558885855L;// 序列...

    对源码进行了整理和排序加注释,方法体直接删除。除了部分重要代码我进行了保留

    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) {}
        
    }
    
    展开全文
  • c语言longlong long的取值范围

    万次阅读 多人点赞 2018-10-20 15:06:15
    int、long int 、long long int 占用字节 《C和指针》中写过:long与int:标准只规定long不小于int的长度,int不小于short的长度。 double与int类型的存储机制不同,long int的8个字节全部都是数据位,而double是以...
  • C/C++:long int与long long的区别

    万次阅读 多人点赞 2018-12-25 11:07:02
    long int  long int即long,给人的感觉好像是长整型,但实际上,它和int一样,只有32位。cppreference给出的定义是—— int - basic integer type. The keyword int may be omitted if any of the modifiers ...
  • c/c++中int,longlong long的取值范围

    万次阅读 2019-04-25 18:21:22
    c/c++中int,longlong long的取值范围: unsigned int 0~4294967295 int -2147483648~2147483647 unsigned long 0~4294967295 long -2147483648~2147483647 long long的最大值:92233720368547758...
  • int,longlong long的区别

    万次阅读 多人点赞 2019-01-03 14:40:10
    int,longlong long的区别 int unsigned int 0~4294967295 int -2147483648~2147483647 long unsigned long 0~4294967295 long -2147483648~2147483647 long long long long:-9223372036854775808~9223....
  • unsigned long longlonglong类型的使用

    千次阅读 2019-03-22 13:29:24
    unsigned long long : 的范围是[0,264-1]。如果越界了以后就相当于是对264-1求模了。 long long:是有符号类型它的范围是[-263-1,263+1],因为有符号的第63位表示“正负”而不表示数值。但数据越界了以后就会从负数...
  • unsigned long long ,long long ,int 等其他的数据的范围

    万次阅读 多人点赞 2018-06-08 18:47:16
    unsigned long long ,long long ,int 等其他的数据的范围:
  • int转long Long

    万次阅读 2018-08-19 18:25:03
    Long l = (Long)5; 以上的不行 因为Long是包装类,而int是值类型数据,两者是不能这样强转的。 long l = (long)5;   int和long都是基本类型的数据,是可以强转的,那么我就可以以此作为桥梁,强转成long后,...
  • long long整型有两种:long long和unsigned long long。在C++11中,标准要求long long整型可以在不同平台上有不同的长度,但至少有64位。
  • unsigned long long类型与long long类型

    万次阅读 2015-05-02 14:46:27
    遇到这种限制条件时就要想到用unsigned long long类型。 可以简洁地声明为typedef unsigned long long ull。这样,如果ull类型的整数溢出了,就相当于取模2^64了。因为ull的范围是[0,2^64-1]。 而ll的范围是[-2^63,2...
  • char -128 ~ +127 (1 Byte) short -32767 ~ + 32768 (2 Bytes) unsigned short 0 ~ 65535 (2 Bytes) int -2147483648 ~ +2147483647 (4 Bytes) unsigned int 0 ~ 4294967295 (4 Bytes) ...long long -92233...
  • int 、longlong long 区别

    千次阅读 2019-03-30 16:44:41
    在C++ primer,或者c++标准书中是这样...= sizoef(long long) 它并没有回答各个数据类型的具体长度,而是由编译器自行决定 下面我们看下在操作系统为64位DEVC++下他们的长度都是多少: #include <bits/stdc++...
  • 类型标识符 32位机器所占字节长度 64位机器所占字节长度 格式化输出 ...long long 8 8 %lld unsinged 4 4 %u unsinged short 2 2 %u unsiged long 4 8 %lu unsigned long long 8 8 %llu...
  • longlong 类型转换

    千次阅读 2017-12-29 14:55:52
    1.longlong类型转换成double类型:因为longlong类型是64位, double类型是32位,转换会丢失精度;但是double转换成longlong类型,低的向高的转换可以安全转换; 2.longlong用“%f”printf打印出来是正确的值:可以...
  • c# long long_C#中的long关键字

    千次阅读 2020-07-30 02:13:17
    c# long long C#uint关键字 (C# uint keyword) In C#, long is a keyword which is used to declare a variable that can store a signed integer value between the range of -9,223,372,036,854,775,808 to 9,223...
  • int long longlong float double类型数据的范围
  • int,long,long long类型的数值范围

    万次阅读 2016-07-18 09:15:23
    int ,long ,long long 等各种数据类型的范围
  • 随机long(Random long/NextLong)

    千次阅读 2019-08-10 02:11:21
    在.net FCL中random没有生成long类型的随机数,不过random可以生成0-1的随机数,这就可以帮助实现random Long. 如下为一简单实现(.net 3.5): Random NextLong 1staticclassCommon2{3publicstaticlongNextLong...
  • C++ 测量整型(int, short, longlong long ) 的长度

    千次阅读 多人点赞 2019-02-27 08:31:50
    C++对整型short、int、longlong long的长度规则定义如下: - short 至少16位; - int 至少和short一样长; - long 至少32位,且至少和int一样长; - long long 至少64位,且至少和long一样长。 可能这个地方比较...
  • 1.将long型转化为int型,这里的long型是基础类型: long a = 10; int b = (int)a; 2.将Long型转换为int 型的,这里的Long型是包装类型: Long a = 10; int b=a.intValue(); 3.将Long型转换为 Integer 型的,这里的...
  • Longlong的区别

    万次阅读 2018-05-21 10:43:06
    基本类型:long,int,byte,float,double2.对象类型:Long,Integer,Byte,Float,Double其它一切java提供的,或者你自己创建的类。其中Longlong的包装类。Integer、Byte和Float也类似,一般包装类的名字首写是数值名...
  • int、longlong long类型的取值范围

    万次阅读 2018-04-05 21:19:53
    unsigned int 0~4294967295 int -2147483648~2147483647 (2*10^9)unsigned long 0~4294967295long -2147483648~2147483647long long的最大值:9223372036854775807long long的最小值:-922337203685477...
  • long long,long,int

    千次阅读 2015-03-07 11:25:25
    突然间就想到了long和int到底什么区别(发现有很多问题都是突然间想到的),然后百度、google各种查找,各种书籍:《C++ Primer》、《C程序设计语言》查看,终于明白了一些。下面的话选自《C程序设计语言》: short...
  • LONGLONG类型

    千次阅读 2013-12-24 10:56:53
    Int64是有符号 64 位整数数据类型,相当于C++中的long long、 C# 中的 long 和 SQL Server 中的 bigint,表示值介于 -2^63 ( -9,223,372,036,854,775,808) 到2^63-1(+9,223,372,036,854,775,807 )之间的整数。...
  • C语言中long long的用法

    万次阅读 2019-01-25 21:51:19
    C语言中long long的用法(转自https://blog.csdn.net/junecau/article/details/6766033) http://www.awuit.com/c-language-the-usage-of-long-long/ ...在分析BT代码的过程中,遇到了这样的定义:long long ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 421,182
精华内容 168,472
关键字:

long