浮点数如何变为网络字节序

Ⅰ C语言的浮点型怎么转换为整型

C语言中，浮点型转换为整型可以用：强制类型转换、自动类型转换，例如：(int)3.14、int a = 3.14。

1、强制类型转换

强制类型转换是通过类型转换运算来实现的。其一般形式为：（类型说明符）（表达式），其功能是把表达式的运算结果强制转换成类型说明符所表示的类型。

例如： (double) a 把a转换为双精度浮点型，(int)(x+y) 把x+y的结果转换为整型。

2、自动类型转换

（1）执行算术运算时，低类型(短字节)可以转换为高类型(长字节)；例如： int型转换成double型，char型转换成int型等。

（2）赋值表达式中，等号右边表达式的值的类型自动隐式地转换为左边变量的类型，并赋值给它。

（3）函数调用时，将实参的值传递给形参，系统首先会自动隐式地把实参的值的类型转换为形参的类型，然后再赋值给形参。

（4）函数有返回值时，系统首先会自动隐式地将返回表达式的值的类型转换为函数的返回类型，然后再赋值给调用函数返回。

(1)浮点数如何变为网络字节序扩展阅读：

C语言中常用的数据类型：

1、int：整型

2、float：单精度浮点型

3、double：双精度浮点型

4、char：字符型

5、char *：字符指针型

Ⅱ 浮点类型是如何存储的

计算机中最小的存储单位是bit只能保存0和1，整数在内存中如何存储我们都知道，将要存储的数字转成2进制即可

用windows自带的计数器可以方便的查看整数对应的2进制值
如：
byte类型（单字节）

那浮点类型是如何用这么少的字节（如float 4字节）表示这么大（float 最大 3.4028235E38）的数字呢？

浮点数，是属于有理数中某特定子集的数的数字表示，在计算机中用以近似表示任意某个实数。具体的说，这个实数由一个整数或定点数（即尾数）乘以某个基数（计算机中通常是2）的整数次幂得到，这种表示方法类似于基数为10的科学计数法。

科学计数法是一种记数的方法。把一个数表示成a与10的n次幂相乘的形式（1≤|a|<10，a不为分数形式，n为整数），这种记数法叫做科学计数法。当我们要标记或运算某个较大或较小且位数较多时，用科学计数法免去浪费很多空间和时间。

这也是一种目前最常用的浮点数标准！为许多CPU与浮点运算器所采用。

简单的说就是将一个浮点数字拆成3个部分（符号部分、指数部分、小数部分） 存储在连续的bit中，类似科学计数法。

用 {S，E，M}来表示一个数 V 的，即 V =（-1）S × M × 2E ，如下：

其中：

其中d.dd...d 为有效数字，β为基数，e 为指数

有效数字中 数字的个数 称为 精度 ，我们可以用 p 来表示，即可称为 p 位有效数字精度。
每个数字 d 介于 0 和基数 β 之间，包括 0。

对十进制的浮点数，即基数 β 等于 10 的浮点数而言，上面的表达式非常容易理解。
如 12.34，我们可以根据上面的表达式表达为：
1×10 ¹ + 2×10 ⁰ + 3×10 ^-1 + 4×10 ^-2
其规范的浮点数表达为： 1.234×10 ¹ 。

但对二进制来说，上面的表达式同样可以简单地表达。
唯一不同之处在于：二进制的 β 等于 2，而每个数字 d 只能在 0 和 1 之间取值。

如二进制数 1001.101 ，我们可以根据上面的表达式表达为：
1×2 ³ + 0×2 ² + 0×2 ¹ + 1×2 ⁰ + 1×2 ^-1 + 0×2 ^-2 + 1×2 ^-3
其规范浮点数表达为： 1.001101×2 ³ 。

二进制数 1001.101 转成十进制如下：

由上面的等式，我们可以得出：
向左移动二进制小数点一位相当于这个数除以 2，而向右移动二进制小数点一位相当于这个数乘以 2。
如 101.11 = 5又3/4 (5.75)，向左移动一位，得到 10.111 = 2又7/8 （2.875）。

除此之外，我们还可以得到这样一个基本规律：
一个十进制小数要能用浮点数精确地表示，最后一位必须是 5（当然这是必要条件，并非充分条件）。
如下面的示例所示：

基本换算方法：
将10进制的数拆分成整数和小数两个部分
整数部分除以2，取余数；小数部分乘以2，取整数位。

示例：
将十进制 1.1 转成 二进制

整数部分：1
1

小数部分：0.1

