精华内容
下载资源
问答
  • 最近在项目开发过程中,需要在采用JAVA作为语言的服务器与采用C++作为语言的服务器间进行通信,这就涉及到这两种语言间数据类型的转换以及网络字节序与主机字节序的区别。该文主要说说网络字节序和主机字节序的区别...

    最近在项目开发过程中,需要在采用JAVA作为语言的服务器与采用C++作为语言的服务器间进行通信,这就涉及到这两种语言间数据类型的转换以及网络字节序与主机字节序的区别。该文主要说说网络字节序和主机字节序的区别以及Little endian与Big endian的概念。其实编程的事就比较简单了

    我也懒得写了,直接引用了我觉得写的挺好的两篇文章:

    来源:http://blog.ednchina.com/qinyonglyz/194674/message.aspx

    1.故事的起源

    “endian”这个词出自《格列佛游记》。小人国的内战就源于吃鸡蛋时是究竟从大头(Big-Endian)敲开还是从小头(Little-Endian)敲开,由此曾发生过六次叛乱,其中一个皇帝送了命,另一个丢了王位。

    我们一般将endian翻译成“字节序”,将big endian和little endian称作“大尾”和“小尾”。

    2.什么是Big Endian和Little Endian?

    在设计计算机系统的时候,有两种处理内存中数据的方法。一种叫为little-endian,存放在内存中最低位的数值是来自数据的最右边部分(也就是数据的最低位部分)。比如一个16进制数字0x12345678,在内存存放的方式如下:

    0111,1000

    0101,0110

    0011,0100

    0001,0010

    地址

    100

    101

    102

    103

    另一种称为big-endian,正好相反,存放在内存中最低位的数值是来自数据的最左边边部分(也就是数据的最高为部分)。比如一个16进制数字0x12345678,在内存存放的方式如下:

    0001,0010

    0011,0100

    0101,0110

    0111,1000

    地址

    100

    101

    102

    103

    比如某些文件需要在不同平台处理,或者通过Socket通信。这方面我们可以借助ntohl(), ntohs(), htonl(), and htons()函数进行格式转换。

    3.如何判断系统是Big Endian还是Little Endian?

    在/usr/include/中(包括子目录)查找字符串BYTE_ORDER(或_BYTE_ORDER, __BYTE_ORDER),确定其值。这个值一般在endian.h或machine/endian.h文件中可以找到,有时在feature.h中,不同的操作系统可能有所不同。一般来说,Little Endian系统BYTE_ORDER(或_BYTE_ORDER,__BYTE_ORDER)为1234,Big Endian系统为4321。大部分用户的操作系统(如windows, FreeBsd,Linux)是Little Endian的。少部分,如MAC OS ,是Big Endian 的。本质上说,Little Endian还是Big Endian与操作系统和芯片类型都有关系。

    ======================================================================

    ext3 文件系统在硬盘分区上的数据是按照 Intel 的 Little-endian 格式存放的,如果是在 PC 以外的平台上开发 ext3 相关的程序,要特别注意这一点。

    谈到字节序的问题,必然牵涉到两大 CPU派系。那就是Motorola的PowerPC系列CPU和Intel的x86系列CPU。PowerPC系列采用big endian方式存储数据,而x86系列则采用little endian方式存储数据。那么究竟什么是big endian,什么又是little endian呢?

    其实big endian是指低地址存放最高有效字节(MSB),而little endian则是低地址存放最低有效字节(LSB)。

    用文字说明可能比较抽象,下面用图像加以说明。比如数字0x12345678在两种不同字节序CPU中的存储顺序如下所示:Big Endian

    低地址                                            高地址

    ----------------------------------------->

    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

    |     12     |      34    |     56      |     78    |

    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+Little Endian   低地址                                            高地址

    ----------------------------------------->

    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

    |     78     |      56    |     34      |     12    |

    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

    从上面两图可以看出,采用big endian方式存储数据是符合我们人类的思维习惯的。而little endian,!@#$%^&*,见鬼去吧 -_-|||

    为什么要注意字节序的问题呢?你可能这么问。当然,如果你写的程序只在单机环境下面运行,并且不和别人的程序打交道,那么你完全可以忽略字节序的存在。但是,如果你的程序要跟别人的程序产生交互呢?在这里我想说说两种语言。C/C++语言编写的程序里数据存储顺序是跟编译平台所在的CPU相关的,而 JAVA编写的程序则唯一采用big endian方式来存储数据。试想,如果你用C/C++语言在x86平台下编写的程序跟别人的JAVA程序互通时会产生什么结果?就拿上面的 0x12345678来说,你的程序传递给别人的一个数据,将指向0x12345678的指针传给了JAVA程序,由于JAVA采取big endian方式存储数据,很自然的它会将你的数据翻译为0x78563412。什么?竟然变成另外一个数字了?是的,就是这种后果。因此,在你的C程序传给JAVA程序之前有必要进行字节序的转换工作。

    无独有偶,所有网络协议也都是采用big endian的方式来传输数据的。所以有时我们也会把big endian方式称之为网络字节序。当两台采用不同字节序的主机通信时,在发送数据之前都必须经过字节序的转换成为网络字节序后再进行传输。

    来源:http://www.cnblogs.com/jacktu/archive/2008/11/24/1339789.html

    不同的CPU有不同的字节序类型 这些字节序是指整数在内存中保存的顺序 这个叫做主机序

    最常见的有两种

    1. Little endian:将低序字节存储在起始地址

    2. Big endian:将高序字节存储在起始地址

    LE little-endian

    最符合人的思维的字节序

    地址低位存储值的低位

    地址高位存储值的高位

    怎么讲是最符合人的思维的字节序,是因为从人的第一观感来说

    低位值小,就应该放在内存地址小的地方,也即内存地址低位

    反之,高位值就应该放在内存地址大的地方,也即内存地址高位

    BE big-endian

    最直观的字节序

    地址低位存储值的高位

    地址高位存储值的低位

    为什么说直观,不要考虑对应关系

    只需要把内存地址从左到右按照由低到高的顺序写出

    把值按照通常的高位到低位的顺序写出

    两者对照,一个字节一个字节的填充进去

    例子:在内存中双字0x01020304(DWORD)的存储方式

    内存地址

    4000 4001 4002 4003

    LE 04 03 02 01

    BE 01 02 03 04

    例子:如果我们将0x1234abcd写入到以0x0000开始的内存中,则结果为

    big-endian  little-endian

    0x0000  0x12      0xcd

    0x0001  0x23      0xab

    0x0002  0xab      0x34

    0x0003  0xcd      0x12

    x86系列CPU都是little-endian的字节序.

    网络字节顺序是TCP/IP中规定好的一种数据表示格式,它与具体的CPU类型、操作系统等无关,从而可以保证数据在不同主机之间传输时能够被正确解释。网络字节顺序采用big endian排序方式。

    为了进行转换 bsd socket提供了转换的函数 有下面四个

    htons 把unsigned short类型从主机序转换到网络序

    htonl 把unsigned long类型从主机序转换到网络序

    ntohs 把unsigned short类型从网络序转换到主机序

    ntohl 把unsigned long类型从网络序转换到主机序

    在使用little endian的系统中 这些函数会把字节序进行转换

    在使用big endian类型的系统中 这些函数会定义成空宏

    同样 在网络程序开发时 或是跨平台开发时 也应该注意保证只用一种字节序 不然两方的解释不一样就会产生bug.

    注:

    1、网络与主机字节转换函数:htons ntohs htonl ntohl (s 就是short l是long h是host n是network)

    2、不同的CPU上运行不同的操作系统,字节序也是不同的,参见下表。

    处理器    操作系统    字节排序

    Alpha    全部    Little endian

    HP-PA    NT    Little endian

    HP-PA    UNIX    Big endian

    Intelx86    全部    Little endian

    Motorola680x()    全部    Big endian

    MIPS    NT    Little endian

    MIPS    UNIX    Big endian

    PowerPC    NT    Little endian

    PowerPC    非NT    Big endian  

    RS/6000    UNIX    Big endian

    SPARC    UNIX    Big endian

    IXP1200 ARM核心    全部    Little endian

    =============================================

    字节序转换类:

    /**

    * 通信格式转换

    *

    * Java和一些windows编程语言如c、c++、delphi所写的网络程序进行通讯时,需要进行相应的转换

    * 高、低字节之间的转换

    * windows的字节序为低字节开头

    * linux,unix的字节序为高字节开头

    * java则无论平台变化,都是高字节开头

    */

    public class FormatTransfer {

    /**

    * 将int转为低字节在前,高字节在后的byte数组

    * @param n int

    * @return byte[]

    */

    public static byte[] toLH(int n) {

    byte[] b = new byte[4];

    b[0] = (byte) (n & 0xff);

    b[1] = (byte) (n >> 8 & 0xff);

    b[2] = (byte) (n >> 16 & 0xff);

    b[3] = (byte) (n >> 24 & 0xff);

    return b;

    }

    /**

    * 将int转为高字节在前,低字节在后的byte数组

    * @param n int

    * @return byte[]

    */

    public static byte[] toHH(int n) {

    byte[] b = new byte[4];

    b[3] = (byte) (n & 0xff);

    b[2] = (byte) (n >> 8 & 0xff);

    b[1] = (byte) (n >> 16 & 0xff);

    b[0] = (byte) (n >> 24 & 0xff);

    return b;

    }

    /**

    * 将short转为低字节在前,高字节在后的byte数组

    * @param n short

    * @return byte[]

    */

    public static byte[] toLH(short n) {

    byte[] b = new byte[2];

    b[0] = (byte) (n & 0xff);

    b[1] = (byte) (n >> 8 & 0xff);

    return b;

    }

    /**

    * 将short转为高字节在前,低字节在后的byte数组

    * @param n short

    * @return byte[]

    */

    public static byte[] toHH(short n) {

    byte[] b = new byte[2];

    b[1] = (byte) (n & 0xff);

    b[0] = (byte) (n >> 8 & 0xff);

    return b;

    }

    /**

    * 将将int转为高字节在前,低字节在后的byte数组

    public static byte[] toHH(int number) {

    int temp = number;

    byte[] b = new byte[4];

    for (int i = b.length - 1; i > -1; i--) {

    b = new Integer(temp & 0xff).byteValue();

    temp = temp >> 8;

    }

    return b;

    }

    public static byte[] IntToByteArray(int i) {

    byte[] abyte0 = new byte[4];

    abyte0[3] = (byte) (0xff & i);

    abyte0[2] = (byte) ((0xff00 & i) >> 8);

    abyte0[1] = (byte) ((0xff0000 & i) >> 16);

    abyte0[0] = (byte) ((0xff000000 & i) >> 24);

    return abyte0;

    }

    */

    /**

    * 将float转为低字节在前,高字节在后的byte数组

    */

    public static byte[] toLH(float f) {

    return toLH(Float.floatToRawIntBits(f));

    }

    /**

    * 将float转为高字节在前,低字节在后的byte数组

    */

    public static byte[] toHH(float f) {

    return toHH(Float.floatToRawIntBits(f));

    }

    /**

    * 将String转为byte数组

    */

    public static byte[] stringToBytes(String s, int length) {

    while (s.getBytes().length < length) {

    s += " ";

    }

    return s.getBytes();

    }

    /**

    * 将字节数组转换为String

    * @param b byte[]

    * @return String

    */

    public static String bytesToString(byte[] b) {

    StringBuffer result = new StringBuffer("");

    int length = b.length;

    for (int i=0; i

    result.append((char)(b & 0xff));

    }

    return result.toString();

    }

    /**

    * 将字符串转换为byte数组

    * @param s String

    * @return byte[]

    */

    public static byte[] stringToBytes(String s) {

    return s.getBytes();

    }

    /**

    * 将高字节数组转换为int

    * @param b byte[]

    * @return int

    */

    public static int hBytesToInt(byte[] b) {

    int s = 0;

    for (int i = 0; i < 3; i++) {

    if (b >= 0) {

    s = s + b;

    } else {

    s = s + 256 + b;

    }

    s = s * 256;

    }

    if (b[3] >= 0) {

    s = s + b[3];

    } else {

    s = s + 256 + b[3];

    }

    return s;

    }

    /**

    * 将低字节数组转换为int

    * @param b byte[]

    * @return int

    */

    public static int lBytesToInt(byte[] b) {

    int s = 0;

    for (int i = 0; i < 3; i++) {

    if (b[3-i] >= 0) {

    s = s + b[3-i];

    } else {

    s = s + 256 + b[3-i];

    }

    s = s * 256;

    }

    if (b[0] >= 0) {

    s = s + b[0];

    } else {

    s = s + 256 + b[0];

    }

    return s;

    }

    /**

    * 高字节数组到short的转换

    * @param b byte[]

    * @return short

    */

    public static short hBytesToShort(byte[] b) {

    int s = 0;

    if (b[0] >= 0) {

    s = s + b[0];

    } else {

    s = s + 256 + b[0];

    }

    s = s * 256;

    if (b[1] >= 0) {

    s = s + b[1];

    } else {

    s = s + 256 + b[1];

    }

    short result = (short)s;

    return result;

    }

    /**

    * 低字节数组到short的转换

    * @param b byte[]

    * @return short

    */

    public static short lBytesToShort(byte[] b) {

    int s = 0;

    if (b[1] >= 0) {

    s = s + b[1];

    } else {

    s = s + 256 + b[1];

    }

    s = s * 256;

    if (b[0] >= 0) {

    s = s + b[0];

    } else {

    s = s + 256 + b[0];

    }

    short result = (short)s;

    return result;

    }

    /**

    * 高字节数组转换为float

    * @param b byte[]

    * @return float

    */

    public static float hBytesToFloat(byte[] b) {

    int i = 0;

    Float F = new Float(0.0);

    i = ((((b[0]&0xff)<<8 | (b[1]&0xff))<<8) | (b[2]&0xff))<<8 | (b[3]&0xff);

    return F.intBitsToFloat(i);

    }

    /**

    * 低字节数组转换为float

    * @param b byte[]

    * @return float

    */

    public static float lBytesToFloat(byte[] b) {

    int i = 0;

    Float F = new Float(0.0);

    i = ((((b[3]&0xff)<<8 | (b[2]&0xff))<<8) | (b[1]&0xff))<<8 | (b[0]&0xff);

    return F.intBitsToFloat(i);

    }

    /**

    * 将byte数组中的元素倒序排列

    */

    public static byte[] bytesReverseOrder(byte[] b) {

    int length = b.length;

    byte[] result = new byte[length];

    for(int i=0; i

    result[length-i-1] = b;

    }

    return result;

    }

    /**

    * 打印byte数组

    */

    public static void printBytes(byte[] bb) {

    int length = bb.length;

    for (int i=0; i

    System.out.print(bb + " ");

    }

    System.out.println("");

    }

    public static void logBytes(byte[] bb) {

    int length = bb.length;

    String ut = "";

    for (int i=0; i

    ut = out + bb + " ";

    }

    }

    /**

    * 将int类型的值转换为字节序颠倒过来对应的int值

    * @param i int

    * @return int

    */

    public static int reverseInt(int i) {

    int result = FormatTransfer.hBytesToInt(FormatTransfer.toLH(i));

    return result;

    }

    /**

    * 将short类型的值转换为字节序颠倒过来对应的short值

    * @param s short

    * @return short

    */

    public static short reverseShort(short s) {

    short result = FormatTransfer.hBytesToShort(FormatTransfer.toLH(s));

    return result;

    }

    /**

    * 将float类型的值转换为字节序颠倒过来对应的float值

    * @param f float

    * @return float

    */

    public static float reverseFloat(float f) {

    float result = FormatTransfer.hBytesToFloat(FormatTransfer.toLH(f));

    return result;

    }

    }

    展开全文
  • 1. 网络字节序和主机字节序 在网络编程中经常会碰到网络字节序和主机字节序。关于网络字节序和主机字节序在学习前需要理解以下几个概念。 字节序,指的是字节在内存中存储的顺序,比如一个int32_t类型的数值占用4个...

    1. 网络字节序和主机字节序

    在网络编程中经常会碰到网络字节序和主机字节序。关于网络字节序和主机字节序在学习前需要理解以下几个概念。
    字节序,指的是字节在内存中存储的顺序,比如一个int32_t类型的数值占用4个字节,这4个字节在内存中的排列顺序就是字节序。字节序有以下两种:

    1. 小端字节序(Little endian),数值低位存储在内存低地址,高位存储在内存高地址。
    2. 大端字节序(Big endian),数值高位存储在内存的低地址,低位存储在内存的高地址。

    下边是从网络上找的一个图,以32位位宽数值0x12345678为例,小端字节序与大端字节序具体的存储区别如下所示:
    在这里插入图片描述

    2. 网络字节序和主机字节序转换

    2.1 常用系统调用

    下边是C标准库提供的关于字节序间转换的操作函数:

    #include <arpa/inet.h>
    
    uint32_t htonl(uint32_t hostlong); //把uint32_t类型从主机序转换到网络序
    uint16_t htons(uint16_t hostshort); //把uint16_t类型从主机序转换到网络序
    uint32_t ntohl(uint32_t netlong); //把uint32_t类型从网络序转换到主机序
    uint16_t ntohs(uint16_t netshort); //把uint16_t类型从网络序转换到主机序
    

    2.2 64位数值的转换

    上边的几个函数有对32位和16位的数值转换,但是如果是64位的就没有现成的API可以调用了,下边提供几种实现方式,对64位类型数据进行转换

    2.2.1 使用位移

    //主机序转网络序
    unsigned long long htonll(unsigned long long val)
    {
        if(__BYTE_ORDER == __LITTLE_ENDIAN) {
            return (((unsigned long long )htonl((int)((val << 32) >> 32))) << 32) | (unsigned int)htonl((int)(val >> 32));
        }
        
        else if (__BYTE_ORDER == __BIG_ENDIAN) {
            return val;
        }
    }
    
    //网络序转主机序
    unsigned long long ntohll(unsigned long long val)
    {
        if (__BYTE_ORDER == __LITTLE_ENDIAN) {
            return (((unsigned long long )ntohl((int)((val << 32) >> 32))) << 32) | (unsigned int)ntohl((int)(val >> 32));
        }
        
        else if (__BYTE_ORDER == __BIG_ENDIAN) {
            return val;
        }
    }
    

    2.2.2 使用联合体union

    下边使用联合体的特性:联合体中所有成员引用的是内存中相同的位置,其长度为最长成员的长度。

    typedef struct {  
        unsigned int u32_h;  
        unsigned int u32_l;  
    }Int64_t;  
    
    typedef union {  
        unsigned long long u64;  
        Int64_t st64;  
    }Convert64_t;
    
    //主机序转网络序
    unsigned long long htonll(unsigned long long val)
    {  
        if (__BYTE_ORDER == __LITTLE_ENDIAN){
            Convert64_t box_in, box_out;  
    
            box_in.u64 = val;  
            box_out.st64.u32_h = htonl(box_in.st64.u32_l);  
            box_out.st64.u32_l = htonl(box_in.st64.u32_h);  
            return box_out.u64;
        }
        else if (__BYTE_ORDER == __BIG_ENDIAN)  {  
            return val;
        }
    }
    
    //网络序转主机序
    unsigned long long ntohll(unsigned long long val)
    {
        if (__BYTE_ORDER == __LITTLE_ENDIAN){
            Convert64_t box_in, box_out;  
    
            box_in.u64 = val;  
            box_out.st64.u32_h = ntohl(box_in.st64.u32_l);  
            box_out.st64.u32_l = ntohl(box_in.st64.u32_h);  
            return box_out.u64;
        }
        else if(__BYTE_ORDER == __BIG_ENDIAN){
            return val;
        }
    }
    

    2.2.3 使用编译器内置函数

    #ifdef WIN32
    #define ntohll(x) _byteswap_uint64 (x)
    #define htonll(x) _byteswap_uint64 (x)
    #else
    #if __BYTE_ORDER == __BIG_ENDIAN
    #define ntohll(x) (x)
    #define htonll(x) (x)
    #else
    #if __BYTE_ORDER == __LITTLE_ENDIAN
    #define ntohll(x) __bswap_64 (x)
    #define htonll(x) __bswap_64 (x)
    #endif
    #endif
    #endif
    
    展开全文
  • “端口号”或者“点分十进制的IP”必须先转化为“网络字节序”,才能在网络环境中传输。 TCP/IP 规定,网络数据流采用大端字节序:高地址存低位数据,计算机一般采用小端存储。如下图所示: 因此,从计算机到网络,...

    1、背景

    “端口号”或者“点分十进制的IP”必须先转化为“网络字节序”,才能在网络环境中传输。
    TCP/IP 规定,网络数据流采用大端字节序:高地址存低位数据,计算机一般采用小端存储。如下图所示:
    在这里插入图片描述
    因此,从计算机到网络,需要一个“主机字节序”到“网络字节序”的转换。

    2、转换函数

    符号说明:
    32:32 位,代表转IP ;
    16:代表转端口号 ;
    h:host 主机 ;
    to:到;
    n:net 网络 ;
    l:长整形(标识 IP) ;
    s:短整形(标识端口号)。

    (1)端口号转换:

    #include <arpa/inet.h> // 头文件
    uint16_t htons(uint16_t hostshort); // 端口号 本地字节序转网络字节序
    uint16_t ntohs(uint16_t netshort); // 端口号 网络字节序转本地字节序
    

    (2)IP地址转换

    uint32_t htonl(uint32_t hostlong); // IP 本地字节序转网络字节序
    uint32_t ntohl(uint32_t netlong); // IP 网络字节序转本地字节序
    

    但是,使用以上函数转换 IP 时候,应用起来比较麻烦,需要:先将点分十进制(字符串)转为unsigned int(本地字节序) 然后再利用上述函数转为网络字节序。
    因此,一般只这样使用:

    htonl(INADDR_ANY); // 将本地的任意有效的 IP转为网络字节序
    

    彻底解决方式:常用以下函数进行转换 IP,这样可以实现:字符串直接转换为网络字节序

    #include <arpa/inet.h> // 头文件
    int inet_pton(int af, const char *src, void *dst); // 点分十进制直接转为网络字节序,成功返回0,失败返回-1
    

    参数:
    af:指定 IP 版本 :AF_INET为IPv4 、AF_INET6为IPv6
    src:点分十进制的 IP 地址
    dst:传出参数,获得的网络字节序,

    const char *inet_ntop(int af, const void *src, char *dst, socklen_t size); // 网络字节序直接转点分十进制
    

    参数:
    src:网络字节序
    dst:传出参数,点分十进制字符串的首地址
    size:socklen_t 类型,字符串的长度

    展开全文
  • PHP与C服务器的socket通信,在做数据转换的时候,PHP没有提供对应将网络字节序和机器字节序相互转换的程序,但是根据函数的意义,...}函数的意义程序的作用是将网络字节序和机器字节序进行相互转换。在C/C++、Pytho...

    PHP与C服务器的socket通信,在做数据转换的时候,PHP没有提供对应将网络字节序和机器字节序相互转换的程序,但是根据函数的意义,我们可以做相应的转换来实现这一函数:

    function ntohl($str){$arr = unpack(‘I‘, pack(‘N‘, $str));return $arr[1];

    }

    函数的意义

    程序的作用是将网络字节序和机器字节序进行相互转换。在C/C++、Python、Delphi中都提供了相应的函数“ntohl”和“htonl”,如果是short类型就是“ntohs”和“htons”。下面是这些函数的意义:

    ntohl()--"Network to Host Long"

    htonl()--"Host to Network Long"

    htons()--"Host to Network Short"

    ntohs()--"Network to Host Short"

    什么是主机字节序

    不同的机器字节序不相同,这与使用的CPU有关。不同的CPU在处理高位字节时所存储的顺序是不同的。

    例如Intel x86结构下, short型数0x1234表示为34 12, int型数0x12345678表示为78 56 34 12

    如IBM power PC结构下, short型数0x1234表示为12 34, int型数0x12345678表示为12 34 56 78

    网络字节序

    正是由于每个主机的处理顺序有可能不同,所以在网络协议中规定数据从高到低顺序存储,目的是在不同架构的主机中可以正常通信,避免兼容性问题。

    参考:http://n3yang.com/archives/2011/12/16/php-function-ntohl/

    原文:http://www.cnblogs.com/rnckty/p/4421676.html

    展开全文
  • 函数说明相关函数:htonl, htons, ntohl头文件:#include 定义函数:unsigned short int ntohs(unsigned short int netshort);函数说明:ntohs()用来将参数指定的...在C/C++写网络程序的时候,往往会遇到字节网络...
  • 最近在项目开发过程中,需要在采用JAVA作为语言的服务器与采用C++作为语言的服务器间进行通信,这就涉及到这两种语言间数据类型的转换以及网络字节序与主机字节序的区别。该文主要说说网络字节序和主机字节序的区别...
  • 一、字节序字节序:是指整数在内存中保存的顺序。字节序有两种实现方式:小端字节序(little endian):低字节数据存放在内存低地址处,高字节数据存放在内存高地址处。大端字节序(bigendian):高字节数据存放在低...
  • 通常我们认为网络字节序为标准顺序,封包的时候,将主机字节序转换为网络字节序,拆包的时候要将网络字节序转换为主机字节序。原以为还要自己写函数,其实网络库已经提供了。主机到网络:short/int/long IPAddress....
  • 一:大小端(一)大小端区别(字节)区别是依据:计算机系统在存储数据时起始地址是高地址仍是低地址。 小端:从低地址开始存储 大端:从高地址开始存储 补充:这里大小端是按字节区别的,还有按字的。按字节,则字节...
  • 主机字节序和网络字节序 转换函数 htonl 、htons 、ntohl 和 ntohs inet_addr 、inet_aton 和 inet_ntoa inet_pton和 inet_ntop 主机字节序和网络字节序 现代 CPU 的累加器一次能装载至少 4 字节,即一个整数...
  • 网络字节序

    2021-01-28 23:06:41
    一.字节序字节序是由于不同的主...网络字节序:是指多字节变量在网络传输时的表示方法,网络字节序采用高端字节序的表示方法(高位在前,低位在后,这是针对一个变量所处的字节中来说的,比如一个变量占两个字节...
  • 1.网络字节序与主机字节序在Linux网络编程中,经常碰到网络字节序与主机字节序的相互转换。说到网络字节序与主机字节序需要清晰了解以下几个概念。字节序,顾名思义,指字节在内存中存储的顺序。比如一个int32_t类型...
  • 网络字节序的转换

    2020-08-22 15:08:01
    只有多于一个字节的数据类型,才有字节序的问题,比如short或者int类型。char是没有这个问题的。字节序就是在硬件里面,一般实在内存里,如何表示存储和表示这些数据类型。如果高字节放到高地址上,就是大端(big ...
  • 自:... 在Linux和Windows网络编程时需要用到htons和htonl函数,用来将主机字节顺序转换为网络字节顺序。 在Intel机器下,执行以下程序 int main() { printf("%...
  •  在Linux和Windows网络编程时需要用到htons和htonl函数,用来将主机字节顺序转换为网络字节顺序。  在Intel机器下,执行以下程序 int main() ...{  printf("%d /n",htons(16));  return 0; } 得到的...
  • 网络字节序 网络字节序1、网络字节序 (Network Byte Order)和本机转换2、字节序转换函数 网络字节序 1、网络字节序 (Network Byte Order)和本机转换 1、大端、小端字节序 “大端”和”小端”表示多字节值的哪一端...
  • 字节序相关概念   什么是字节序?   字节序是由于不同主处理器(CPU)和操作系统(OS)对多字节的变量在内存中存放顺序的不同而产生的。   字节序的分类?一般分为两类:   ①小端字节序(Little Endian,LE...
  • 网络字节序,是指采用大端法存储网络地址, 本地主机字节序,是指采用小端法存储本地主机地址. 大端法:低字节保存在内存...//本地字节序转网络字节序(用于IPV4地址) uint16_t htons(uint16_t hostshort);//本地字...
  • c/c++字节序转换

    千次阅读 2019-04-04 18:28:15
    字节序(byte order)关系到多字节整数(short/int16、int/int32,int64)和浮点数的各字节在内存中的存放顺序。字节序分为两种:小端字节序(little endian)和大端字节序(bigendian)。小端字节序:低字节存放在...
  • inet_addr函数将一个IP字符串转换为一个网络字节序的整数值。 四、网络字节序与主机字节序 1.主机字节序 就是我们平常说的大端和小端模式,大端就是低地址存放高字节,小端就是低地址存放低字节。不同的...
  • 网络通信要将go基本数据类型转为字节, golang如何做? 基本类型 c类型 go类型 字节长度 signed char int8 1 unsigned char uint8 1 _Bool bool 1 short int16 2 unsigned short uint16 2 int int...
  • php字节序转换的方法

    2021-03-26 15:36:11
    php主机字节序和网络字节序使用php编写socket程序时,也需要注意主机字节序和网络字节序的转换主机字节序就是我们平常说的大端和小端模式:不同的 CPU 有不同的字节序类型,这些字节序是指整数在内存中保存的顺...
  • 1-网络字节序和ip地址

    千次阅读 2018-06-12 10:30:32
      之前我们在学习内存的时候可知,内存存储数据也是有大端存储和小端存储的,对于网络数据流同样有大端小端之分,那么为什么要定义网络字节序呢?   原因是让不同cpu架构的计算机进行网络通信时,字节序不会...
  • 主机网络序转换函数02. 网络序到主机转换函数03. inet_pton函数04. inet_ntop函数05. 附录 01. 主机网络序转换函数 相关函数 #include <arpa/inet.h> uint32_t htonl(uint32_t hostlong); uint16_t...
  • 主机字节序和网络字节序

    千次阅读 2019-01-06 19:11:13
    什么是字节序——字节序是一个处理器架构特性,用于指示像整数这样的大数据类型内部的字节如何排序。 考虑一个16位整数,它由2个字节组成。内存中存储这两个字节有2种方法:一种是将低序字节存储在起始地址,这称为...
  • 主机字节序不同的CPU有不同的字节序类型 这些字节序是指整数在内存中保存的顺序 这个叫做主机序最常见的有两种1. Little endian:将低序字节存储在起始地址2. Big endian:将高序字节存储在起始地址LE little-...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,853
精华内容 5,941
关键字:

short类型转网络字节序

友情链接: PCB-Logo-Creato.rar