精华内容
下载资源
问答
  • 符合IEEE754规则的4字节数组转换为单精度浮点数的Labview实用小vi
  • 今天小编就为大家分享一篇Android String类型转换为float、double和int的工具类方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Trans(double)返回2进制 TransToHex(double)返回16进制 GetCrcstring(string data, ref string crc)返回冗余校验
  • float型数据与字节数组的转化

    千次阅读 2016-04-06 14:35:31
    float型数据与字节数组的转化 MCU和PC的浮点数都是基于IEEE754格式的。有4字节(float)、8字节(double)、10字节(有一些不支持)。这里以4字节(float)浮点数为例。 一、C语言 转化常见的方法有: 1、强制...

    float型数据与字节数组的转化

    MCUPC的浮点数都是基于IEEE754格式的。有4字节(float)8字节(double)、10字节(有一些不支持)。这里以4字节(float)浮点数为例。

    一、C语言
    转化常见的方法有:
    1
    、强制指针类型转换。

    [html]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. //转换float数据到字节数组  
    2. unsigned char i;  
    3. float floatVariable;  
    4. unsigned char charArray[4];  
    5. (unsigned char) *pdata = ((unsigned char)*)&floatVariable;  //把float类型的指针强制转换为unsigned char型  
    6. for(i=0;i<4;i++)  
    7. {  
    8.     charArray[i] = *pdata++;//把相应地址中的数据保存到unsigned char数组中       
    9. }  
    10.   
    11. //转换字节数组到float数据  
    12. float   floatVariable;  
    13. unsigned char  i;   
    14. void   *pf;       
    15. pf = &floatVariable;   
    16. (unsigned char) * px = charArray;    
    17.   
    18. for(i=0;i<4;i++)  
    19. {  
    20.     *(((unsigned char)*)pf+i)=*(px+i);       
    21. }     


    2、使用结构和联合

    [html]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. //定义结构和联合  
    2. typedef union   
    3. {  
    4.     struct   
    5.     {  
    6.         unsigned char low_byte;  
    7.         unsigned char mlow_byte;  
    8.         unsigned char mhigh_byte;  
    9.         unsigned char high_byte;  
    10.      }float_byte;  
    11.             
    12.      float  value;  
    13. }FLAOT_UNION;  


    这样可以在程序中直接对各数据赋值,然后获取数据。如对float_byte中的各字节赋值,可以直接从value中获取float型数据,反之亦然。

    注意,从上面的转换可以看到,对于定义的数组unsignedchar charArray[4],一般charArray[0]代表低字节,charArray[3]代表高字节。

    二、c#

    c#中可以使用BitConverter类中的函数进行转换,如下:

    名称

    说明

    GetBytes(Double)

    以字节数组的形式返回指定的双精度浮点值。

    GetBytes(Single)

    以字节数组的形式返回指定的单精度浮点值。

    ToDouble

    返回由字节数组中指定位置的八个字节转换来的双精度浮点数。

    ToSingle

    返回由字节数组中指定位置的四个字节转换来的单精度浮点数。

    BitConverter类进行基础数据类型与字节数组之间的相互转换,此类便于操作基本形式的类型。一个字节定义为一个 8位无符号整数。包含的方法如下:

    名称

    说明

    DoubleToInt64Bits

    将指定的双精度浮点数转换为 64 位有符号整数。

    GetBytes(Boolean)

    以字节数组的形式返回指定的布尔值。

    GetBytes(Char)

    以字节数组的形式返回指定的 Unicode 字符值。

    GetBytes(Double)

    以字节数组的形式返回指定的双精度浮点值。

    GetBytes(Int16)

    以字节数组的形式返回指定的 16 位有符号整数值。

    GetBytes(Int32)

    以字节数组的形式返回指定的 32 位有符号整数值。

    GetBytes(Int64)

    以字节数组的形式返回指定的 64 位有符号整数值。

    GetBytes(Single)

    以字节数组的形式返回指定的单精度浮点值。

    GetBytes(UInt16)

    以字节数组的形式返回指定的 16 位无符号整数值。

    GetBytes(UInt32)

    以字节数组的形式返回指定的 32 位无符号整数值。

    GetBytes(UInt64)

    以字节数组的形式返回指定的 64 位无符号整数值。

    Int64BitsToDouble

    将指定的 64 位有符号整数转换成双精度浮点数。

    ToBoolean

    返回由字节数组中指定位置的一个字节转换来的布尔值。

    ToChar

    返回由字节数组中指定位置的两个字节转换来的 Unicode 字符。

    ToDouble

    返回由字节数组中指定位置的八个字节转换来的双精度浮点数。

    ToInt16

    返回由字节数组中指定位置的两个字节转换来的 16 位有符号整数。

    ToInt32

    返回由字节数组中指定位置的四个字节转换来的 32 位有符号整数。

    ToInt64

    返回由字节数组中指定位置的八个字节转换来的 64 位有符号整数。

    ToSingle

    返回由字节数组中指定位置的四个字节转换来的单精度浮点数。

    ToString( array<Byte []()>[])

    将指定的字节数组的每个元素的数值转换为它的等效十六进制字符串表示形式。

    ToString( array<Byte []()>[], Int32)

    将指定的字节子数组的每个元素的数值转换为它的等效十六进制字符串表示形式。

    ToString( array<Byte []()>[], Int32, Int32)

    将指定的字节子数组的每个元素的数值转换为它的等效十六进制字符串表示形式。

    ToUInt16

    返回由字节数组中指定位置的两个字节转换来的 16 位无符号整数。

    ToUInt32

    返回由字节数组中指定位置的四个字节转换来的 32 位无符号整数。

    ToUInt64

    返回由字节数组中指定位置的八个字节转换来的 64 位无符号整数。

     

    [cpp]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. <p><span style="font-size:18px"></span></p>  
    展开全文
  • /*uint8 无符号一个字节 Int16 有符号 两个字节 Uint16 无符号两个字节 Int32 有符号4字节 Float4字节,正字节 */ //无符号数据转换,一个字节 public static int Uint8ToInt1W(byte byt) ...
     /*uint8 无符号一个字节
              Int16 有符号 两个字节
              Uint16 无符号两个字节
              Int32 有符号4字节
              Float4字节,正字节
            */
    
            //无符号数据转换,一个字节
            public static int Uint8ToInt1W(byte byt)
            {
                //UInt16
                return Convert.ToInt16(byt);
            }
            //两个字节有符号数转换,有符号
            public static int Int16ToInt2Y(byte[] byt)
            {
                return BitConverter.ToInt16(byt, 0); //
            }
    
            //两个字节的无符号数
            public static int Uint16ToInt2W(byte[] byt)
            {
                Array.Reverse(byt);
                return BitConverter.ToUInt16(byt, 0); //
            }
    
            //有符号四字节转换
            public static int Int32ToInt4Y(byte[] byt)
            {
                Array.Reverse(byt);
                return BitConverter.ToInt32(byt, 0);
            }
    
            //单精度数转换,注意reverse
            public static float FloatToFloat4Y(byte[] byt)
            {
                Array.Reverse(byt);
                return BitConverter.ToSingle(byt, 0);
            }

     

    展开全文
  • 字节数据类型数组(double,float,int,long)数组数组和byte数组的相互转换都可以基于java.nio.Buffer实现. java.nio.DoubleBuffer对应double[], java.nio.FloatBuffer对应float[], java.nio.LongBuffer对应long[]...

    多字节数据类型数组(double,float,int,long)数组数组和byte数组的相互转换都可以基于java.nio.Buffer实现.
    java.nio.DoubleBuffer对应double[],
    java.nio.FloatBuffer对应float[],
    java.nio.LongBuffer对应long[],
    java.nio.IntBuffer对应int[]

    byte[] 转 double[],float[],int[]…

    byte[]转double[],float[],int[]…很简单因为ByteBuffer本身就有asDoubleBuffer,asFloatBuffer,asIntBuffer等方法,可以将ByteBuffer直接转换为DoubleBuffer,FloatBuffer,IntBuffer…;
    代码实现如下:

    	public static double[] asDoubleArray(byte[] input){
    		if(null == input ){
    			return null;
    		}
    		DoubleBuffer buffer = ByteBuffer.wrap(input).asDoubleBuffer();
    		double[] res = new double[buffer.remaining()];
    		buffer.get(res);
    		return res;
    	}
    	public static float[] asFloatArray(byte[] input){
    		if(null == input ){
    			return null;
    		}
    		FloatBuffer buffer = ByteBuffer.wrap(input).asFloatBuffer();
    		float[] res = new float[buffer.remaining()];
    		buffer.get(res);
    		return res;
    	}
    	public static int[] asIntArray(byte[] input){
    		if(null == input ){
    			return null;
    		}
    		IntBuffer buffer = ByteBuffer.wrap(input).asIntBuffer();
    		int[] res = new int[buffer.remaining()];
    		buffer.get(res);
    		return res;
    	}
    	public static long[] asLongArray(byte[] input){
    		if(null == input ){
    			return null;
    		}
    		LongBuffer buffer = ByteBuffer.wrap(input).asLongBuffer();
    		long[] res = new long[buffer.remaining()];
    		buffer.get(res);
    		return res;
    	}
    	public static short[] asShortArray(byte[] input){
    		if(null == input ){
    			return null;
    		}
    		ShortBuffer buffer = ByteBuffer.wrap(input).asShortBuffer();
    		short[] res = new short[buffer.remaining()];
    		buffer.get(res);
    		return res;
    	}
    

    double[],float[],int[]…转byte[]

    反过来,从多字节类型数组(double[],float[],long[]…)转byte[]要稍麻烦一些,因为多字节类型数组对应的Buffer类并没提供asByteBuffer这样的方法.所以要自己写些代码进行转换(比如将DoubleBuffer转为ByteBuffer),实现代码如下:

    	/**
    	 * {@link DoubleBuffer} TO {@link ByteBuffer}
    	 * @param input
    	 * @return
    	 */
    	public static ByteBuffer asByteBuffer(DoubleBuffer input){
    		if(null == input ){
    			return null;
    		}
    		ByteBuffer buffer = ByteBuffer.allocate(input.capacity()* (Double.SIZE/8));
    		while(input.hasRemaining()){
    			buffer.putDouble(input.get());
    		}
    		return buffer;
    	}
    	/**
    	 * double[] TO byte[]
    	 * @param input
    	 * @return
    	 */
    	public static byte[] asByteArray(double[] input){
    		if(null == input ){
    			return null;
    		}
    		return asByteBuffer(DoubleBuffer.wrap(input)).array();
    	}
    	/**
    	 * {@link FloatBuffer} TO {@link ByteBuffer}
    	 * @param input
    	 * @return
    	 */
    	public static ByteBuffer asByteBuffer(FloatBuffer input){
    		if(null == input ){
    			return null;
    		}
    		ByteBuffer buffer = ByteBuffer.allocate(input.capacity()* (Float.SIZE/8));
    		while(input.hasRemaining()){
    			buffer.putFloat(input.get());
    		}
    		return buffer;
    	}
    	/**
    	 * float[] TO byte[]
    	 * @param input
    	 * @return
    	 */
    	public static byte[] asByteArray(float[] input){
    		if(null == input ){
    			return null;
    		}
    		return asByteBuffer(FloatBuffer.wrap(input)).array();
    	}
    	/**
    	 * {@link IntBuffer} TO {@link ByteBuffer}
    	 * @param input
    	 * @return
    	 */
    	public static ByteBuffer asByteBuffer(IntBuffer input){
    		if(null == input ){
    			return null;
    		}
    		ByteBuffer buffer = ByteBuffer.allocate(input.capacity()* (Integer.SIZE/8));
    		while(input.hasRemaining()){
    			buffer.putInt(input.get());
    		}
    		return buffer;
    	}
    	/**
    	 * int[] TO byte[]
    	 * @param input
    	 * @return
    	 */
    	public static byte[] asByteArray(int[] input){
    		if(null == input ){
    			return null;
    		}
    		return asByteBuffer(IntBuffer.wrap(input)).array();
    	}
    	/**
    	 * {@link LongBuffer} TO {@link ByteBuffer}
    	 * @param input
    	 * @return
    	 */
    	public static ByteBuffer asByteBuffer(LongBuffer input){
    		if(null == input ){
    			return null;
    		}
    		ByteBuffer buffer = ByteBuffer.allocate(input.capacity()* (Long.SIZE/8));
    		while(input.hasRemaining()){
    			buffer.putLong(input.get());
    		}
    		return buffer;
    	}
    	/**
    	 * long[] TO byte[]
    	 * @param input
    	 * @return
    	 */
    	public static byte[] asByteArray(long[] input){
    		if(null == input ){
    			return null;
    		}
    		return asByteBuffer(LongBuffer.wrap(input)).array();
    	}
    	/**
    	 * {@link ShortBuffer} TO {@link ByteBuffer}
    	 * @param input
    	 * @return
    	 */
    	public static ByteBuffer asByteBuffer(ShortBuffer input){
    		if(null == input ){
    			return null;
    		}
    		ByteBuffer buffer = ByteBuffer.allocate(input.capacity()* (Short.SIZE/8));
    		while(input.hasRemaining()){
    			buffer.putShort(input.get());
    		}
    		return buffer;
    	}
    	/**
    	 * short[] TO byte[]
    	 * @param input
    	 * @return
    	 */
    	public static byte[] asByteArray(short[] input){
    		if(null == input ){
    			return null;
    		}
    		return asByteBuffer(ShortBuffer.wrap(input)).array();
    	}
    
    展开全文
  • 都是用类BitConverter...(1)float、int等类型bytes数组 使用:GetBytes。 可以将常见的各种数据类型转换为byte数组。 参见: BitConverter.GetBytes Method 例如: float fvalue = 1.02; byte[] bytes ...

    都是用类BitConverter完成,该类定义了一组静态函数实现双向转换,位于System下。
    这里涉及双向转换问题和大小端转换的问题。

    (1)float、int等类型转bytes数组
    使用:GetBytes。
    可以将常见的各种数据类型转换为byte数组。
    参见: BitConverter.GetBytes Method

    例如:

    float fvalue = 1.02;
    byte[] bytes = BitConverter.GetBytes(fvalue); 
    

    (2) 数组向各种类型转换
    使用:ToXXX系列函数完成转换。ToXXX(Byte[] bytes,Int32 startIndex)
    其中第一个参数为输入的字节数组,第二个参数为该数组中的字节偏移。
    常见的有:
    ToBoolean(Byte[], Int32)
    返回由字节数组中指定位置的一个字节转换来的布尔值。
    ToChar(Byte[], Int32)
    返回由字节数组中指定位置的两个字节转换来的 Unicode 字符。
    ToDouble(Byte[], Int32)
    返回由字节数组中指定位置的八个字节转换来的双精度浮点数。
    ToInt16(Byte[], Int32)
    返回由字节数组中指定位置的两个字节转换来的 16 位有符号整数。
    ToInt32(Byte[], Int32)
    返回由字节数组中指定位置的四个字节转换来的 32 位有符号整数。
    ToInt64(Byte[], Int32)
    返回由字节数组中指定位置的八个字节转换来的 64 位有符号整数。
    ToSingle(Byte[], Int32)
    返回由字节数组中指定位置的四个字节转换来的单精度浮点数。
    ToString(Byte[])
    将指定的字节数组的每个元素的数值转换为它的等效十六进制字符串表示形式。
    ToString(Byte[], Int32)
    将指定的字节子数组的每个元素的数值转换为它的等效十六进制字符串表示形式。
    ToString(Byte[], Int32, Int32)
    将指定的字节子数组的每个元素的数值转换为它的等效十六进制字符串表示形式。
    ToUInt16(Byte[], Int32)
    返回由字节数组中指定位置的两个字节转换来的 16 位无符号整数。
    ToUInt32(Byte[], Int32)
    返回由字节数组中指定位置的四个字节转换来的 32 位无符号整数。
    ToUInt64(Byte[], Int32)
    返回由字节数组中指定位置的八个字节转换来的 64 位无符号整数。

    具体参见:BitConverter Class

    (3) 关于大小端转换与反序。
    注意:该函数的转换中涉及大小端的问题,具体的字节顺序依赖与所在计算机本身的大小端!!
    所以,如果处理的是来自网络或串口的数据,一定要注意是否跟本地计算机的一样!
    一般x86系列的计算机都是小端的,即高字节在低位,低字节在高位。例如整数:0x12345678。小端存储的结果为:0x78563412。
    那么如何转序呢?有以下几种方法:
    (a)使用Array.Reverse方法。
    Reverse(Array, Int32, Int32)
    反转一维 Array 中某部分元素的元素顺序。分别为从某一个起始的,长度。
    Reverse(Array)
    反转整个一维 Array 中元素的顺序。
    (b)对于整型可以使用这个转换函数:这里只能针对整型的!
    (i)网络序转本机序
    NetworkToHostOrder(Int32)
    将整数值由网络字节顺序转换为主机字节顺序。
    NetworkToHostOrder(Int64)
    将长值由网络字节顺序转换为主机字节顺序。
    NetworkToHostOrder(Int16)
    将短值由网络字节顺序转换为主机字节顺序。
    (ii)本机序转网络序
    IPAddress.HostToNetworkOrder Method
    HostToNetworkOrder(Int16)
    将短值由主机字节顺序转换为网络字节顺序。
    HostToNetworkOrder(Int32)
    将整数值由主机字节顺序转换为网络字节顺序。
    HostToNetworkOrder(Int64)
    将长值由主机字节顺序转换为网络字节顺序。

    展开全文
  • 浮点数与字节数组相互转换

    热门讨论 2012-01-03 10:54:36
    可以将字节数组转换为浮点数,双精度数,反之亦然,通讯调试必备工具。徐州恺尔电子设备有限公司-李广
  • 单精度浮点数与16进制数相互转换工具,单精度浮点数与16进制数相互转换工具,单精度浮点数与16进制数相互转换工具,
  • c语言中double与float的区别

    万次阅读 多人点赞 2020-02-03 23:19:07
    C语言中小数的数据类型为 float 或 double:float 称为单精度浮点数,double 称为精度浮点数。不像整数,小数的长度始终是固定的,float 占用4个字节,double 占用8个字节。 %f 默认保留六位小数,不足六位以 0 补...
  • 精度浮点数在机内占8个字节 (2)有效数字位数不同 单精度浮点数有效数字8位 精度浮点数有效数字16位 (3)所能表示数的范围不同 单精度浮点的表示范围:-3.40E+38 ~ +3.40E+38 精度浮点的表示范围:-1.79E+...
  • 用于将Modbus通信中感应器返回的数据截取后的数据处理成浮点数,目前只弄了四字节的十六进制数转换为单精度浮点数。
  • 因为IEEE754标准(IEEE二进制浮点数算术标准)定义了两种浮点数格式:32位单精度和64位精度,如下图所示: IEEE 754 的规定: 32位单精度格式中包含1bit符号位s,8bit阶码e,23bit尾数f 64位精度格式中包含1bit...
  • 在进行工控数据采集时,很多设备都是使用RS485 接口传输modbus RTU协议数据,比较常见的是,传输一个字(2个bytes),但是有些变量超过了两个字节,比如float类型、int、long、double类型数据在modbus RTU传输时,该...
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    原理是什么Java语言有哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序和小程序的主类有何不同?Java应用程序与小程序之间有那些差别?Java和C++的区别Oracle JDK 和 OpenJDK 的...
  • 本人自己封装的类库(附带源码,希望高手完善一下封装)。 ... * double: 精度浮点数(小数) 占8个字节 64位二进制 byte[0] byte[1] byte[2] byte[3] byte[4] * byte[5] byte[6] byte[7] */
  • Convertor按照IEEE 754标准对Float和Double类型进行转换
  • 浮点数与字节数据转换详解

    万次阅读 2017-10-23 21:01:54
    本文参考网络上的诸多文章,首先分析了单精度浮点数是如何在机器中存储的,然后将浮点数转换为内存中显示的字节数据,进而又将字节数据转换为单精度浮点数。主要用于对数据存储的分析和字节流转换为有效数据方面。
  • Python中 整形 字节 浮点数互

    千次阅读 2018-05-10 14:24:04
    import struct byte_4 = struct.pack('&...float_num = struct.unpack('&gt;f', byte_4) # 将字节转换为浮点数类型 &gt;&gt;&gt; (0.3050229847431183,) 亲自测试, 有效!...
  • double 转float 损失精度

    千次阅读 2018-04-03 16:15:13
    有符号型: short 在内存中占两个字节,范围为-2^15~(2^15-1) int 在内存中占四个字节,范围为-2^31~(2^31-1) long在内存中占四个字节,范围为-2^31~2^31-1 无符号型:最高位不表示符号位 unsigned short 在内存...
  • 浮点数据与4个单字节的转换

    万次阅读 多人点赞 2016-03-05 23:57:46
    在串口、IIC、SPI等数据传送时基本上都是一次传送一个字节的数据,如果要传送浮点数据? 通常是将浮点数乘以一个倍数,如10,100,1000,10000等,然后将其转换为整型数据再转化为单个字节进行传送。如果这个数据是...
  • c# 单精度与字节类型相互转换

    千次阅读 2018-10-12 19:04:11
    一、单精度转字节类型   //获取数据 float tem_coef =0; tem_coef = Convert.ToSingle(Tem_trans_coeffic_set1.Text); //单精度转字节 byte[] tem_data = new byte[4];//存放单精度转换为四字节的数组 tem_...
  • 由于JavaScript只有num类型,所以进制转换中单精度和精度浮点数没法直接转换,下面是根据公式计算的,原理网上有。背景是我通过udp接收终端远程传输的modbus的数据,解析出来的十六进制数据需转换成单精度和精度...
  • c# 类型转换string To float

    万次阅读 2016-07-29 13:32:29
    c# 类型转换string To float
  • java float转换int

    千次阅读 2019-08-02 20:23:11
    1.Java的简单类型及其封装器类 ⑴Java简单类型与封装类 我们知道,Java语言是典型的...当然,Java在提供大量的其它类时,也提供了与简单数据类型对应的封装类,于是,Java中就有了诸如int和Integer(floatFloat、...
  • Float和Double的讲解

    千次阅读 2015-01-04 16:30:52
    java中Double和Float之间的转化及其double和float之间的区别
  • 单精度float精度double

    千次阅读 2020-01-31 17:07:01
    单精度,也即float,一般在计算机中存储占用4字节,也32位,有效位数为7位;精度(double)在计算机中存储占用8字节,64位,有效位数为16位。 IEEE754规范: 单精度格式:1位符号,8位指数,23位小数。 ...
  • C语言

    万次阅读 多人点赞 2019-12-18 23:01:50
    char* 2个字节 int 4个字节 float 4个字节 double 8个字节 19.10进制8进制,手算用 除8取余数法得 20.十进制十六进制为:除十六取余直到商为0,余数从后往前读。 21.%f代表单精度浮点型数据(float),%lf代表...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 84,368
精华内容 33,747
关键字:

双字节转float