二进制形式表示为：
1.000110011001100110011...

再加上整数1，约等于：
1.099609375

计算的位数越多越精确

注意：
二进制小数不像整数一样，只要位数足够，它就可以表示所有整数。
在有限长度的编码中，二进制小数一般无法精确的表示任意小数，比如十进制小数0.2，我们并不能将其准确的表示为一个二进制数，只能增加二进制长度提高表示的精度。

根据 IEEE 754 浮点“双精度格式”位布局。

如果参数是正无穷大，则结果为 0x7ff0000000000000L。
如果参数是负无穷大，则结果为 0xfff0000000000000L。
如果参数是 NaN，则结果为 0x7ff8000000000000L。

根据 IEEE 754 浮点“单一格式”位布局。

如果参数为正无穷大，则结果为 0x7f800000。
如果参数为负无穷大，则结果为 0xff800000。
如果参数为 NaN，则结果为 0x7fc00000。

这里以 double类型说明

将一个浮点数与上面的掩码进行与运算，即可得到对应的 符号位、指数位、尾数位 的值。

1.000110011001100110011...

所以存为：
0 01111111111 000110011001100110011...

根据 IEEE 754 规范

在二进制，第一个有效数字必定是“1”，因此这个“1”并不会存储。
单精和双精浮点数的有效数字分别是有存储的23和52个位，加上最左边没有存储的第1个位，即是24和53个位。

通过计算其能表示的最大值，换十进制来看其精度：

浮点运算很少是精确的，只要是超过精度能表示的范围就会产生误差。而往往产生误差不是因为数的大小，而是因为数的精度。

我自己理解为分两种情况（这个不一定是对）

通过上面的转换示例，我们知道小数的二进制表示一般都不是精确的，在有限的精度下只能尽量的表示近似值

值本身就不是精确的，再进行计算就很可能产生误差

输出：

0.1
原始值： 0 01111111011
指数：1019 -1023 = -4
二进制形式：
0.0001

0.2
原始值：0 01111111100
指数：1020 -1023 = -3
二进制形式：
0.00

0.3
原始值：0 01111111101
指数：1021 = -2
二进制形式：
0.00

二进制加法运算

这里用float验证，float最大的精度是8位数

对于不能精确的表示的数，采取一种系统的方法：找到“最接近”的匹配值，它可以用期望的浮点形式表现出来，这就是舍入。

对于舍入，可以有很多种规则，可以向上舍入，向下舍入，向偶数舍入。如果我们只采用前两种中的一种，就会造成平均数过大或者过小，实际上这时候就是引入了统计偏差。如果是采用偶数舍入，则有一半的机会是向上舍入，一半的机会是向下舍入，这样子可以避免统计偏差。而 IEEE 754 就是采用向最近偶数舍入（round to nearest even）的规则。

（这段是网上抄的）

这里以java语言示例，用大端的方式示例（网络序）

java中是以大端模式存储的，java对我们屏蔽了内部字节顺序的问题以实现跨平台！

实际在不同的cpu架构下，存储方式不同，我们常用的X86是以小端的模式存储的。

网络传输一般采用大端序，也被称之为网络字节序，或网络序。IP协议中定义大端序为网络字节序。

输出：

Ⅲ 怎么把浮点值转换为4字节的16进制数

我关于这个写了一篇论文.
在公司现有的产品通讯协议升级的过程中，涉及到了浮点数的传输。利用传统的做法就是将浮点数乘以一个整数倍数，将其放大到一定的精度再取整，将取整后的整数传输出去，到了目的地，再将整数除以相应的倍数，还原回真实值，这种方法虽然可以避免传输过程中浮数的操作，可是却给通讯双方带来了计算上的压力，将一个浮点数放大若干倍及缩小若干倍是需要进行乘除法运算的。而且标准的Modbus RTU协议也是允许传递浮点数操作的，因此，在通讯中使用浮点数是，最主要的是要注意浮点数在内存中的存储格式，这是通讯双方正确解析通讯数据的前提。IEEE委员会对浮点数的结构做了明确的规定，而且现在大多数的硬件厂商及编译器都采用了IEEE对浮点数的规定，IEEE规定了二进制浮点数可采用32位、64位及128位表示。对于我们公司所使用的研发的产品及对未来产品发展的预测，使用32位浮点数足以满足数据的大小及精度的要求，因此我们通讯协议中的浮点数采用32位二进制表示，根据IEEE的规定，32位浮点数表示为
（-1）s X be X m
其中
S为0或1
b为所使用的进制
e为一个整数且eMin<=e<=eMax
m被表示为下面一组数字形式的数值，d0.d1d2d3d4……dp-1(di是一个整数且0<=di<=b)，因此 0<=m<b。
对于用32位二进制表示的浮点数，b的取值为2，eMin = 0,eMax = 127。例如-11的二进制表示为-1011，转换为上面的IEEE表示形式为
(-1)1 X (10)3 X (1.011)，将IEEE表示形式编码为32位二进制数的表示形式为

