免费注册 查看新帖 |

Chinaunix

  平台 论坛 博客 文库
最近访问板块 发新帖
查看: 1437 | 回复: 0
打印 上一主题 下一主题

linux select使用 [复制链接]

论坛徽章:
0
跳转到指定楼层
1 [收藏(0)] [报告]
发表于 2009-10-19 10:24 |只看该作者 |倒序浏览
Linux下各类TCP网络服务器的实现源代码关键词:                            
Linux
                               
C语言
                               
tcp
                               
网络
                               
编程
                                                                          
                                 
                                 
Linux下各类TCP网络服务器的实现源代码
大家都知道各类网络服务器程序的编写步骤,并且都知道网络服务器就两大类:循环服务和并发服务。这里附上源代码来个小结吧。
首先,循环网络服务器编程实现的步骤是这样的:
                              建立socket(这里用到socket()函数及函数setsockopt())
                                                            |
                                                            |
                                                           \|/
                              把socket和IP地址及端口绑定(这里用到bind函数)
                                                            |
                                                            |
                                                           \|/
                              开始监听(这里用到listen()函数)
                                                            |
                                                            |
                                                           /\
                                                       /        \
                                               \     /           \
                    -----------------------  | 有连接|
                    |                           /   \             /
                    |                                 \         /
                    |                                     \ /
                    |                                       |
                    |          接受新的连接(这里用到accept()函数)
                    |                                       |  /___________________________________________________
                  
|                                       |
\                                                                                                                           
|
                    |                                    
\|/                                                                                                                             
|
                    |         从连接里读取数据(这里用到recv()系统函数,当然也可以是read()函数)                          |
                  
|                                       
|                                                                                                                              
|
                    |                                      
|                                                                                                                              
|
                    |                                    
\|/                                                                                                                           
|
                    |          返回信息给连接(这里用到send()系统函数,当然也可以是write()函        数)                    |
                  
|                                      
|                                                                                                                              
|
                    |                                      
|                                                                                                                              
|
                    |                                    
/\                                                                                                                           
|
                    |                                  /      
\                                                                                                                        
|
                    |                              
/              
\                                                                                                                     
|
                    |                              | 还有数据 |-Y-------------------------------------------------------
                    |                              \               /
                    |                                 \         /
                    |                                     \ /
                    |________________|
