特点

①各主机的字节序可能不同，网络协议指定的通讯字节序为大端。
②只有在多字节数据处理时才需要考虑字节序。
③运行在同一台计算机的进程互相通信时，不需要考虑字节序。

二、字节序转换函数

头文件：#include <arpa/inet.h>
①htonl函数（发送数据方使用）

32位：（IPv4字节序的转换）

uint32_t htonl(uint32_t host32bitvalue); 

功能：将32位主机字节序数据转换成网络字节序数据。
返回值：返回网络字节序的值。

②ntohl函数（接收数据方使用）

uint32_t ntohl(uint32_t net32bitvalue);     //返回主机字节序的值

功能：将32位网络字节序转换成主机字节序数据。
返回值：返回主机字节序的值。

16位（端口的转换）

③htons函数（发送方使用）

uint16_t htons(uint16_t host16bitvalue);    //返回网络字节序的值

功能：将16位主机字节序数据转换成网络字节序数据。

返回值：返回网络字节序的值。
④ntohs函数（接收方使用）

uint16_t ntohs(uint16_t net16bitvalue);     //返回主机字节序的值

功能：将16位网络字节序转换成主机字节序数据。
返回值：返回主机字节序的值。

总结：四个函数，如果主机和网络字节序相同，那么函数不会颠倒数据

二、新型网路地址转化函数

这两个函数是随IPv6出现的函数，对于IPv4地址和IPv6地址都适用，函数中p和n分别代表表达（presentation)和数值（numeric)。地址的表达格式通常是ASCII字符串，数值格式则是存放到套接字地址结构的二进制值。

① 将点分十进制的ip地址转化为用于网络传输的数值格式

int inet_pton(int family, const char *strptr, void *addrptr);    

参数：family 协议族
     strptr 点分十进制数串
     addrptr 32位无符号整数的地址

返回值：若成功则为1，若输入不是有效的表达式则为0，若出错则为-1

eg:

#include <stdio.h>
#include <arpa/inet.h>

int main()
{
	//点分十进制数串
	char *str_ip="172.20.10.1";
	//32位无字符串整型数据
	unsigned int num_ip=0;
	//AF_INET:IPv4  AF_INET6:IPv6
	inet_pton(AF_INET,str_ip,&num_ip);
	
	printf("转换前:str_ip=%s\n",str_ip);
	printf("转换后:num_ip=%u\n",num_ip);
	
	return 0;	
}

②将数值格式转化为点分十进制的ip地址格式

const char * inet_ntop(int family, const void *addrptr, char *strptr, size_t len);     

返回值：若成功则为指向结构的指针，若出错则为NULL

eg:

#include <stdio.h>
#include <arpa/inet.h>

int main()
{
	//模拟一个32位网络字节序IP地址
	unsigned char p[]={192.168.0.1};
	
	char ip_str[16]="";
	inet_ntop(AF_INET,p,ip_str,16);
	printf("ip_str:%s\n",ip_str);
	
	return 0;	
}

1.字节序转换接口：

//man  hton 可查看
#include <arpa/inet.h>
h：host    n: net

uint32_t htonl(uint32_t hostlong);	32位（4字节）主机字节序到网络字节序的转换。
uint16_t htons(uint16_t hostshort);	16位主机字节序到网络字节序的转换   
uint32_t ntohl(uint32_t netlong); 	32网络字节序到位主机字节序转换
uint16_t ntohs(uint16_t netshort);	16位网络字节序到位主机字节序转换    

//上面这些接口里面能判断主机字节序，若与要转换的相同则不操作返回。

2.字符串点分十进制IP地址转换为网络字节序整数IP地址接口：

eg:192.168.2.2-转为十进制数字地址0xcoa80202

#include <sys/socket.h>  //socket接口头文件
#include <netinet/in.h>  //地址结构，协议类型头文件
#include <arpa/inet.h>   //字节序转换接口头文件