其中e使用移码表示，
IEEE对浮点数规定相关内容参见《The IEEE Standard for Floating-Point Arithmetic》。

Ⅳ C中socket传输时int,long.float类型要怎么处理需要转成网络字节顺序么怎么转

1. 要。只要类型长度超过1字节的，都要转换网络字节序。

2. socket api，这些很容易搜索到的，htonl，htos，用法还是自己找吧，自己找的，才会印象深刻

Ⅳ 计算机组成原理——浮点数表示方法

就是在二进制中，一个数的小数点可以可以通过乘以2的幂次来改变位置，这是其原理 。

浮点数的组成：阶符+ 阶码 +数符+ 尾数

计算机中表示浮点数的字长通常为32位，其中7位作阶码，1位为阶符，23位尾数，1位作数符

例如用2个字节表示一个浮点数（32写起来麻烦，所以用2个字节就是16位来举例，呵呵希望谅解） （72.45x10^5)D先换成普通二进制数（11011101000110011001000）B

然后开始像十进制数的科学计数法那样写成约等于（0.1101110）Bx(2^23)D

之后再将后半部分的(2^23)D转换成（2^10111)B

于是整个数就变成了（0.1101110x2^10111)B

在计算机中表示成0001011101101110 其中第一个0是阶符表示指数是正的第九个0表示尾数是正的他们中间的就是阶码，后面的就是尾数。

Ⅵ 如何用C语言实现向某个IP发送数据包（例如4个浮点数）

使用socket编程即可。
1、网络的Socket数据传输是一种特殊的I/O，Socket也是一种文件描述符。Socket也具有一个类似于打开文件的函数调用Socket()，该函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。

2、下面用Socket实现一个windows下的c语言socket通信例子，这里客户端传递一个字符串，服务器端进行接收。

