精华内容
参与话题
问答
  • <p>I don't see what i'm doing wrong here with this error, both are of type ...<p>./common.go:15: invalid operation: result + (now.Usec - oldTime.Usec) (mismatched types uint64 and int32) </div>
  • c# uint 和int C#Int64和C#UInt64 (C# Int64 and C# UInt64) In C#, Int64 known as a signed integer of 8 bytes which can store both types of values including negative and positive between the ranges of ...

    c# uint 和int

    C#Int64和C#UInt64 (C# Int64 and C# UInt64)

    In C#, Int64 known as a signed integer of 8 bytes which can store both types of values including negative and positive between the ranges of -9223372036854775808 to +9223372036854775807.

    在C#中, Int64被称为8字节的有符号整数,它可以存储-9223372036854775808到+9223372036854775807范围之间的两种类型的值,包括负数和正

    UInt64 known as an unsigned integer of 8 bytes which can store only positive values between the ranges of 0 to 18446744073709551615.

    UInt64,它是8个字节的无符号整数 ,只能存储0到18446744073709551615范围之间的正值

    “ Int64”和“ UInt64”之间的区别 (Differences between 'Int64' and 'UInt64')

    Int64 UInt64
    Int64 stands for signed integer. UInt64 stands for unsigned integer.
    It's capacity to store the value is -9223372036854775808 to +9223372036854775807. It's capacity to store the value is 0 to 18446744073709551615.
    It can store negative and positive integers. It can store only positive integers.
    It occupies 8-bytes space in the memory. It also occupies 8-bytes space in the memory.
    Declaration syntax:
    Int64 variable;
    Declaration syntax:
    UInt64 variable;
    整数64 UInt64
    Int64代表有符号整数。 UInt64代表无符号整数。
    它可以存储值的容量是-9223372036854775808至+9223372036854775807。 存储值的容量为0到18446744073709551615。
    它可以存储负整数和正整数。 它只能存储正整数。
    它在内存中占用8个字节的空间。 它还在内存中占用8字节的空间。
    声明语法:
    Int64变量;
    声明语法:
    UInt64变量;

    Example:

    例:

    In this example, to explain the differences between Int64 and UInt64 in C#, we are printing their minimum and maximum values, we are also declaring two arrays – arr1 is a signed integer type and arr2 is an unsigned integer type. Initializing the arrays with corresponding negative and positive values based on their capacity.

    在此示例中,为了解释C#中Int64和UInt64之间区别 ,我们将打印它们的最小值和最大值,同时还声明了两个数组– arr1是有符号整数类型,而arr2是无符号整数类型。 根据其容量用相应的负值和正值初始化数组。

    using System;
    using System.Text;
    
    namespace Test
    {
        class Program
        {
            static void Main(string[] args)
            {
                //Int64 value range 
                Console.WriteLine("Int64 value capacity...");
                Console.WriteLine("Min: {0}, Max: {1}\n", Int64.MinValue, Int64.MaxValue);
    
                //UInt64 value range 
                Console.WriteLine("UInt64 value capacity...");
                Console.WriteLine("Min: {0}, Max: {1}\n", UInt64.MinValue, UInt64.MaxValue);
    
                //Int64 array
                Int64[] arr1 = { 	
    				-9223372036854775808, 
    				0, 
    				1287822320009, 
    				9223372036854700000, 
    				9223372036854775807
    			};
                Console.WriteLine("UInt64 array elements...");
                foreach (Int64 num in arr1)
                {
                    Console.WriteLine(num);
                }
                Console.WriteLine();
    
                //UInt64 array
                UInt64[] arr2 = { 	
    				0, 
    				1239289300, 
    				2399900900022, 
    				18446744073709000000, 
    				1844674407370955161 
    			};
                Console.WriteLine("UInt64 array elements...");
                foreach (UInt64 num in arr2)
                {
                    Console.WriteLine(num);
                }
    
                //hit ENTER to exit
                Console.ReadLine();
            }
        }
    }
    
    

    Output

    输出量

    Int64 value capacity...
    Min: -9223372036854775808, Max: 9223372036854775807
    
    UInt64 value capacity...
    Min: 0, Max: 18446744073709551615
    
    UInt64 array elements...
    -9223372036854775808
    0
    1287822320009
    9223372036854700000
    9223372036854775807
    
    UInt64 array elements...
    0
    1239289300
    2399900900022
    18446744073709000000
    1844674407370955161
    
    
    

    翻译自: https://www.includehelp.com/dot-net/Int64-and-UInt64-in-c-sharp.aspx

    c# uint 和int

    展开全文
  • Lua支持Int64和UInt64

    千次阅读 2018-04-26 22:01:34
    基础知识 c# 位运算符 &lt;&lt; 二进制左移运算符。左操作数的值向左移动右操作数指定的位数。 | 如果存在于任一操作数中,二进制 OR 运算符复制一位到结果中。 ... a|b 将得到...

    基础知识

    c# 位运算符


    • << 二进制左移运算符。左操作数的值向左移动右操作数指定的位数。
    • | 如果存在于任一操作数中,二进制 OR 运算符复制一位到结果中。

    示例
    a = 60;(二进制 0011 1100)
    b = 13;(二进制 0000 1101)
    a << 2 将得到240,即为1111 0000
    a|b 将得到 61,即为0011 1101


    c#数据类型

    • Int8 等价于byte
    • Int16 等价于short,占两个字节,-32768~32678
    • Int32 等价于int,占四个字节,-2147483648~2147483647
    • Int64 等价于long,占八个字节,-9223372036854775808 9223372036854775807

    BitConverter 类

    将基数据类型转换为一个字节数组以及将一个字节数组转换为基数据类型。
    BitConverter类包括下表说明了用于从数组的字节,与转换每个基元类型的静态方法。
    BitConvert
    更多参考MSDN

    思路

    如何支持int64?目前有几种方式:

    • 底层库全部换成luavm5.3,因为升级可能会有少许兼容性修改。
    • 直接用luavm 5.1.4 编译安卓+iOS底层库,并且打上int64的补丁。
    • int64用字符串代替。(最简单)

    c#实现,然后注册到lua虚拟机,在lua中使用

    • LuaUInt64
    using System;
    using UnityEngine;
    
    public class LuaUInt64
    {
        public static byte[] Make(UInt32 high, UInt32 low)
        {
            UInt64 uint64_value = high;
            uint64_value = ((uint64_value << 32) | low);
            return BitConverter.GetBytes(uint64_value);
        }
    
        public static byte[] FromString(string str)
        {
            UInt64 v;
            UInt64.TryParse(str, out v);
            return BitConverter.GetBytes(v);
        }
    
        public static byte[] And(byte[] left, byte[] right)
        {
            ulong uint64_value_l = BitConverter.ToUInt64(left, 0);
            ulong uint64_value_r = BitConverter.ToUInt64(right, 0);
    
            return BitConverter.GetBytes(uint64_value_l & uint64_value_r);
        }
    
        public static byte[] Or(byte[] left, byte[] right)
        {
            ulong uint64_value_l = BitConverter.ToUInt64(left, 0);
            ulong uint64_value_r = BitConverter.ToUInt64(right, 0);
    
            return BitConverter.GetBytes(uint64_value_l | uint64_value_r);
        }
    
        public static byte[] Xor(byte[] left, byte[] right)
        {
            ulong uint64_value_l = BitConverter.ToUInt64(left, 0);
            ulong uint64_value_r = BitConverter.ToUInt64(right, 0);
    
            return BitConverter.GetBytes(uint64_value_l ^ uint64_value_r);
        }
    
        public static byte[] FromDouble(double v)
        {
            return BitConverter.GetBytes((ulong)v);
        }
    
        public static double ToDouble(byte[] v)
        {
            return (double)BitConverter.ToUInt64(v, 0);
        }
    
        public static string ToString(byte[] v)
        {
            ulong uint64_value = BitConverter.ToUInt64(v, 0);
            return uint64_value.ToString();
        }
    
        public static byte[] UInt64ToBytes(UInt64 v)
        {
            return BitConverter.GetBytes(v);
        }
    
        public static UInt64 BytesToUInt64(byte[] v)
        {
            return BitConverter.ToUInt64(v, 0);
        }
    }
    
    • LuaInt64
    using System;
    using UnityEngine;
    
    public class LuaInt64
    {
        public static byte[] Make(Int32 high, Int32 low)
        {
            unchecked
            {
                UInt64 uint64_value = (UInt64)high;
                uint64_value = ((uint64_value << 32) | (UInt32)low);
                return BitConverter.GetBytes(uint64_value);
            }
        }
    
        public static byte[] FromString(string str)
        {
            Int64 v;
            Int64.TryParse(str, out v);
            return BitConverter.GetBytes(v);
        }
    
        public static byte[] And(byte[] left, byte[] right)
        {
            long int64_value_l = BitConverter.ToInt64(left, 0);
            long int64_value_r = BitConverter.ToInt64(right, 0);
    
            return BitConverter.GetBytes(int64_value_l & int64_value_r);
        }
    
        public static byte[] Or(byte[] left, byte[] right)
        {
            long int64_value_l = BitConverter.ToInt64(left, 0);
            long int64_value_r = BitConverter.ToInt64(right, 0);
    
            return BitConverter.GetBytes(int64_value_l | int64_value_r);
        }
    
        public static byte[] Xor(byte[] left, byte[] right)
        {
            long int64_value_l = BitConverter.ToInt64(left, 0);
            long int64_value_r = BitConverter.ToInt64(right, 0);
    
            return BitConverter.GetBytes(int64_value_l ^ int64_value_r);
        }
    
        public static byte[] FromDouble(double v)
        {
            return BitConverter.GetBytes((long)v);
        }
    
        public static double ToDouble(byte[] v)
        {
            return (double)BitConverter.ToInt64(v, 0);
        }
    
        public static string ToString(byte[] v)
        {
            long int64_value = BitConverter.ToInt64(v, 0);
            return int64_value.ToString();
        }
    
        public static byte[] Int64ToBytes(Int64 v)
        {
            return BitConverter.GetBytes(v);
        }
    
        public static Int64 BytesToInt64(byte[] v)
        {
            return BitConverter.ToInt64(v, 0);
        }
    }
    
    展开全文
  • 下表列出了printfscanf对于各种格式说明符可以接受的参数类型。 格式 printf scanf %c int char * %d, %i int int * %o, %u, %x ...

    下表列出了printf和scanf对于各种格式说明符可以接受的参数类型。

    格式

    printf

    scanf

    %c

    int

    char *

    %d, %i

    int

    int *

    %o, %u, %x

    unsigned int

    unsigned int *

    (续)

    格式

    printf

    scanf

    %ld, %li

    long int

    long int *

    %lo, %lu, %lx

    unsinged long int

    unsigned long int *

    %hd, %hi

    int

    short int *

    %ho, %hu, %hx

    unsigned int

    unsigned short int *

    %e, %f, %g

    double

    float *

    %le, %lf, %lg

    n/a

    double *

    %s

    char *

    char *

    %[...]

    n/a

    char *

    %p

    void

    void **

    %n

    int *

    int *

    %%

    none

    none


    (严格地讲,%lf在printf下是未定义的,但是很多系统可能会接受它。要确保可移植性,就要坚持使用%f。)

    最近在CSDN上看到一个网友写下了类似如下代码,想以小数格式输出一个整数:

    int a = 0, b = 0;
    printf(
    "%f, %d", a, b);
    可是运行结果并不尽如人意,%f字段输出了0,%d字段输出一个较大的数据。

    因为我最近刚阅读了浮点数的内存表示方法,所以对上述代码做出解释如下:
    %f为double类型,需要两个字节表示,所以,printf在遇到%f时即将a,b的两个整型数据都读了去,而到了需要输出%d的时候,只能读取b的下一个单元,自然不是所期望的数据了。

    但是有朋友说%f是float类型,%lf才是double类型,具此我特意查阅了MSDN和Linux man手册,均没有发现此类描述,在linux man手册中,说明%lf为long double类型。
    为了说明问题,我又做了几个实验:

    实验一,检查%f需要读取几个字节
    int a=0, b=0, c=5;
    printf(
    "%f,%d\n", a, b, c);
    输出结果:
    0,5
    结论:%f读取8个字节,即两个整型大小

    实验二,检查%lf需要读取几个字节
    int a=0, b=0, c=5;
    printf(
    "%lf,%d\n", a, b, c);
    输出结果:
    0,5
    结论:%lf也读取8个字节(也许和机器位宽有关,我是32位的机器)

    实验三,检查printf读取float类型数据
    float a=0.0f;
    int b=5;
    printf(
    "%f,%d\n", a, b);
    输出结果:
    0.0,5
    结论:float类型只占4个字节的数据,但前面实验一已经证明%f会读8个字节,即double类型的宽度,所以,编译器在将float类型参数入栈的时候,事先转换成了double类型。

    实验四,再次证明实验三的结论
    float a=0.0f;
    int b=5;
    printf(
    "%d,%d,%d\n", a, b);
    输出结果:
    0,0,5
    结论:a在入栈的时候,占了8个字节。

    以上4步,我觉得可以证明%f是按double类型输出的了,另外,我也知道了float类型在作为参数进行传递的时候,编译器会先将它转换成double类型。

    转自http://www.cnblogs.com/Xiao_bird/archive/2010/03/26/1696908.html

    展开全文
  • 所述的Int64 可以两种类型的值,包括所述范围之间的负的正的存储-9,223,372,036,854,775,808至9,223,372,036,854,775,807 范例: // C# program to show the // difference between Int64 // and UInt64 ...

    Int64:此 Struct用于表示64位带符号整数。所述的Int64 可以两种类型的值,包括所述范围之间的负的和正的存储-9,223,372,036,854,775,808至9,223,372,036,854,775,807
    范例:

    // C# program to show the 
    // difference between Int64 
    // and UInt64 
      
    using System; 
    using System.Text; 
      
    public
    class GFG { 
      
      // Main Method 
      static void Main(string[] args) { 
      
        // printing minimum & maximum values 
        Console.WriteLine("Minimum value of Int64: " 
                          + Int64.MinValue); 
        Console.WriteLine("Maximum value of Int64: " 
                          + Int64.MaxValue); 
        Console.WriteLine(); 
      
        // Int64 array 
        Int64[] arr1 = {-3, 0, 1, 3, 7}; 
      
        foreach (Int64 i in arr1) 
        {  
          Console.WriteLine(i); 
        } 
      } 
    }
    

    输出:

    Int64的最小值:-9223372036854775808
    Int64的最大值:9223372036854775807
    
    -3
    0
    1
    3
    7
    

    UInt64:此结构用于表示64位无符号整数。所述UINT64 只能存储唯一积极的值,其范围为0至18,446,744,073,709,551,615。

    范例:

    // C# program to show the  
    // difference between Int64  
    // and UInt64 
      
    using System; 
    using System.Text; 
      
    public class GFG{ 
          
        // Main Method 
        static void Main(string[] args) 
        { 
      
            //printing minimum & maximum values 
            Console.WriteLine("Minimum value of UInt64: "
                              + UInt64.MinValue); 
            Console.WriteLine("Maximum value of UInt64: "
                              + UInt64.MaxValue); 
            Console.WriteLine(); 
              
            //Int64 array 
            UInt64[] arr1 = { 13, 0, 1, 3, 7}; 
              
            foreach (UInt64 i in arr1) 
            { 
                Console.WriteLine(i); 
            } 
        } 
    }
    
    UInt64的最小值:0
    UInt64的最大值:18446744073709551615
    
    13
    0
    1
    3
    7
    

    C#中Int64和UInt64之间的区别

    INT64

    1.Int64 用于表示 64 位带符号整数。
    2.Int64 代表有符号整数。
    3.它可以存储负整数和正整数。
    4.它在内存中占用8 字节的 空间。
    5.Int64的范围 是-9223372036854775808到9223372036854775807。
    6. 声明Int64的语法:Int64 variable_name;

    UINT64

    1.UInt64 用于表示 64 位无符号整数。
    2.UInt64 代表无符号整数。
    3.它只能存储正整数。
    4.它还占用了8 字节的内存空间。
    5.UInt64的范围是0到18446744073709551615。
    6.声明UInt64的语法:UInt64 variable_name;

    展开全文
  • C++打印size_t和ssize_t和int64_t和uint64_t

    千次阅读 2018-08-29 18:37:57
    1.main.c //定义:typedef unsigned int size_t; typedef unsigned int uint32_t; typedef signed int ssize_t; int main(){ size_t a; ssize_t b; printf("a = %zu\n", a); // unsig...
  • 1、输出uint32_t uint32_t a = 888; printf("a is %ld", a);...2、输出uint64_t uint64_t b = 888; printf("b is %lu", b); printf("b is %lld", b); 3、输出16进制 int c =16; printf("c is 0x%08x", c)
  • uint64 字符串相互转换

    万次阅读 2015-08-07 15:57:32
    uint64转换成string snprintf函数声明int snprintf(char *restrict buf, size_t n, const char * restrict format, ...);例如:snprintf(string,sizeof(string),"%ju",GID);string转换成uint64GID=strtoull...
  • uint64_t testdata[4]={40000,40100,40200,40300}; uint64_t epoch= 315964819; for(int i=0;i;i++){ testdata[i]=testdata[i]-epoch; printf("test1=%d",testdata[i]); 测试结果如下: 40000- 31596481900 =...
  • void serializeu64(unsigned long long i,char buf[]) { unsigned long long mask = 0xff00000000000000;//字节掩码位 for(int l = 0;l<8;l++) { auto move = 8-l-1; auto f = i&mask;//取对...
  • 吭吃坑吃的编译安装完ffmpeg 0.75,在centos5.9上后,遇到了一些问题,.../usr/local/include/libavutil/common.h: In function ‘int32_t av_clipl_int32_c(int64_t)’: /usr/local/include/libavutil/common.h:170:
  • PRId64表示64位整数,在32位系统中表示long long int,在64位系统中表示long int。相当于: printf("%" "ld" "\n", value); //64bit OS printf("%" "lld" "\n", value); //32bit OS 或者 printf(
  • 在VS2017,x86编译环境下: //编程环境:vs2017 debug x86 //Written by Mr.zs #include #include #include #include using namespace std;... uint64_t a = 18446744073709551615U; cout << "a_dec = " << dec
  • jsoncpp-0.5,支持uint64

    千次阅读 2015-07-24 16:50:28
    现在很多地方都需要用到uint64,比如传递时间,你传递一个unix时间戳如(1437727512)总比传递一个...在从官网下载的jsoncpp-0.5使用的时候,他最大只支持uint,而没有uint64,所以我把Uint64加上去了,没有加int64. 按
  • 在嵌入式编程中经常遇到用uint8_t、uint16_t、uint32_t、uint_fast16_t之类的关键字定义一些整型变量,但是具体表示什么意思,并不是太清楚,只是把它当成int之类的整型变量定义关键字。...int和uint的区别:...
  • uint8_t / uint16_t / uint32_t /uint64_t 是什么数据类型,在嵌入式编程中经常会遇见。首先#define uint unsigned int;int和uint的区别:一个有符号,一个无符号。uint在单片机中经常用到,定义一个无符号整型变量...
  • 工作中经常碰到int8_t、int16_t、int32_t、int64_t、uint8_t、size_t、ssize_t等数据类型,所以有必要对此进行梳理。 int_t同类 int_t 为一个结构的标注,可以理解为type/typedef的缩写,表示它是通过typedef定义...
  • 工作中经常碰到int8_t、int16_t、int32_t、int64_t、uint8_t、size_t、ssize_t等数据类型,所以有必要对此进行梳理。 int_t同类 int_t 为一个结构的标注,可以理解为type/typedef的缩写,表示它是通过typedef定义...
  • LitJson的问题,借鉴于:https://github.com/lbv/litjson/issues/30https://stackoverflow.com/questions/21742126/litjson-library-for-format-float-double-issue 告诉LitJson一种转换方式: 添加后问题解决。...
  • 数字类型 4.5.2.1 整型 int 浮点型 ...int uint 在 32 位操作系统上,它们均使用 32 位(4 个字节),在 64 位操作系统上,它们均使用 64 位(8 个字节)。 uintptr 的长度被设定为足够存放一个指针即可。 Go
  • int_t int_t是一个大类,不同的机器有不同的字长,所以采用typedef的形式,便于后期维护。 int8_t : typedef signed char; uint8_t : typedef unsigned char; int16_t : typedef signed short ; uint16_t : typedef...
  • <pre><code>var x uint64 = 1<<64 - 1 fmt.Printf("%d %x; %d %x ", x, x, int64(x), int64(x)) </code></pre> <p>prints <pre><code>18446744073709551615 ffffffffffffffff; -1 -1 </code></pre> <p>As a...

空空如也

1 2 3 4 5 ... 20
收藏数 635
精华内容 254
关键字:

uint64和int64