in_addr_t inet_addr(const char *cp);只能转换IPV4的ip地址
eg: addr.sin_addr.s_addr = inet_addr("172.17.0.3");

//int inet_pton(int af, const char *src, void *dst); IPV4，ipv6都能转换。

3.将网络IP地址转换为字符串点分十进制IP地址：

char *inet_ntoa(struct in_addr in); 只能转换IPV4的ip地址
//const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);IPV4，ipv6都能转换。
IPV4，ipv6都能转换。

Eg:

 bool Accept(TcpSocket *sock, 
                std::string *ip = NULL,uint16_t *port = NULL){
            //int accept(监听描述符，获取客户端地址，长度)
            struct sockaddr_in addr;
            socklen_t len = sizeof(struct sockaddr_in);
            int newfd = accept(_sockfd,(sockaddr*)&addr,&len);
            if (newfd < 0) {
                perror("accept error");
                return false;
            }
            sock->_sockfd = newfd;
            if (ip != NULL) {
                *ip = inet_ntoa(addr.sin_addr);
            }
            if (port != NULL) {
                *port = ntohs(addr.sin_port);
            }
            return true;
        }

常用命令

netstat -anptu 可查看当前主机上网络状态信息

 命令： netstat      
      	-a  查看所有网络信息
		-n   不显示服务名称，显示地址信息	
		-P  显示服务进程
		-t  过滤,只包含TCP
		-u  过滤，只包含udp

Ifconfig 可查看地址信息
云服务器–>内网地址：

字节序（byte order）关系到多字节整数（short/int16、int/int32,int64）和浮点数的各字节在内存中的存放顺序。字节序分为两种：小端字节序（little endian）和大端字节序（big endian）。小端字节序：低字节存放在内存低地址，例如对两字节整数0x0100(十进制数256)，低字节00放在低地址（假设地址为0x0041f880），高字节01放在高地址0x0041f881。大端字节序：高字节在低地址，同样是0x0100，高字节01放在低地址（假设地址为0x0041f880），低字节00放高地址0x0041f881。可见对相同的两字节整数，在不同字节序的机器上其内存布局是不同的，反过来内存布局相同的，在不同字节序的机器上被解释为不同的整数值，除非这几个字节值相同。

    字节序是由cpu处理器架构决定的，和操作系统无关，例如Intel cpu采用小端字节序，PowerPC采用大端字节序，有些cpu例如Alpha支持两种字节序，但在使用时要设置具体采用哪一种字节序，不可能同时用两种。主机字节序（host byte order）就是指当前机器的字节序，根据cpu处理器的架构和设置，主机字节序可为小端字节序或大端字节序。关于字节序问题，较全面的描述见https://en.wikipedia.org/wiki/Endianness。

    在socket网络编程中通常会涉及到多字节整数、浮点数的传输，如果两台机器字节序不同，直接传多字节整数或浮点数会导致双方将这些多字节解释成不同的数字，所以要在网络协议中规定编解码方式，例如有的协议将整数编码成字符串来避免字节序问题，但只要协议中有多字节整数，都要规定采用什么字节序来表示协议中的多字节整数（除非能保证两台机器的字节序是相同的），也就出现了网络字节序，网络字节序其实就是大端字节序，协议当然也可采用小端字节序，只要双方统一就行。

     如上所述，在设计网络二进制协议时，对多字节整数，要规定打包传输时的字节序：网络字节序还是小端字节序。客户端和服务器代码在打包和解包时，对多字节整数，要进行主机字节序和协议规定的字节序的相互转化。

   Java应用通常使用java.nio.ByteBuffer进行协议数据的打包和解包，其order(ByteOrder bo)方法可设置打包或解包使用的字节序；如果使用netty框架，可使用ByteBuf类的order方法。

   C/C++应用通常使用C库中的如下函数来进行主机字节序和网络字节序的相互转换。

// hton* 主机字节转网络字节序

uint64_t htonll(uint64_t hostlonglong);