【服务器端】
#include "stdafx.h"
#include <stdio.h>
#include <winsock2.h>
#include <winsock2.h>
#define SERVER_PORT 5208 //侦听端口
void main()
{
WORD wVersionRequested;
WSADATA wsaData;
int ret, nLeft, length;
SOCKET sListen, sServer; //侦听套接字，连接套接字
struct sockaddr_in saServer, saClient; //地址信息
char *ptr;//用于遍历信息的指针
//WinSock初始化
wVersionRequested=MAKEWORD(2, 2); //希望使用的WinSock DLL 的版本
ret=WSAStartup(wVersionRequested, &wsaData);
if(ret!=0)
{
printf("WSAStartup() failed!\n");
return;
}
//创建Socket,使用TCP协议
sListen=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (sListen == INVALID_SOCKET)
{
WSACleanup();
printf("socket() faild!\n");
return;
}
//构建本地地址信息
saServer.sin_family = AF_INET; //地址家族
saServer.sin_port = htons(SERVER_PORT); //注意转化为网络字节序
saServer.sin_addr.S_un.S_addr = htonl(INADDR_ANY); //使用INADDR_ANY 指示任意地址

//绑定
ret = bind(sListen, (struct sockaddr *)&saServer, sizeof(saServer));
if (ret == SOCKET_ERROR)
{
printf("bind() faild! code:%d\n", WSAGetLastError());
closesocket(sListen); //关闭套接字
WSACleanup();
return;
}

//侦听连接请求
ret = listen(sListen, 5);
if (ret == SOCKET_ERROR)
{
printf("listen() faild! code:%d\n", WSAGetLastError());
closesocket(sListen); //关闭套接字
return;
}

printf("Waiting for client connecting!\n");
printf("Tips: Ctrl+c to quit!\n");
//阻塞等待接受客户端连接
while(1)//循环监听客户端，永远不停止，所以，在本项目中，我们没有心跳包。
{
length = sizeof(saClient);
sServer = accept(sListen, (struct sockaddr *)&saClient, &length);
if (sServer == INVALID_SOCKET)
{
printf("accept() faild! code:%d\n", WSAGetLastError());
closesocket(sListen); //关闭套接字
WSACleanup();
return;
}
char receiveMessage[5000];
nLeft = sizeof(receiveMessage);
ptr = (char *)&receiveMessage;
while(nLeft>0)
{
//接收数据
ret = recv(sServer, ptr, 5000, 0);
if (ret == SOCKET_ERROR)
{
printf("recv() failed!\n");
return;
}
if (ret == 0) //客户端已经关闭连接
{
printf("Client has closed the connection\n");
break;
}
nLeft -= ret;
ptr += ret;
}
printf("receive message:%s\n", receiveMessage);//打印我们接收到的消息。

}
// closesocket(sListen);
// closesocket(sServer);
// WSACleanup();
}
【客户端】
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
#define SERVER_PORT 5208 //侦听端口
void main()
{
WORD wVersionRequested;
WSADATA wsaData;
int ret;
SOCKET sClient; //连接套接字
struct sockaddr_in saServer; //地址信息
char *ptr;
BOOL fSuccess = TRUE;
//WinSock初始化
wVersionRequested = MAKEWORD(2, 2); //希望使用的WinSock DLL的版本
ret = WSAStartup(wVersionRequested, &wsaData);
if(ret!=0)
{
printf("WSAStartup() failed!\n");
return;
}
//确认WinSock DLL支持版本2.2
if(LOBYTE(wsaData.wVersion)!=2 || HIBYTE(wsaData.wVersion)!=2)
{
WSACleanup();
printf("Invalid WinSock version!\n");
return;
}
//创建Socket,使用TCP协议
sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (sClient == INVALID_SOCKET)
{
WSACleanup();
printf("socket() failed!\n");
return;
}
//构建服务器地址信息
saServer.sin_family = AF_INET; //地址家族
saServer.sin_port = htons(SERVER_PORT); //注意转化为网络节序
saServer.sin_addr.S_un.S_addr = inet_addr("192.168.1.127");
//连接服务器
ret = connect(sClient, (struct sockaddr *)&saServer, sizeof(saServer));
if (ret == SOCKET_ERROR)
{
printf("connect() failed!\n");
closesocket(sClient); //关闭套接字
WSACleanup();
return;
}

char sendMessage[]="hello this is client message!";
ret = send (sClient, (char *)&sendMessage, sizeof(sendMessage), 0);
if (ret == SOCKET_ERROR)
{
printf("send() failed!\n");
}
else
printf("client info has been sent!");
closesocket(sClient); //关闭套接字
WSACleanup();
}

Ⅶ 浮点型数据的相互转换

标准4字节浮点型在计算机里存储方式如下图

IEEE754标准中浮点数表示格式IEEE规定的浮点数表示法是一种科学计数法，用符号（正或负）、指数和尾数来表示，底数被确定为2。也就是说浮点数被表示为尾数乘以2的指数次方再带上符号。具体格式如下： 符号域 指数域 小数域 指数偏移量 单精度浮点数 1 位[31] 8位[30-23] 23位[22-00] 127 双精度浮点数 1 位[63] 11 位[62-52] 52 位[51-00] 1023 下面以单精度浮点数为例来介绍浮点数的三个区域：
符号域：符号域占1位，0表示正数，1表示负数。指数域：指数域共有8位，可表达的范围为：0~255。为能处理负指数，实际指数位存储在指数域中值减去一个偏移量(单精度为127,双精度为1023)。单精度浮点数的偏移量为127，故实际可表达的指数值的范围为-127~128。尾数域：尾数域共有23位。由于规范浮点数的小数点左侧必须为1，所以在保存尾数时，可以省略小数点前面这个1，从而腾出一个二进制位来保存更多的尾数。举例：比如对于单精度数而言，二进制的1001.101（对应于十进制的9.625）可以表达为1.001101 ×2^3，所以实际保存在尾数域中的
值为0011 0100 0000 0000 0000 000，即去掉小数点左侧的1，并用0 在右侧补齐。
(
整数部分(9)的计算:1001
小数部分(0.625)的计算:
0.625*2=1.25--------1
0.25 *2=0.5 ----------0
0.5 *2=1.0 -----------1
所以用二进制科学表示方式为:1.001101*2^3
)
实数与浮点数之间的变换举例例一：已知一个单精度浮点数用16进制数表示为：0xC0B40000，求此浮点数所表达的实数。
先转换为二进制形式(注意:对于负数二进制补码转换成十进制一定要:先取反,后加1)
C 0 B 4 0 0 0 0
1100 0000 1011 0100 0000 0000 0000 0000
按照浮点数格式切割成相应的域 1 1000 0001 01101 000000000000000000
经分析：符号域1 意味着负数；指数域为129 意味着实际的指数为2 （减去偏差值127）；尾数域为01101 意味着实际的二进制尾数为1.01101 （加上隐含的小数点前面的1）。所以，实际的实数为：
= -1.01101 × 2^ 2=- ( 1*2^0 + 1*2^(-2) + 1*2^(-3) + 1*2^(-5) ) × 2^2
= -(1+0.25+0.125+0.03125)*4
= -1.40625*4
= -5.625
例二：将实数-9.625变换为相应的浮点数格式。
1) 求出该实数对应的二进制：1001.101，用科学技术法表达为：-1.001101 ×2^3；
2) 因为负数，符号为1；
3) 指数为3，故指数域的值为3 + 127 = 130，即二进制的10000010；
4) 尾数为1.001101，省略小数点左边的1后为001101，右侧0补齐，补够23位，
最终尾数域为：00110100000000000000000；
5) 最终结果：1 10000010 00110100000000000000000，用16进制表示：0xC11A0000。