这种服务器模型是典型循环服务,如果不加上多进程/线程技术,此种服务吞吐量有限,大家都可以看到,如果前一个连接服务数据没有收发完毕后面的连接没办法处理。所以一般有多进程技术,对一个新连接启用一个新进程去处理,而监听socket继续监听。
/************关于本文档********************************************
*filename: Linux下各类TCP网络服务器的实现源代码
*purpose: 记录Linux下各类tcp服务程序源代码
*wrote by: zhoulifa(
zhoulifa@163.com
) 周立发(
http://zhoulifa.bokee.com
)
Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
*date time:2006-07-04 22:00:00
*Note: 任何人可以任意复制代码并运用这些文档,当然包括你的商业用途
* 但请遵循GPL
*Hope:希望越来越多的人贡献自己的力量,为科学技术发展出力
*********************************************************************/
一个循环TCP服务源代码(因为用fork进行多进程服务了,所以这种服务现实中也有用)如下:
/*----------------------源代码开始--------------------------------------------*/
#include
#include
#include
#include
#include
#include
#include
#include
/*********************************************************************
*filename: cycletcpserver.c
*purpose: 循环tcp服务端程序
*tidied by: zhoulifa(
zhoulifa@163.com
) 周立发(
http://zhoulifa.bokee.com
)
Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
*date time:2006-07-04 22:00:00
*Note: 任何人可以任意复制代码并运用这些文档,当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Google.com
*********************************************************************/
int main(int argc, char ** argv)
{
    int sockfd,new_fd; /* 监听socket: sock_fd,数据传输socket: new_fd */
    struct sockaddr_in my_addr; /* 本机地址信息 */
    struct sockaddr_in their_addr; /* 客户地址信息 */
    unsigned int sin_size, myport, lisnum;
    if(argv[1])  myport = atoi(argv[1]);
    else myport = 7838;
    if(argv[2])  lisnum = atoi(argv[2]);
    else lisnum = 2;
    if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
        perror("socket");
        exit(1);
    }
    my_addr.sin_family=PF_INET;
    my_addr.sin_port=htons(myport);
    my_addr.sin_addr.s_addr = INADDR_ANY;
    bzero(&(my_addr.sin_zero), 0);
    if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1) {
        perror("bind");
        exit(1);
    }
    if (listen(sockfd, lisnum) == -1) {
        perror("listen");
        exit(1);
    }
    while(1) {
        sin_size = sizeof(struct sockaddr_in);
        if ((new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size)) == -1) {
            perror("accept");
            continue;
        }
        printf("server: got connection from %s\n",inet_ntoa(their_addr.sin_addr));
        if (!fork()) { /* 子进程代码段 */
            if (send(new_fd, "Hello, world!\n", 14, 0) == -1) {
                perror("send");
                close(new_fd);
                exit(0);
            }
        }
        close(new_fd); /*父进程不再需要该socket*/
        waitpid(-1,NULL,WNOHANG);/*等待子进程结束,清除子进程所占用资源*/
    }
}
/*----------------------源代码结束--------------------------------------------*/
一个测试客户端代码如下:
/*----------------------源代码开始--------------------------------------------*/
#include
#include
#include
#include
#include
#include
#include
#include
#define MAXDATASIZE 100 /*每次最大数据传输量 */
/*********************************************************************
*filename: cycletcpclient.c
*purpose: 循环tcp客户端程序
*tidied by: zhoulifa(
zhoulifa@163.com
) 周立发(
http://zhoulifa.bokee.com
)
Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
*date time:2006-07-04 22:20:00
*Note: 任何人可以任意复制代码并运用这些文档,当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Google.com
*Hope:希望越来越多的人贡献自己的力量,为科学技术发展出力
*********************************************************************/
int main(int argc, char *argv[])
{
    int sockfd, numbytes;
    char buf[MAXDATASIZE];
    struct hostent *he;
    struct sockaddr_in their_addr;
    unsigned int myport;
    if(argv[2]) myport = atoi(argv[2]);
    else myport = 7838;
    if (argc != 3) {
        fprintf(stderr,"usage: %s hostname port\n", argv[0]);
        exit(1);
    }
    if((he=gethostbyname(argv[1]))==NULL) {
        herror("gethostbyname");
        exit(1);
    }
    if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
        perror("socket");
        exit(1);
    }
    their_addr.sin_family=PF_INET;
    their_addr.sin_port=htons(myport);
    their_addr.sin_addr = *((struct in_addr *)he->h_addr);
    bzero(&(their_addr.sin_zero),0);
    if (connect(sockfd, (struct sockaddr *)&their_addr, sizeof(struct sockaddr)) == -1) {
        perror("connect");
        exit(1);
    }
    if ((numbytes=recv(sockfd, buf, MAXDATASIZE, 0)) == -1) {
        perror("recv");
        exit(1);
    }
    buf[numbytes] = 0;
    printf("Received: %s\n",buf);
    close(sockfd);
    return 0;
}
/*----------------------源代码结束--------------------------------------------*/
用gcc cycletcpserver.c -o tcpserver和gcc cycletcpclient.c -o tcpclient分别编译上述代码后运行情况如下:
服务端运行显示:
[email=administrator@ubuzlf:/data/example/c$]administrator@ubuzlf:/data/example/c$[/email]
./tcpserver
server: got connection from 127.0.0.1
server: got connection from 127.0.0.1
server: got connection from 127.0.0.1
客户端运行显示:
[email=administrator@ubuzlf:/data/example/c$]administrator@ubuzlf:/data/example/c$[/email]
./tcpclient 127.0.0.1 7838
Received: Hello, world!
[email=administrator@ubuzlf:/data/example/c$]administrator@ubuzlf:/data/example/c$[/email]
./tcpclient 127.0.0.1 7838
Received: Hello, world!
[email=administrator@ubuzlf:/data/example/c$]administrator@ubuzlf:/data/example/c$[/email]
./tcpclient 127.0.0.1 7838
Received: Hello, world!
不得不说的一个概念性问题:阻塞与非阻塞