uint32_t htonl(uint32_t hostlong);

uint16_t htons(uint16_t hostshort);

// ntoh* 网络字节序转主机字节序

uint64_t ntohll(uint64_t hostlonglong);

uint32_t ntohl(uint32_t netlong);

uint16_t ntohs(uint16_t netshort);

  linux系统在endian.h头文件中提供了更多的函数进行主机字节和大小端字节序的相互转换，如下：

uint16_t htobe16(uint16_t host_16bits);

uint16_t htole16(uint16_t host_16bits);

uint16_t be16toh(uint16_t big_endian_16bits);

uint16_t le16toh(uint16_t little_endian_16bits);

uint32_t htobe32(uint32_t host_32bits);

uint32_t htole32(uint32_t host_32bits);

uint32_t be32toh(uint32_t big_endian_32bits);

uint32_t le32toh(uint32_t little_endian_32bits);

uint64_t htobe64(uint64_t host_64bits);

uint64_t htole64(uint64_t host_64bits);

uint64_t be64toh(uint64_t big_endian_64bits);

uint64_t le64toh(uint64_t little_endian_64bits);

   htobe*（例如htobe16）表示主机字节序到大端字节序（网络字节序）；htole*表示主机字节序到小端字节序；be*toh表示大端到主机；le*toh表示小端到主机。

  上面的字节序转换函数有个缺点，就是方法太多不方便使用，需要根据多字节整数的类型（uint16_t/int16_t/uint32_t/int32_t/uint64_t/int64_t）来调用不同的转换函数，所以在c++应用中利用模板技术编写了4个统一的字节序转换函数，和整数的类型无关。如下：

 /*
 *  ByteOrderUtil.h
 *
 *  Created on: Nov 15, 20xx
 *  Author: wanshi
 */
 
#ifndef BYTEORDERUTIL_H_
#define BYTEORDERUTIL_H_
 
#include <stdint.h>
 
namespace ByteOrder {
    const  uint16_t us_flag = 1;
    // little_end_flag 表示主机字节序是否小端字节序
    const  bool little_end_flag = *((uint8_t*)&us_flag) == 1;
 
    //小端到主机
 template<typename T> T le_to_host(T& from)
    {
   T to;
   uint8_t byteLen = sizeof(T);
 
         if(little_end_flag){
     return from;
         }
         else{
              char* to_char =  (char*)&to;
              char* from_char = (char*)&from;
     for(int i=0;i<byteLen;i++){
                   to_char[i] = from_char[byteLen-i-1];
       //此处也可用移位操作来实现
              }
     return to;
   }
 }
  
    //主机到小端
 template<typename T> T host_to_le(T& from)
    {
    return le_to_host(from);
 }
 
 //大端到主机
 template<typename T> T be_to_host(T& from)
    {
    T to;
    uint8_t byteLen = sizeof(T);
            if(!little_end_flag){
       return from;
            }
            else{
                    char* to_char =  (char*)&to;
                    char* from_char = (char*)&from;
                    for(int i=0;i<byteLen;i++){
                         to_char[i] = from_char[byteLen-i-1];
         //此处也可用移位操作来实现
                    }
       return to;
    }
 }
 
    //主机到大端
 template<typename T> T host_to_be(T& from)
 {
     return be_to_host(from);
 }
 
}
 
#endif /* BYTEORDERUTIL_H_ */
 
使用演示：
#include "ByteOrderUtil.h"
using namespace ByteOrder;
 
int main(int argc,char** argv)
{
        uint16_t u16t = 0x1514;
        //host到小端
        uint16_t leu16t = host_to_le(u16t);
        uint16_t hu16t = le_to_host(leu16t);
 
         uint64_t u64t = 0x15141312;
         //host到大端
         uint64_t beu64t = host_to_be(u64t);
         uint64_t hu64t = be_to_host(beu64t);
   return 0;
}

转自：https://wanshi.iteye.com/blog/2214693