Ⅷ 32位浮点型高字节在前如何变成低字节在前 怎么换算， 举个例子说明

#include<cstdio>
unsigned int swapEndian(unsigned int a){
unsigned char t,*p=(unsigned char *)&a;
t=p[0];
p[0]=p[3];
p[3]=t;
t=p[1];
p[1]=p[2];
p[2]=t;
return a;
}

int main()
{
unsigned int a=0x12345678;
printf("%x => %x",a,swapEndian(a));
return 0;
}
=======
12345678 => 78563412

x86下用汇编最快,
32位，64位寄存器有效
uint32_t changeEndian(uint32_t i){
asm ("bswapl %0;"
: "=r" (i)
: "r" (i)
);
return i;
}

===========
漏看题意，浮点型，数据转换总其实也没有必要强调类型。代码基本一样
32位单精度浮点转换代码
#include<cstdio>
float swapFloatEndian(float a){
unsigned char t,*p=(unsigned char *)&a;
t=p[0];
p[0]=p[3];
p[3]=t;
t=p[1];
p[1]=p[2];
p[2]=t;
return a;
}

int main()
{
unsigned int a=0x12345678;
unsigned int *pi;
float *pf=(float *)&a;
float b=swapFloatEndian(*pf);
pi=(unsigned int *)&b;
printf("%x => %x",a,*pi);
return 0;
}

Ⅸ 请问熟悉浮点计算的朋友们，如何把一个数字变成4字节浮点数

参见IEEE 754编码标准
http://en.wikipedia.org/wiki/Single_precision_floating-point_format

0.84这个来说
0.84×2 = 1.68 那么二进制小数部分第一位为1
0.68×2 = 1.36 那么二进制小数部分第二位为1
0.36×2 = 0.72 那么二进制小数部分第三位为0
.。。。。
一直继续下去直到得到23位 二进制小数（0.1 10101110000101000111101）
正数的符号位为0，
小数点右移一位，得到1 .10101110000101000111101 那么 exponent位-1 （-1+127=126 biased form）126二进制为01111110
所以0-01111110-10101110000101000111101=3F570A3DH

再看100.0整数部分100=64H=01100100
小数部分为0，
小数点左移6位1.100100， exponent 6+127=133=85H=10000101
0-10000101-10010000000000000000000=42C80000H

Ⅹ 网络传输时，float类型要不要转字节序

小端法(Little-Endian)就是低位字节排放在内存的低地址端(即该值的起始地址),高位字节排放在内存的高地址端;
大端法(Big-Endian)就是高位字节排放在内存的低地址端(即该值的起始地址),低位字节排放在内存的高地址端;
网络字节序是大端字节序，平常的PC机器上是小端字节序
需要转换下，可以用htons()函数做转换 将主机字节序转换为网络上用的字节序
int 和 long 都可以用htons()函数做转换
float型的一般来说，编译器是按照IEEE标准解释的，即把float/double看作4/8个字符的数组进行解释。因此，只要编译器是支持IEEE浮点标准的，就不需要考虑字节顺序。
如果你实在不放心，可以采取下面两种办法：
（1）在保证不超过int范围的情况下，将浮点数乘以100（或1000，10000，视所需精度随你定）转换为整数传输，在接收端再除以100，得到浮点数。
（2）将浮点数转换为字符串传输，由于字符串是一个字节一个字节的流，就不会有字节顺序的问题了。