阻塞服务中,当服务器运行到accept语句而没有客户连接服务请求到来,那么会发生什么情况?这时服务器就会停止在accept语句上等待连接服务请求
的到来;同样,当程序运行到接收数据语句recv时,如果没有数据可以读取,则程序同样会停止在接收语句上。这种情况称为阻塞(blocking)。
但如果你希望服务器仅仅注意检查是否有客户在等待连接,有就接受连接;否则就继续做其他事情,则可以通过将 socket设置为非阻塞方式来实现:非阻塞socket在没有客户在等待时就使accept调用立即返回 。

过设置socket为非阻塞方式,可以实现“轮询”若干socket。当企图从一个没有数据等待处理的非阻塞socket读入数据时,函数将立即返回,并
且返回值置为-1,并且errno置为EWOULDBLOCK。但是这种“轮询”会使CPU处于忙等待方式,从而降低性能。考虑到这种情况,假设你希望服
务器监听连接服务请求的同时从已经建立的连接读取数据,你也许会想到用一个accept语句和多个recv()语句,但是由于accept及recv都是
会阻塞的,所以这个想法显然不会成功。
调用非阻塞的socket会大大地浪费系统资源。而调用select()会有效地解决这个问题,它允许你把
进程本身挂起来,而同时使系统内核监听所要求的一组文件描述符的任何活动,只要确认在任何被监控的文件描述符上出现活动,select()调用将返回指示
该文件描述符已准备好的信息,从而实现了为进程选出随机的变化,而不必由进程本身对输入进行测试而浪费CPU开销。
其次,并发服务器,在上述cycletcpserver.c中,由于使用了fork技术也可以称之为并发服务器,但这种服务器并不是真正意义上的IO多路复用的并发服务器,并且由于没有处理阻塞问题,实际应用有各种各样的问题。
一个典型IO多路复用的单进程并发服务器流程如下:
/*IO多路复用并发服务流程图*/

