ntoh16 与 hton16

最新推荐文章于 2022-03-13 09:20:46 发布
原创 最新推荐文章于 2022-03-13 09:20:46 发布 · 890 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#C #C++ #C#

本文介绍了将主机字节序转换为网络字节序的函数 hton16 和 hton32，以及相反操作的函数 ntoh16 和 ntoh32。这些函数对于实现网络通信中的数据格式统一至关重要。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

/*
    * Functions hton16 and hton32 convert the host
    * representation of integer numbers into the network
    * representation as defined in "Trivial Internet Protocol",
    * section 2.1.
    * ntoh32 and ntoh16 are reverse functions to hton32 and hton16.
    *
    * Adjust the following definitions for the particular
    * hardware and C complier.
    */
   #define hton16(n) (((uint16)(n) >> 8) | ((uint16)(n) << 8))
   #define hton32(n) (ntoh16((uint32)(n) >> 16) | (ntoh16(n) << 16))
   #define ntoh16(n) hton16(n)
   #define ntoh32(n) hton32(n)

ntoh hton __builtin_constant_p ___constant_swab __fswab简介
08-20 1410
研究IPV4的过程中发现了
关于网络传输字节顺序的问题: hton? or ntoh?-
Newweapon's Trace
12-07 2744
note: from baidu search小知识：字节顺序 很少有人关心字节顺序（Byte Ordering），因为它真的很少用到。何为字节顺序呢？让我们先来看一个例子，假设现在有一个WORD类型的变量，它的值为0x7788，那么它在内存中是怎么存放的呢？内存中： 低地址 高地址0x770x88高地址 低地址0x770x88图3.7 两种字节顺序 事实上，对于不同的CPU、不同的操作系统，图3
ntoh实现
03-22 401
typedef unsigned short int uint16; typedef unsigned long int uint32; // 短整型大小端互换 #define BigLittleSwap16(A) ((((uint16)(A) & 0xff00) >> 8) | \ (((uint16)(A) & 0x00ff) // 长整型大小端互换 #d
linux笔记-perror()、ntoh、hton
qq_43413381的博客
05-12 1536
perror()、ntoh、hton函数 perror() 函数定义： void perror(const char *s); perror (“open_port”); 头文件：#include<stdio.h>; 函数说明 用 来 将 上 一 个 函 数 发 生 错 误 的 原 因 输 出 到 标 准 设备 (stderr) 。参数 s 所指的字符串会先打印出,后面再加上错误原因字...
知道为什么需要htons(), ntohl(), ntohs()，htons() 函数吗?
期待下集是个可爱梦儿
03-04 896
<br />在C/C++写网络程序的时候，往往会遇到字节的网络顺序和主机顺序的问题。这是就可能用到htons(), ntohl(), ntohs()，htons()这4个函数。 <br />网络字节顺序与本地字节顺序之间的转换函数：      htonl()--"Host to Network Long"<br />      ntohl()--"Network to Host Long"<br />      htons()--"Host to Network Short"<br />      ntoh
数字字节序之判断大小头
nodeathphoenix的专栏
09-02 4465
一个字节8位刚好存储两个十六进的数字。网络字节序即为大头字节序。 判断当前平台是大头还是小头： #define BIGENDIAN (htons(1) == 1) 当htons(1) == 1成立时，BIGENDIAN的值就是1，否则为0. 后续代码就可以通过 if (BIGENDIAN) { ……}的形式来判断大小头。 各操作系统都会实现这个函数： unit16_t htons
TS_MOD_PRIV_DEFN FUNC(uint16, TCPIP_CODE) TcpIp_CalcSum16Bit ( P2CONST(uint8, AUTOMATIC, TCPIP_APPL_DATA) dataPtr, uint16 initValue, uint16 length ) { #if (defined HAS_64BIT_TYPES) /* 64 bit architecture / types / memory bus */ typedef uint64 A_Type; typedef uint32 A2_Type; /* half an accumulator */ uint64 TcpIp_accu= 0u; /* 48 bit accumulator, so we retain the overflow of the 32bit adds - high part is only carry bits so < 16bits */ #else /* 32 bit architecture / types / memory bus */ typedef uint32 A_Type; typedef uint16 A2_Type; /* half an accumulator */ /* local alias to w32, using the TcpIp namespace to trigger define guard,... */ /* TCPIP_ACCU/TcpIp_accu defined as w32. w32 is already used for the peeling iterations and initialized with initValue */ #endif /* (defined HAS_64BIT_TYPES) */ const uint16 maxAlignment= sizeof(A_Type); const uint8 halfBits= sizeof(A2_Type)*8u; /* do we need to swap result bytes for LE ^ odd start address? */ /* Deviation MISRAC2012-8 */ uint8 shift= (((uint8)1u) & (uint8)(TS_IF_BE_LE((uint8),(uint8) ~(uint8)) ((uint32)(&dataPtr[0u])))) << 3u; /* 32 bit accumulator for 16-bit values - 64kB -> 32k carries max, so it can't overflow */ uint32 w32= ((uint32)initValue) << shift; /* put the initValue in the right place for its alignment! */ uint16_least index= 0u; /* MISRA -> must rely on compiler to do strength reduction */ /* peel till it's aligned */ if (!TCPIP_ISALIGNED(&dataPtr[index],maxAlignment) && (length > 0u)) { /* Deviation MISRAC2012-8 */ uint16 len1= maxAlignment - (((uint16)(usize)&dataPtr[index]) & (maxAlignment-1u)); /* len1 > 0 */ uint16 fatbool= TS_FATBOOL(uint16, length < len1); uint16 len2= TS_SELECT(uint16, fatbool, length,len1); /* now peel len2 iterations - len2 > 0 since length & len2 were both > 0 */ length-= len2; do { /* shift by 8 or 0 bits depending on alignment vs LE/BE */ w32 += TCPIP_SHIFTCHECKSUMBYTE(dataPtr[index]); ++index; --len2; } while (len2 > 0); } /* if (length!=0u) -- skip remaining loops! */ /* only aligned starts or length==0 comes here (but length=0 should've been jumping to the end of the loop (jump2jump opt) */ /* if 64bit is possible: read uint64, sum 32bit halves - LE/BE is don't care (associativity) & cyclical carry */ /* otherwise: read uint32, sum 16bit halves - LE/BE is don't care (associativity) & cyclical carry */ if (length >= maxAlignment) /* use the guarding-if from the compiler's loop-rotation to speed up short cases */ { do { /* Deviation MISRAC2012-9 */ const A_Type read= *((P2CONST(A_Type, AUTOMATIC, TCPIP_APPL_DATA))(&dataPtr[index])); TCPIP_ACCU += ((A_Type)((A2_Type)(read >> halfBits))) + ((A2_Type)read); index += maxAlignment; length -= maxAlignment; } while(length >= maxAlignment); #if (defined HAS_64BIT_TYPES) /* if we used a 64bit accu, fold the 2 16bit SIMD accumulators + 16bit carry parts into 32bit */ { /* mixed strategy for 32bit architectures with costly 64 bit ops: reduce to 32bit registers and avoid all 32bit overflows */ uint32 hi32= (uint32)(TCPIP_ACCU >> 32u); /* usually just takes the hi register (half) */ uint32 lo32= (uint32) TCPIP_ACCU; /* usually just takes the lo register (half) */ /* the rest of the computation is in 32 bit registers, without 32bit overflows: w32 is 24 bits max (initValue16 << 8) hi32 only contains the carry bits of 16k uint32 adds, so < 14 bits, so the high 18 bits are zero -> no narrowing Only the 2 lo values are full 16 bits and may produce a carry into the high part which holds the upper byte of initValue at most */ w32+= hi32 + (lo32 >> 16u) + ((uint16)lo32); } #endif /* (defined HAS_64BIT_TYPES) */ } /* now peel till we're done */ if (length > 0u) { do { /* shift by 8 or 0 bits depending on alignment vs LE/BE */ w32 += TCPIP_SHIFTCHECKSUMBYTE(dataPtr[index]); ++index; --length; } while(length > 0u); } { uint16 w16; w32= (w32 >> 16u) + ((uint16)w32); w16= ((uint16)(w32 >> 16u)) + ((uint16)w32); /* now swap the bytes for LE (HTON/NTOH), leave them for BE (& the other way round, if the address was odd) */ if (shift != 0u) { w16= COMSTACK_BYTE_MIRROR16(w16); /* __ROR(w16, shift), if there was a portable primitive */ } return w16; } }
最新发布
07-31
3. **折叠进位**：将累加结果的高16位（进位）与低16位相加，重复此过程直到高16位为0。 4. **取反**：对结果取反（按位取反）得到最终校验和。 ### TcpIp_CalcSum16Bit函数实现分析 下面是一个典型的实现，同时...
int16的数据只发12bit
06-12
我们有一个int16类型的数据（16位），但只需要发送其中的12位。通常，我们会忽略高4位（或低4位，根据需求），然后将剩余的12位数据打包发送。由于问题中要求“不可转换成一个字节”（一个字节为8位），但12位需要...
大小端转换htonl、ntohl、htons、ntohs
Gordennizaicunzai的博客
12-28 4951
htonl The htonl function converts a u_long from host to TCP/IP network byte order (which is big-endian). u_long htonl( u_long hostlong ); Parameters hostlong [in] 32-bit number in host byt
程序员视角：TCP流套接字的地址结构与功能解析
如大端模式（big_endian）和小端模式（little_endian），这就涉及到数据在网络间传输时的字节排序问题，这时会用到诸如hton、ntoh这样的转换函数，特别在处理sin_port这样的16位值时。 在处理IP地址时，现代编程...
Linux网络学习与总结（1）
weixin_37651557的博客
03-13 450
网络通信编程 物理地址是标识适配器（网卡）的ID，六个字节，48位，全球唯一不会改变。作用是收发数据。 IP地址是用来表示一台主机的逻辑地址。 IPV4：4个字节，32位，用在局域网 IPV6：16字节，128位，用在广域网 IP将其分为子网ID和主机ID 子网ID：IP中被子网掩码中1连续覆盖的位 主机ID：IP中被子网掩码中0连续覆盖的位 比如： IP：192.168.1.2/24（24代表连续24个1，即255.255.255.0） 子网id：192.168.1 主机id：2 网段地址：192.16
C/C++ 实现htonf和ntof的两种方法
音频算法研究与学习
08-30 3669
数字在计算机中两种储存数据的方式：1． Little endian：将低序字节存储在起始地址；2． Big endian：将高序字节存储在起始地址。一般来说主机序是小端的，网络序是大端的。htonl、htons和ntohl、ntohs是常见的函数，htonl、htons用于32位何16位数据小端字节序到大端字节序的转换，ntohl、ntohs用于32位何16位数据大端字节序到小端字节序的转换。
android 大小端转换器,大小端转换的C++ 封装 ：hton ， ntol
weixin_39996101的博客
05-26 403
使用C++的模板、自动类型推导技术#ifndef HtoN_h#define HtoN_h#include #if __ANDROID__#ifndef htonll#define htonll(x) htonq(x)#endif#ifndef ntohll#define ntohll(x) ntohq(x)#endif#endifnamespace zxszl{template T zl_h...
ntohs函数的意思
热门推荐
qq_38171115的博客
04-18 1万+
ntohs()是一个函数名，作用是将一个16位数由网络字节顺序转换为主机字节顺序 将一个无符号短整型数从网络字节顺序转换为主机字节顺序。 #include uint16_t ntohs(uint16_t netshort); netshort：一个以网络字节顺序表达的16位数。 本函数将一个16位数从主机字节顺序转换成网络字节顺序。 返回值： htons()返回一个网络字节顺序的值
ntohs, ntohl, htons,htonl的比较和详解
wowfly98的博客
06-21 797
ntohs, ntohl, htons,htonl的比较和详解 2012-02-22  LibraryOf...   阅 19020  转 77 转藏到我的图书馆 微信分享： 在C/C++写网络程序的时候，往往会遇到字节的网络顺序和主机顺序的问题。 这时就可能用到htons(), ntohl(), ntohs()，htons()这4个网络字节顺
c# 主机和网络字节序的转换
weixin_34301132的博客
11-23 377
最近使用C#进行网络开发，需要处理ISO8583报文，由于其中有些域是数值型的，于是在传输的时候涉及到了字节序的转换。 字节顺序是指占内存多于一个字节类型的数据在内存中的存放顺序，通常有两种字节顺序，根据他们所处的位置我们分别称为主机节序和网络字节序。通常我们认为网络字节序为标准顺序，封包的时候，将主机字节序转换为网络字节序，拆包的时候要将网络字节序转换为主机字节序。 原以为还要自己写函数，其...
64位整数 网络序 主机序 转换函数的实现
linuxheik的专栏
09-18 2685
64位整数 网络序 主机序 转换函数的实现 static bool IsBigEndian()   {       const int n = 1;       if(*(char *)&n)       {           return false;       }       return true;   }  #define swap64(val) (
ntohs和htons区别？
hanchaoman的专栏
09-26 6112
一直以来都对这个两个函数含含糊糊的，今天又用到所以特意查看linux的源代码(/include/netinet/in.h) # if __BYTE_ORDER == __BIG_ENDIAN /* The host byte order is the same as network byte order,    so these functions are all just identity
htonl、ntohl、htons、ntohs函数
andrewbytecoder
08-13 1938
htonl函数，将一个32位整数，由主机字节序转换为网络字节序。 htons函数，将一个16位整数，由主机字节序转化为网络字节序 ntohl函数，将一个32位整数，由网络字节序转换为主机字节序。 ntohs函数，将一个16位整数，由网络字节序转化为主机字节序 htonl()--"Host to Network Long" ntohl()--"Network ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值