下面是一个演示IO多路复用的源程序,是一个端口转发程序,但它的用处相当大,实际应用中的各类代理软件或端口映射软件都是基于这样的代码的,比如Windows下的WinGate、WinProxy等都是在此基础上实现的。源代码如下:
/*----------------------源代码开始--------------------------------------------*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
static int forward_port;
#undef max
#define max(x,y) ((x) > (y) ? (x) : (y))
/*************************关于本文档************************************
*filename: tcpforwardport.c
*purpose: 演示了select的用法,这是一个极好的代理软件核心,专门作端口映射用
*tidied by: zhoulifa(
zhoulifa@163.com
) 周立发(
http://zhoulifa.bokee.com
)
Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
*date time:2006-07-05 19:00:00
*Note: 任何人可以任意复制代码并运用这些文档,当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Paul Sheer 感谢Paul Sheer在select_tut的man手册里提供了这份源代码
*Hope:希望越来越多的人贡献自己的力量,为科学技术发展出力
*********************************************************************/
static int listen_socket (int listen_port) {
    struct sockaddr_in a;
    int s;
    int yes;
    if ((s = socket (AF_INET, SOCK_STREAM, 0)) = 0) {   \
        shutdown (fd1, SHUT_RDWR);  \
        close (fd1);  \
        fd1 = -1;     \
    }   \
}
#define SHUT_FD2 { \
    if (fd2 >= 0) {   \
        shutdown (fd2, SHUT_RDWR);  \
        close (fd2);  \
        fd2 = -1;     \
    }   \
}
#define BUF_SIZE 1024
int main (int argc, char **argv) {
    int h;
    int fd1 = -1, fd2 = -1;
    char buf1[BUF_SIZE], buf2[BUF_SIZE];
    int buf1_avail, buf1_written;
    int buf2_avail, buf2_written;
    if (argc != 4) {
        fprintf (stderr, "Usage\n\tfwd   \n");
        exit (1);
    }
    signal (SIGPIPE, SIG_IGN);
    forward_port = atoi (argv[2]);
    /*建立监听socket*/
    h = listen_socket (atoi (argv[1]));
    if (h  0 && buf1_avail  0 && buf2_avail  0 && buf2_avail - buf2_written > 0) {
            FD_SET (fd1, &wr);
            nfds = max (nfds, fd1);
        }
        if (fd2 > 0 && buf1_avail - buf1_written > 0) {
            FD_SET (fd2, &wr);
            nfds = max (nfds, fd2);
        }
        /*把有异常数据的socket两个一起放入select的异常句柄列表里*/
        if (fd1 > 0) {
            FD_SET (fd1, &er);
            nfds = max (nfds, fd1);
        }
        if (fd2 > 0) {
            FD_SET (fd2, &er);
            nfds = max (nfds, fd2);
        }
        /*开始select*/
        r = select (nfds + 1, &rd, &wr, &er, NULL);
        if (r == -1 && errno == EINTR) continue;
        if (r  0)
        if (FD_ISSET (fd1, &er)) {
            char c;
            errno = 0;
            r = recv (fd1, &c, 1, MSG_OOB);
            if (r  0)
        if (FD_ISSET (fd2, &er)) {
            char c;
            errno = 0;
            r = recv (fd2, &c, 1, MSG_OOB);
            if (r  0)
        if (FD_ISSET (fd1, &rd)) {
            r = read (fd1, buf1 + buf1_avail, BUF_SIZE - buf1_avail);
            if (r  0)
        if (FD_ISSET (fd2, &rd)) {
            r = read (fd2, buf2 + buf2_avail, BUF_SIZE - buf2_avail);
            if (r  0)
        if (FD_ISSET (fd1, &wr)) {
            r = write (fd1, buf2 + buf2_written, buf2_avail - buf2_written);
            if (r  0)
        if (FD_ISSET (fd2, &wr)) {
            r = write (fd2, buf1 + buf1_written, buf1_avail - buf1_written);
            if (r
用gcc tcpforwardport.c -o MyProxy编译此程序后运行效果如下:
./MyProxy 8000 80 172.16.100.218
accepting connections on port 8000
connect from 127.0.0.1
当有用户访问本机的8000端口时,MyProxy程序将把此请求转发到172.16.100.218主机的80端口,即实现了一个http代理。
关于select函数:
其函数原型为:
int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

函数的功能是由内核检测在timeout时间内,是否有readfds,writefds,exceptfds三个句柄集(file
descriptors)里的某个句柄(file
descriptor)的状态符合寻求,即readfds句柄集里有句柄可读或writefds句柄集里有可写或exceptfds句柄集里有例外发生,
任何一个有变化函数就立即返回,返回值为timeout发生状态变化的句柄个数。
n是所有readfds,writefds,exceptfds三个句柄集(file descriptors)里编号最大值加1。比如:要检测两个socket句柄fd1和fd2在timeout时间内是否分别可读和可写就可以这样:
先把两个句柄集(file descriptors)清零:
        FD_ZERO (&readfds);
        FD_ZERO (&writefds);
然后把fd1加入读检测集:
        FD_SET (fd1, &readfds);
然后把fd2加入写检测集:
        FD_SET (fd2, &writefds);
再给timeout设置值,timeout是这样的一个结构:
              struct timeval {
                  long    tv_sec;         /* seconds */
                  long    tv_usec;        /* microseconds */
              };
你可以这样赋值:
        timeout.tv_sec=1;
        timeout.tv_uec=0;
表示检测在1秒钟内是否有句柄状态发生变化。
如果有句柄发生变化,就可以用FD_ISSET检测各个句柄,比如:
                FD_ISSET (fd1, &readfds);//检测是否fd1变成可读的了
                FD_ISSET (fd2, &writefds);//检测是否fd2变成可写的了
示意程序代码如下:
/*----------------------示意代码开始--------------------------------------------*/
    fd1 = socket();//创建一个socket
    fd2 = socket();//创建一个socket
    while(1)  {
        FD_ZERO (&readfds);
        FD_ZERO (&writefds);
        FD_SET (fd1, &readfds);
        FD_SET (fd2, &writefds);
        timeout.tv_sec=1;
        timeout.tv_uec=0;
        ret = select(fd1>fd2?(fd1+1):(fd2+1), &readfds, &writefds, NULL, &timeout);
        if(ret
经常用到的几个自定义函数:
1、开启监听的函数
/*----------------------源代码代码开始--------------------------------------------*/
int
OpenSCPServer(int port, int total, int sendbuflen, int recvbuflen, int blockORnot, int reuseORnot)    {
/*************************关于本函数************************************
*function_name: OpenSCPServer
*参数说明:port整数型监听端口号,total整数型监听个数,sendbuflen整数型发送缓冲区大小
*          recvbuflen整数型接收缓冲区大小,blockORnot整数型是否阻塞,reuseORnot整数型是否端口重用
*purpose: 用来建立一个tcp服务端socket
*tidied by: zhoulifa(
zhoulifa@163.com
) 周立发(
http://zhoulifa.bokee.com
)
Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
*date time:2006-07-05 20:00:00
*Note: 任何人可以任意复制代码并运用这些文档,当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Paul Sheer 感谢Paul Sheer在select_tut的man手册里提供了这份源代码
*Hope:希望越来越多的人贡献自己的力量,为科学技术发展出力
*Note:要使用此函数需要自定义一个全局变量char errorMessage[1024];并包含GetCurrentTime.h头文件
*********************************************************************/
    int    sockfd = 0, ret = 0, opt = 0, flags=1;
    struct sockaddr_in    laddr;
    ret = sockfd = socket(PF_INET, SOCK_STREAM, 0);
    if(ret 2、连接服务器的函数
/*----------------------源代码代码开始--------------------------------------------*/
int
ConnectSCPServer(char * serverip, int serverport, int blockORnot)    {
/*************************关于本函数************************************
*function_name: ConnectSCPServer
*参数说明:serverip服务器IP地址或主机名,serverport服务器端口,blockORnot整数型是否阻塞
*purpose: 用来建立一个tcp客户端socket
*tidied by: zhoulifa(
zhoulifa@163.com
) 周立发(
http://zhoulifa.bokee.com
)
Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
*date time:2006-07-05 20:40:00
*Note: 任何人可以任意复制代码并运用这些文档,当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Paul Sheer 感谢Paul Sheer在select_tut的man手册里提供了这份源代码
*Hope:希望越来越多的人贡献自己的力量,为科学技术发展出力
*Note:要使用此函数需要自定义一个全局变量char errorMessage[1024];并包含自己编写的GetCurrentTime.h头文件
*********************************************************************/
    int    serversock = 0, ret = 0;
    unsigned long    addr;
    struct sockaddr_in    sin;
    struct hostent *he;
    if((he=gethostbyname(serverip))== 0) {
        sprintf(errorMessage, "ConnectSCPServer IP address '%s' error! return:-1 %s", serverip, GetCurrentTime(0, 0));
        return -1;
    }
    serversock = socket(PF_INET, SOCK_STREAM, 0);
    if(serversock == -1)    {
      
sprintf(errorMessage, "ConnectSCPServer socket() error! return:-2,
errno=%d, errortext:'%s' %s", errno, strerror(errno), GetCurrentTime(0,
0));
        return -2;
    }
    ioctl(serversock, FIONBIO, &blockORnot);  //block or not
    memset((char*)&sin, 0, sizeof(struct sockaddr_in));
    sin.sin_family = PF_INET;
    sin.sin_port = htons(serverport);
    sin.sin_addr = *((struct in_addr *)he->h_addr);
    ret = connect(serversock, (struct sockaddr *)&sin, sizeof(sin));
    if(ret == -1)    {
      
sprintf(errorMessage, "ConnectSCPServer connect() error! return:-3,
errno=%d, errortext:'%s' %s", errno, strerror(errno), GetCurrentTime(0,
0));
        close(serversock);
        return -3;
    }
    return serversock;
}
/*----------------------源代码代码结束--------------------------------------------*/
3、发送数据函数Send
/*----------------------源代码代码开始--------------------------------------------*/
int
Send(int sock, char * buf, size_t size, int flag, int timeout)    {
/*************************关于本函数************************************
*function_name: Send
*参数说明:sock整数型socket,buf待发送的内容,size要发送的大小,flag发送选项,timeout超时时间值
*purpose: 用来通过一个socket在指定时间内发送数据
*tidied by: zhoulifa(
zhoulifa@163.com
) 周立发(
http://zhoulifa.bokee.com
)
Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
*date time:2006-07-05 20:58:00
*Note: 任何人可以任意复制代码并运用这些文档,当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Paul Sheer 感谢Paul Sheer在select_tut的man手册里提供了这份源代码
*Hope:希望越来越多的人贡献自己的力量,为科学技术发展出力
*Note:要使用此函数需要自定义一个全局变量char errorMessage[1024];并包含自己编写的GetCurrentTime.h头文件
*********************************************************************/
    int i = 0, ret = 0, intretry = 0;
    struct timeval tival;
    fd_set writefds;
    int maxfds = 0;
    tival.tv_sec = timeout;
    tival.tv_usec = 0;
    FD_ZERO(&writefds);
    if(sock > 0) {
        FD_SET(sock, &writefds);
        maxfds=((sock > maxfds)?sock:maxfds);
    }
    else    {
        sprintf(errorMessage, "Send socket:%d error! return:-2 %s", sock, GetCurrentTime(0, 0));
        return -2;
    }
    ret = select(maxfds + 1, NULL, &writefds, NULL, &tival);
    if(ret 4、接收数据函数Recv
/*----------------------源代码代码开始--------------------------------------------*/
int
Recv(int sock, char * buf, size_t size, int flag, int timeout)    {
/*************************关于本函数************************************
*function_name: Recv
*参数说明:sock整数型socket,buf接收数据的缓冲区,size要接收数据的大小,flag接收选项,timeout超时时间值
*purpose: 用来从一个socket在指定时间内读取数据
*tidied by: zhoulifa(
zhoulifa@163.com
) 周立发(
http://zhoulifa.bokee.com
)
Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
*date time:2006-07-05 21:10:00
*Note: 任何人可以任意复制代码并运用这些文档,当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Paul Sheer 感谢Paul Sheer在select_tut的man手册里提供了这份源代码
*Hope:希望越来越多的人贡献自己的力量,为科学技术发展出力
*Note:要使用此函数需要自定义一个全局变量char errorMessage[1024];并包含自己编写的GetCurrentTime.h头文件
*********************************************************************/
    int i = 0, ret = 0, intretry = 0;
    struct timeval tival;
    fd_set readfds;
    int maxfds = 0;
    tival.tv_sec = timeout;
    tival.tv_usec = 0;
    FD_ZERO(&readfds);
    if(sock > 0) {
        FD_SET(sock, &readfds);
        maxfds=((sock > maxfds)?sock:maxfds);
    }
    else    {
        sprintf(errorMessage, "Recv socket:%d error! return:-2 %s", sock, GetCurrentTime(0, 0));
        return -2;
    }
    ret = select(maxfds + 1, &readfds, NULL, NULL, &tival);
    if(ret 最
后需要说明的是:我这里讲到的源程序并不能实际地作为一个产品程序来用,实际情况下可能会有其它许多工作要做,比如可能要建立共享队列来存放socket
里读到的消息,也可能把发送消息先进行排队然后再调用Send函数。还有,如果不是全数字,在发送前一定要htonl转换为网络字节序,同理接收到后一定
要先ntohl由网络字节序转换为主机字节序,否则对方发送过来的0x00000001在你这里可能是0x00010000,因为高低位顺序不同
               
               
               

本文来自ChinaUnix博客,如果查看原文请点:http://blog.chinaunix.net/u2/63560/showart_2073068.html
您需要登录后才可以回帖 登录 | 注册

本版积分规则 发表回复

  

北京盛拓优讯信息技术有限公司. 版权所有 京ICP备16024965号-6 北京市公安局海淀分局网监中心备案编号:11010802020122 niuxiaotong@pcpop.com 17352615567
未成年举报专区
中国互联网协会会员  联系我们:huangweiwei@itpub.net
感谢所有关心和支持过ChinaUnix的朋友们 转载本站内容请注明原作者名及出处

清除 Cookies - ChinaUnix - Archiver - WAP - TOP