socket实现简单的通信-CSDN博客

文章目录

socket
什么是socket？
Internet套接字
网络理论
socket编程步骤
主要函数
C++多线程
源码下载

socket

socket本质是编程接口(API)，对TCP/IP的封装，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口；HTTP是轿车，提供了封装或者显示数据的具体形式;Socket是发动机，提供了网络通信的能力。
在Internet上的主机一般运行了多个服务软件，同时提供几种服务。每种服务都打开一个Socket，并绑定到一个端口上，不同的端口对应于不同的服务。Socket正如其英文原意那样，像一个多孔插座。一台主机犹如布满各种插座的房间，每个插座有一个编号，有的插座提供220伏交流电，有的提供110伏交流电，有的则提供有线电视节目。客户软件将插头插到不同编号的插座，就可以得到不同的服务。

什么是socket？

你经常听到人们谈论着 “socket”，或许你还不知道它的确切含义。现在让我告诉你：它是使用标准Unix 文件描述符 (file descriptor) 和其它程序通讯的方式。什么？你也许听到一些Unix高手(hacker)这样说过：“呀，Unix中的一切就是文件！”那个家伙也许正在说到一个事实：Unix 程序在执行任何形式的 I/O 的时候，程序是在读或者写一个文件描述符。一个文件描述符只是一个和打开的文件相关联的整数。但是(注意后面的话)，这个文件可能是一个网络连接，FIFO，管道，终端，磁盘上的文件或者什么其它的东西。Unix 中所有的东西就是文件！所以，你想和Internet上别的程序通讯的时候，你将要使用到文件描述符。你必须理解刚才的话。现在你脑海中或许冒出这样的念头：“那么我从哪里得到网络通讯的文件描述符呢？”，这个问题无论如何我都要回答：你利用系统调用 socket()，它返回套接字描述符 (socket descriptor)，然后你再通过它来进行send() 和 recv()调用。

“但是…”，你可能有很大的疑惑，“如果它是个文件描述符，那么为什么不用一般调用read()和write()来进行套接字通讯？”简单的答案是：“你可以使用！”。详细的答案是：“你可以，但是使用send()和recv()让你更好的控制数据传输。”

存在这样一个情况：在我们的世界上，有很多种套接字。有DARPA Internet 地址 (Internet 套接字)，本地节点的路径名 (Unix套接字)，CCITT X.25地址 (你可以将X.25 套接字完全忽略)。也许在你的Unix 机器上还有其它的。我们在这里只讲第一种：Internet 套接字。

Internet套接字

什么意思？有两种类型的Internet 套接字？是的。不，我在撒谎。其实还有很多，但是我可不想吓着你。我们这里只讲两种。除了这些, 我打算另外介绍的 “Raw Sockets” 也是非常强大的，很值得查阅。
那么这两种类型是什么呢？一种是"Stream Sockets"（流格式），另外一种是"Datagram Sockets"（数据包格式）。我们以后谈到它们的时候也会用到 “SOCK_STREAM” 和 “SOCK_DGRAM”。数据报套接字有时也叫“无连接套接字”(如果你确实要连接的时候可以用connect()。) 流式套接字是可靠的双向通讯的数据流。如果你向套接字按顺序输出“1，2”，那么它们将按顺序“1，2”到达另一边。它们是无错误的传递的，有自己的错误控制，在此不讨论。

有什么在使用流式套接字？你可能听说过 telnet，不是吗？它就使用流式套接字。你需要你所输入的字符按顺序到达，不是吗？同样，WWW浏览器使用的 HTTP 协议也使用它们来下载页面。实际上，当你通过端口80 telnet 到一个 WWW 站点，然后输入 “GET pagename” 的时候，你也可以得到 HTML 的内容。为什么流式套接字可以达到高质量的数据传输？这是因为它使用了“传输控制协议 (The Transmission Control Protocol)”，也叫 “TCP” (请参考 RFC-793 获得详细资料。)TCP 控制你的数据按顺序到达并且没有错误。你也许听到 “TCP” 是因为听到过 “TCP/IP”。这里的 IP 是指“Internet 协议”(请参考 RFC-791。) IP只是处理 Internet 路由而已。

那么数据报套接字呢？为什么它叫无连接呢？为什么它是不可靠的呢？有这样的一些事实：如果你发送一个数据报，它可能会到达，它可能次序颠倒了。如果它到达，那么在这个包的内部是无错误的。数据报也使用 IP 作路由，但是它不使用 TCP。它使用“用户数据报协议 (User Datagram Protocol)”，也叫 “UDP” (请参考 RFC-768。)

为什么它们是无连接的呢？主要是因为它并不象流式套接字那样维持一个连接。你只要建立一个包，构造一个有目标信息的IP 头，然后发出去。无需连接。它们通常使用于传输包-包信息。简单的应用程序有：tftp, bootp等等。

你也许会想：“假如数据丢失了这些程序如何正常工作？”我的朋友，每个程序在 UDP 上有自己的协议。例如，tftp 协议每发出的一个被接受到包，收到者必须发回一个包来说“我收到了！” (一个“命令正确应答”也叫“ACK” 包)。如果在一定时间内(例如5秒)，发送方没有收到应答，它将重新发送，直到得到 ACK。这一ACK过程在实现 SOCK_DGRAM 应用程序的时候非常重要。

网络理论

既然我刚才提到了协议层，那么现在是讨论网络究竟如何工作和一些关于 SOCK_DGRAM 包是如何建立的例子。当然，你也可以跳过这一段，如果你认为已经熟悉的话。

现在是学习数据封装 (Data Encapsulation) 的时候了！它非常非常重要。它重要性重要到你在网络课程学习中无论如何也得也得掌握它（图1：数据封装）。主要的内容是：一个包，先是被第一个协议(在这里是TFTP )在它的报头（也许是报尾）包装(“封装”)，然后，整个数据(包括 TFTP 头)被另外一个协议 (在这里是 UDP )封装，然后下一个( IP )，一直重复下去，直到硬件(物理) 层( 这里是以太网 )。
当另外一台机器接收到包，硬件先剥去以太网头，内核剥去IP和UDP 头，TFTP程序再剥去TFTP头，最后得到数据。

现在我们终于讲到声名狼藉的网络分层模型 (Layered Network Model)。这种网络模型在描述网络系统上相对其它模型有很多优点。例如，你可以写一个套接字程序而不用关心数据的物理传输(串行口，以太网，连接单元接口 (AUI) 还是其它介质)，因为底层的程序会为你处理它们。实际的网络硬件和拓扑对于程序员来说是透明的。

不说其它废话了，我现在列出整个层次模型。如果你要参加网络考试，可一定要记住：

应用层 (Application)

表示层 (Presentation)

会话层 (Session)

传输层(Transport)

网络层(Network)

数据链路层(Data Link)

物理层(Physical)

物理层是硬件(串口，以太网等等)。应用层是和硬件层相隔最远的–它是用户和网络交互的地方。这个模型如此通用，如果你想，你可以把它作为修车指南。把它对应到 Unix，结果是：

应用层(Application Layer) (telnet, ftp,等等)

传输层(Host-to-Host Transport Layer) (TCP, UDP)

Internet层(Internet Layer) (IP和路由)

网络访问层 (Network Access Layer) (网络层，数据链路层和物理层)

现在，你可能看到这些层次如何协调来封装原始的数据了。

看看建立一个简单的数据包有多少工作？哎呀，你将不得不使用 “cat” 来建立数据包头！这仅仅是个玩笑。对于流式套接字你要作的是 send() 发送数据。对于数据报式套接字，你按照你选择的方式封装数据然后使用 sendto()。内核将为你建立传输层和 Internet 层，硬件完成网络访问层。这就是现代科技。现在结束我们的网络理论速成班。哦，忘记告诉你关于路由的事情了。但是我不准备谈它，如果你真的关心，那么参考 IP RFC。

socket编程步骤

服务器端编程的步骤：

1：加载套接字库，创建套接字(WSAStartup()/socket())；

2：绑定套接字到一个IP地址和一个端口上(bind())；

3：将套接字设置为监听模式等待连接请求(listen())；

4：请求到来后，接受连接请求，返回一个新的对应于此次连接的套接字(accept())；

5：用返回的套接字和客户端进行通信(send()/recv())；

6：返回，等待另一连接请求；

7：关闭套接字，关闭加载的套接字库(closesocket()/WSACleanup())。

客户端编程的步骤：

1：加载套接字库，创建套接字(WSAStartup()/socket())；

2：向服务器发出连接请求(connect())；

3：和服务器端进行通信(send()/recv())；

4：关闭套接字，关闭加载的套接字库(closesocket()/WSACleanup())。

主要函数

socket()函数

我想我不能再不提这个了－下面我将讨论一下socket()系统调用。

下面是详细介绍：
```
 #include <sys/types.h>
 
 #include <sys/socket.h>
 
 int socket(int domain, int type, int protocol);
```
但是它们的参数是什么? 首先，domain 应该设置成 “AF_INET”，就象上面的数据结构struct sockaddr_in 中一样。然后，参数 type 告诉内核是 SOCK_STREAM 类型还是 SOCK_DGRAM 类型。最后，把 protocol 设置为 “0”。(注意：有很多种 domain、type，我不可能一一列出了，请看 socket() 的 man帮助。当然，还有一个"更好"的方式去得到 protocol，同时请查阅 getprotobyname() 的 man 帮助。) socket() 只是返回你以后在系统调用种可能用到的 socket 描述符，或者在错误的时候返回-1。全局变量 errno 中将储存返回的错误值。(请参考 perror() 的 man 帮助。)
bind()函数

一旦你有一个套接字，你可能要将套接字和机器上的一定的端口关联起来。(如果你想用listen()来侦听一定端口的数据，这是必要一步–MUD 告诉你说用命令 “telnet x.y.z 6969”。)如果你只想用 connect()，那么这个步骤没有必要。但是无论如何，请继续读下去。

这里是系统调用 bind() 的大概：
```
 #include <sys/types.h>
 
 #include <sys/socket.h>
 
 int bind(int sockfd, struct sockaddr *my_addr, int addrlen);
```
sockfd 是调用 socket 返回的文件描述符。my_addr 是指向数据结构 struct sockaddr 的指针，它保存你的地址(即端口和 IP 地址) 信息。 addrlen 设置为 sizeof(struct sockaddr)。简单得很不是吗? 再看看例子：
```
 #include <string.h>
 
 #include <sys/types.h>
 
 #include <sys/socket.h>
 
 #define MYPORT 3490
 
 main()
 
 {
 
 　　int sockfd;
 
 　　struct sockaddr_in my_addr;
 
 　　sockfd = socket(AF_INET, SOCK_STREAM, 0); /*需要错误检查 */
 
 　　my_addr.sin_family = AF_INET; /* host byte order */
 
 　　my_addr.sin_port = htons(MYPORT); /* short, network byte order */
 
 　　my_addr.sin_addr.s_addr = inet_addr("132.241.5.10");
 
 　　bzero(&(my_addr.sin_zero),; /* zero the rest of the struct */
 
 　　/* don't forget your error checking for bind(): */
 
 　　bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr));
```
这里也有要注意的几件事情。my_addr.sin_port 是网络字节顺序， my_addr.sin_addr.s_addr 也是的。另外要注意到的事情是因系统的不同，包含的头文件也不尽相同，请查阅本地的 man 帮助文件。在 bind() 主题中最后要说的话是，在处理自己的 IP 地址和/或端口的时候，有些工作是可以自动处理的。
```
 my_addr.sin_port = 0; /* 随机选择一个没有使用的端口 */
 
 my_addr.sin_addr.s_addr = INADDR_ANY; /* 使用自己的IP地址 */
```
通过将0赋给 my_addr.sin_port，你告诉 bind() 自己选择合适的端口。同样，将 my_addr.sin_addr.s_addr 设置为 INADDR_ANY，你告诉它自动填上它所运行的机器的 IP 地址。

如果你一向小心谨慎，那么你可能注意到我没有将 INADDR_ANY 转换为网络字节顺序！这是因为我知道内部的东西：INADDR_ANY 实际上就是 0！即使你改变字节的顺序，0依然是0。但是完美主义者说应该处处一致，INADDR_ANY或许是12呢？你的代码就不能工作了，那么就看下面的代码：
```
 my_addr.sin_port = htons(0); /* 随机选择一个没有使用的端口 */
 
 my_addr.sin_addr.s_addr = htonl(INADDR_ANY);/* 使用自己的IP地址 */
```
你或许不相信，上面的代码将可以随便移植。我只是想指出，既然你所遇到的程序不会都运行使用htonl的INADDR_ANY。

bind() 在错误的时候依然是返回-1，并且设置全局错误变量errno。

在你调用 bind() 的时候，你要小心的另一件事情是：不要采用小于 1024的端口号。所有小于1024的端口号都被系统保留！你可以选择从1024 到65535的端口(如果它们没有被别的程序使用的话)。
你要注意的另外一件小事是：有时候你根本不需要调用它。如果你使用 connect() 来和远程机器进行通讯，你不需要关心你的本地端口号(就象你在使用 telnet 的时候)，你只要简单的调用 connect() 就可以了，它会检查套接字是否绑定端口，如果没有，它会自己绑定一个没有使用的本地端口。
connect()程序

现在我们假设你是个 telnet 程序。你的用户命令你得到套接字的文件描述符。你听从命令调用了socket()。下一步，你的用户告诉你通过端口 23(标准 telnet 端口)连接到"132.241.5.10"。你该怎么做呢? 幸运的是，你正在阅读 connect()–如何连接到远程主机这一章。你可不想让你的用户失望。

connect() 系统调用是这样的：
```
 #include <sys/types.h>
 
 #include <sys/socket.h>
 
 int connect(int sockfd, struct sockaddr *serv_addr, int addrlen);
```
sockfd 是系统调用 socket() 返回的套接字文件描述符。serv_addr 是保存着目的地端口和 IP 地址的数据结构 struct sockaddr。addrlen 设置为 sizeof(struct sockaddr)。想知道得更多吗？让我们来看个例子：
```
 #include <string.h>

 #include <sys/types.h>

 #include <sys/socket.h>
 
 #define DEST_IP "132.241.5.10"
 
 #define DEST_PORT 23
 
 main()
 
 {
 
 　　int sockfd;
 
 　　struct sockaddr_in dest_addr; /* 目的地址*/
 
 　　sockfd = socket(AF_INET, SOCK_STREAM, 0); /* 错误检查 */
 
 　　dest_addr.sin_family = AF_INET; /* host byte order */
 
 　　dest_addr.sin_port = htons(DEST_PORT); /* short, network byte order */
 
 　　dest_addr.sin_addr.s_addr = inet_addr(DEST_IP);
 
 　　bzero(&(dest_addr.sin_zero),; /* zero the rest of the struct */
 
 　　/* don't forget to error check the connect()! */
 
 　　connect(sockfd, (struct sockaddr *)&dest_addr, sizeof(struct sockaddr));
```
再一次，你应该检查 connect() 的返回值–它在错误的时候返回-1，并设置全局错误变量 errno。同时，你可能看到，我没有调用 bind()。因为我不在乎本地的端口号。我只关心我要去那。内核将为我选择一个合适的端口号，而我们所连接的地方也自动地获得这些信息。一切都不用担心。
listen()函数

是换换内容得时候了。假如你不希望与远程的一个地址相连，或者说，仅仅是将它踢开，那你就需要等待接入请求并且用各种方法处理它们。处理过程分两步：首先，你听–listen()，然后，你接受–accept() (请看下面的内容)。

除了要一点解释外，系统调用 listen 也相当简单。
```
 int listen(int sockfd, int backlog);
```
sockfd 是调用 socket() 返回的套接字文件描述符。backlog 是在进入队列中允许的连接数目。什么意思呢? 进入的连接是在队列中一直等待直到你接受 (accept() 请看下面的文章)连接。它们的数目限制于队列的允许。大多数系统的允许数目是20，你也可以设置为5到10。

和别的函数一样，在发生错误的时候返回-1，并设置全局错误变量 errno。

你可能想象到了，在你调用 listen() 前你或者要调用 bind() 或者让内核随便选择一个端口。如果你想侦听进入的连接，那么系统调用的顺序可能是这样的：
```
 socket();
 
 bind();
 
 listen();

 /* accept() 应该在这 */
```
因为它相当的明了，我将在这里不给出例子了。(在 accept() 那一章的代码将更加完全。)真正麻烦的部分在 accept()。
accept()函数

准备好了，系统调用 accept() 会有点古怪的地方的！你可以想象发生这样的事情：有人从很远的地方通过一个你在侦听 (listen()) 的端口连接 (connect()) 到你的机器。它的连接将加入到等待接受 (accept()) 的队列中。你调用 accept() 告诉它你有空闲的连接。它将返回一个新的套接字文件描述符！这样你就有两个套接字了，原来的一个还在侦听你的那个端口，新的在准备发送 (send()) 和接收 ( recv()) 数据。这就是这个过程！

函数是这样定义的：
```
 #include <sys/socket.h>
 
 int accept(int sockfd, void *addr, int *addrlen);
```
sockfd 相当简单，是和 listen() 中一样的套接字描述符。addr 是个指向局部的数据结构 sockaddr_in 的指针。这是要求接入的信息所要去的地方（你可以测定那个地址在那个端口呼叫你）。在它的地址传递给 accept 之前，addrlen 是个局部的整形变量，设置为 sizeof(struct sockaddr_in)。 accept 将不会将多余的字节给 addr。如果你放入的少些，那么它会通过改变 addrlen 的值反映出来。

同样，在错误时返回-1，并设置全局错误变量 errno。

现在是你应该熟悉的代码片段。
```
 #include <string.h>
 
 #include <sys/socket.h>
 
 #include <sys/types.h>
 
 #define MYPORT 3490 /*用户接入端口*/
 
 #define BACKLOG 10 /* 多少等待连接控制*/
 
 main()
 
 {
 
 　　int sockfd, new_fd; /* listen on sock_fd, new connection on new_fd */
 
 　　struct sockaddr_in my_addr; /* 地址信息 */
 
 　　struct sockaddr_in their_addr; /* connector's address information */
 
 　　int sin_size;
 
 　　sockfd = socket(AF_INET, SOCK_STREAM, 0); /* 错误检查*/
 
 　　my_addr.sin_family = AF_INET; /* host byte order */
 
 　　my_addr.sin_port = htons(MYPORT); /* short, network byte order */
 
 　　my_addr.sin_addr.s_addr = INADDR_ANY; /* auto-fill with my IP */
 
 　　bzero(&(my_addr.sin_zero),; /* zero the rest of the struct */
 
 　　/* don't forget your error checking for these calls: */
 
 　　bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr));
 
 　　listen(sockfd, BACKLOG);
 
 　　sin_size = sizeof(struct sockaddr_in);
 
 　　new_fd = accept(sockfd, &their_addr, &sin_size);
```
注意，在系统调用 send() 和 recv() 中你应该使用新的套接字描述符 new_fd。如果你只想让一个连接进来，那么你可以使用 close() 去关闭原来的文件描述符 sockfd 来避免同一个端口更多的连接。
send() and recv()函数

这两个函数用于流式套接字或者数据报套接字的通讯。如果你喜欢使用无连接的数据报套接字，你应该看一看下面关于sendto() 和 recvfrom() 的章节。

send() 是这样的：
```
 int send(int sockfd, const void *msg, int len, int flags);
```
sockfd 是你想发送数据的套接字描述符(或者是调用 socket() 或者是 accept() 返回的。)msg 是指向你想发送的数据的指针。len 是数据的长度。把 flags 设置为 0 就可以了。(详细的资料请看 send() 的 man page)。这里是一些可能的例子：
```
 char *msg = "Beej was here!";
 
 int len, bytes_sent;
 
 ……
 
 len = strlen(msg);
 
 bytes_sent = send(sockfd, msg, len, 0);
```
send() 返回实际发送的数据的字节数–它可能小于你要求发送的数目！注意，有时候你告诉它要发送一堆数据可是它不能处理成功。它只是发送它可能发送的数据，然后希望你能够发送其它的数据。记住，如果 send() 返回的数据和 len 不匹配，你就应该发送其它的数据。但是这里也有个好消息：如果你要发送的包很小(小于大约 1K)，它可能处理让数据一次发送完。最后要说得就是，它在错误的时候返回-1，并设置 errno。

recv() 函数很相似：
```
 int recv(int sockfd, void *buf, int len, unsigned int flags);
```
sockfd 是要读的套接字描述符。buf 是要读的信息的缓冲。len 是缓冲的最大长度。flags 可以设置为0。(请参考recv() 的 man page。) recv() 返回实际读入缓冲的数据的字节数。或者在错误的时候返回-1，同时设置 errno。

很简单，不是吗? 你现在可以在流式套接字上发送数据和接收数据了。你现在是 Unix 网络程序员了！
sendto() 和 recvfrom()函数

“这很不错啊”，你说，“但是你还没有讲无连接数据报套接字呢？” 没问题，现在我们开始这个内容。既然数据报套接字不是连接到远程主机的，那么在我们发送一个包之前需要什么信息呢? 不错，是目标地址！看看下面的：
```
 int sendto(int sockfd, const void *msg, int len, unsigned int flags,
 
 const struct sockaddr *to, int tolen);
```
你已经看到了，除了另外的两个信息外，其余的和函数 send() 是一样的。 to 是个指向数据结构 struct sockaddr 的指针，它包含了目的地的 IP 地址和端口信息。tolen 可以简单地设置为 sizeof(struct sockaddr)。和函数 send() 类似，sendto() 返回实际发送的字节数(它也可能小于你想要发送的字节数！)，或者在错误的时候返回 -1。

相似的还有函数 recv() 和 recvfrom()。recvfrom() 的定义是这样的：
```
 int recvfrom(int sockfd, void *buf, int len, unsigned int flags, 　
 
 struct sockaddr *from, int *fromlen);
```
又一次，除了两个增加的参数外，这个函数和 recv() 也是一样的。from 是一个指向局部数据结构 struct sockaddr 的指针，它的内容是源机器的 IP 地址和端口信息。fromlen 是个 int 型的局部指针，它的初始值为 sizeof(struct sockaddr)。函数调用返回后，fromlen 保存着实际储存在 from 中的地址的长度。

recvfrom() 返回收到的字节长度，或者在发生错误后返回 -1。

记住，如果你用 connect() 连接一个数据报套接字，你可以简单的调用 send() 和 recv() 来满足你的要求。这个时候依然是数据报套接字，依然使用 UDP，系统套接字接口会为你自动加上了目标和源的信息。
close()和shutdown()函数

你已经整天都在发送 (send()) 和接收 (recv()) 数据了，现在你准备关闭你的套接字描述符了。这很简单，你可以使用一般的 Unix 文件描述符的 close() 函数：
```
 close(sockfd);
```
它将防止套接字上更多的数据的读写。任何在另一端读写套接字的企图都将返回错误信息。如果你想在如何关闭套接字上有多一点的控制，你可以使用函数 shutdown()。它允许你将一定方向上的通讯或者双向的通讯(就象close()一样)关闭，你可以使用：
```
 int shutdown(int sockfd, int how);	 
```
sockfd 是你想要关闭的套接字文件描述复。how 的值是下面的其中之一：

0 – 不允许接受

1 – 不允许发送

2 – 不允许发送和接受(和 close() 一样)

shutdown() 成功时返回 0，失败时返回 -1(同时设置 errno。) 如果在无连接的数据报套接字中使用shutdown()，那么只不过是让 send() 和 recv() 不能使用(记住你在数据报套接字中使用了 connect 后是可以使用它们的)。
getpeername()函数

这个函数太简单了。它太简单了，以至我都不想单列一章。但是我还是这样做了。函数 getpeername() 告诉你在连接的流式套接字上谁在另外一边。函数是这样的：
```
 #include <sys/socket.h>
 
 int getpeername(int sockfd, struct sockaddr *addr, int *addrlen);
```
sockfd 是连接的流式套接字的描述符。addr 是一个指向结构 struct sockaddr (或者是 struct sockaddr_in) 的指针，它保存着连接的另一边的信息。addrlen 是一个 int 型的指针，它初始化为 sizeof(struct sockaddr)。函数在错误的时候返回 -1，设置相应的 errno。

一旦你获得它们的地址，你可以使用 inet_ntoa() 或者 gethostbyaddr() 来打印或者获得更多的信息。但是你不能得到它的帐号。(如果它运行着愚蠢的守护进程，这是可能的，但是它的讨论已经超出了本文的范围，请参考 RFC-1413 以获得更多的信息。)
gethostname()函数

甚至比 getpeername() 还简单的函数是 gethostname()。它返回你程序所运行的机器的主机名字。然后你可以使用 gethostbyname() 以获得你的机器的 IP 地址。

下面是定义：
```
 #include <unistd.h>
 
 int gethostname(char *hostname, size_t size);
```
参数很简单：hostname 是一个字符数组指针，它将在函数返回时保存主机名。size是hostname 数组的字节长度。

函数调用成功时返回 0，失败时返回 -1，并设置 errno。
域名服务（DNS）

如果你不知道 DNS 的意思，那么我告诉你，它代表域名服务(Domain Name Service)。它主要的功能是：你给它一个容易记忆的某站点的地址，它给你 IP 地址(然后你就可以使用 bind(), connect(), sendto() 或者其它函数) 。当一个人输入：
```
  $ telnet whitehouse.gov
```
telnet 能知道它将连接 (connect()) 到 “198.137.240.100”。但是这是如何工作的呢? 你可以调用函数 gethostbyname()：
```
 #include <netdb.h>
 
 struct hostent *gethostbyname(const char *name);
```
很明白的是，它返回一个指向 struct hostent 的指针。这个数据结构是这样的：
```
 struct hostent {
 
 　　char *h_name;
 
 　　char **h_aliases;
 
 　　int h_addrtype;
 
 　　int h_length;
 
 　　char **h_addr_list;
 
 };  



 #define h_addr h_addr_list[0]
```
这里是这个数据结构的详细资料：
```
 h_name – 地址的正式名称。
 
 h_aliases – 空字节-地址的预备名称的指针。
 
 h_addrtype –地址类型; 通常是AF_INET。
 
 h_length – 地址的比特长度。
 
 h_addr_list – 零字节-主机网络地址指针。网络字节顺序。
 
 h_addr - h_addr_list中的第一地址。
```
gethostbyname() 成功时返回一个指向结构体 hostent 的指针，或者是个空 (NULL) 指针。(但是和以前不同，不设置errno，h_errno 设置错误信息，请看下面的 herror()。) 但是如何使用呢? 有时候（我们可以从电脑手册中发现），向读者灌输信息是不够的。这个函数可不象它看上去那么难用。

这里是个例子：
```
 #include <stdio.h>
 
 #include <stdlib.h>
 
 #include <errno.h>
 
 #include <netdb.h>
 
 #include <sys/types.h>
 
 #include <netinet/in.h>
 
 int main(int argc, char *argv[])
 
 {
 
 　　struct hostent *h;
 
 　　if (argc != 2) { /* 检查命令行 */
 
 　　fprintf(stderr,"usage: getip address\n");
 
 　　exit(1);
 
 　　}
 
 　　if ((h=gethostbyname(argv[1])) == NULL) { /* 取得地址信息 */
 
 　　herror("gethostbyname");
 
 　　exit(1);
 
 　　}
 
 　　printf("Host name : %s\n", h->h_name);
 
 　　printf("IP Address : %s\n",inet_ntoa(*((struct in_addr *)h->h_addr)));
 
 return 0;
 
 }
```
在使用 gethostbyname() 的时候，你不能用 perror() 打印错误信息 (因为 errno 没有使用)，你应该调用 herror()。

相当简单，你只是传递一个保存机器名的字符串(例如 “whitehouse.gov”) 给 gethostbyname()，然后从返回的数据结构 struct hostent 中获取信息。

唯一也许让人不解的是输出 IP 地址信息。h->h_addr 是一个 char *，但是 inet_ntoa() 需要的是 struct in_addr。因此，我转换 h->h_addr 成 struct in_addr *，然后得到数据。

C++多线程

多线程是多任务处理的一种特殊形式，多任务处理允许让电脑同时运行两个或两个以上的程序。一般情况下，两种类型的多任务处理：基于进程和基于线程。

基于进程的多任务处理是程序的并发执行。
基于线程的多任务处理是同一程序的片段的并发执行。

多线程程序包含可以同时运行的两个或多个部分。这样的程序中的每个部分称为一个线程，每个线程定义了一个单独的执行路径。

本教程假设您使用的是 Linux 操作系统，我们要使用 POSIX 编写多线程 C++ 程序。POSIX Threads 或 Pthreads 提供的 API 可在多种类 Unix POSIX 系统上可用，比如 FreeBSD、NetBSD、GNU/Linux、Mac OS X 和 Solaris。

创建线程

下面的程序，我们可以用它来创建一个 POSIX 线程：

#include <pthread.h>
pthread_create (thread, attr, start_routine, arg)

在这里，pthread_create 创建一个新的线程，并让它可执行。下面是关于参数的说明：

参数	描述
thread	指向线程标识符指针。
attr	一个不透明的属性对象，可以被用来设置线程属性。您可以指定线程属性对象，也可以使用默认值 NULL。
start_routine	线程运行函数起始地址，一旦线程被创建就会执行。
arg	运行函数的参数。它必须通过把引用作为指针强制转换为 void 类型进行传递。如果没有传递参数，则使用 NULL。

创建线程成功时，函数返回 0，若返回值不为 0 则说明创建线程失败。
终止线程

使用下面的程序，我们可以用它来终止一个 POSIX 线程：

#include <pthread.h>
pthread_exit (status)

在这里，pthread_exit 用于显式地退出一个线程。通常情况下，pthread_exit() 函数是在线程完成工作后无需继续存在时被调用。

如果 main() 是在它所创建的线程之前结束，并通过 pthread_exit() 退出，那么其他线程将继续执行。否则，它们将在 main() 结束时自动被终止。

实例

#include <iostream>
#include <cstdlib>
#include <pthread.h>
 
using namespace std;
 
#define NUM_THREADS     5
 
void *PrintHello(void *threadid)
{  
   // 对传入的参数进行强制类型转换，由无类型指针变为整形数指针，然后再读取
   int tid = *((int*)threadid);
   cout << "Hello Runoob! 线程 ID, " << tid << endl;
   pthread_exit(NULL);
}
 
int main ()
{
   pthread_t threads[NUM_THREADS];
   int indexes[NUM_THREADS];// 用数组来保存i的值
   int rc;
   int i;
   for( i=0; i < NUM_THREADS; i++ ){      
      cout << "main() : 创建线程, " << i << endl;
      indexes[i] = i; //先保存i的值
      // 传入的时候必须强制转换为void* 类型，即无类型指针        
      rc = pthread_create(&threads[i], NULL, 
                          PrintHello, (void *)&(indexes[i]));
      if (rc){
         cout << "Error:无法创建线程," << rc << endl;
         exit(-1);
      }
   }
   pthread_exit(NULL);
}

向线程传递参数

这个实例演示了如何通过结构传递多个参数。您可以在线程回调中传递任意的数据类型，因为它指向 void，如下面的实例所示：

实例

 #include <iostream>
 #include <cstdlib>
 #include <pthread.h>
  
 using namespace std;
  
 #define NUM_THREADS     5
  
 struct thread_data{
    int  thread_id;
    char *message;
 };
  
 void *PrintHello(void *threadarg)
 {
    struct thread_data *my_data;
  
    my_data = (struct thread_data *) threadarg;
  
    cout << "Thread ID : " << my_data->thread_id ;
    cout << " Message : " << my_data->message << endl;
  
    pthread_exit(NULL);
 }
  
 int main ()
 {
    pthread_t threads[NUM_THREADS];
    struct thread_data td[NUM_THREADS];
    int rc;
    int i;
  
    for( i=0; i < NUM_THREADS; i++ ){
       cout <<"main() : creating thread, " << i << endl;
       td[i].thread_id = i;
       td[i].message = (char*)"This is message";
       rc = pthread_create(&threads[i], NULL,
                           PrintHello, (void *)&td[i]);
       if (rc){
          cout << "Error:unable to create thread," << rc << endl;
          exit(-1);
       }
    }
    pthread_exit(NULL);
 }

当上面的代码被编译和执行时，它会产生下列结果：

 $ g++ -Wno-write-strings test.cpp -lpthread -o test.o
 $ ./test.o
 main() : creating thread, 0
 main() : creating thread, 1
 Thread ID : 0 Message : This is message
 main() : creating thread, Thread ID : 21
  Message : This is message
 main() : creating thread, 3
 Thread ID : 2 Message : This is message
 main() : creating thread, 4
 Thread ID : 3 Message : This is message
 Thread ID : 4 Message : This is message

连接和分离线程

我们可以使用以下两个函数来连接或分离线程：

pthread_join (threadid, status) 
pthread_detach (threadid)

pthread_join() 子程序阻碍调用程序，直到指定的 threadid 线程终止为止。当创建一个线程时，它的某个属性会定义它是否是可连接的（joinable）或可分离的（detached）。只有创建时定义为可连接的线程才可以被连接。如果线程创建时被定义为可分离的，则它永远也不能被连接。

这个实例演示了如何使用 pthread_join() 函数来等待线程的完成。

实例

#include <iostream>
#include <cstdlib>
#include <pthread.h>
#include <unistd.h>
 
using namespace std;
 
#define NUM_THREADS     5
 
void *wait(void *t)
{
   int i;
   long tid;
 
   tid = (long)t;
 
   sleep(1);
   cout << "Sleeping in thread " << endl;
   cout << "Thread with id : " << tid << "  ...exiting " << endl;
   pthread_exit(NULL);
}
 
int main ()
{
   int rc;
   int i;
   pthread_t threads[NUM_THREADS];
   pthread_attr_t attr;
   void *status;
 
   // 初始化并设置线程为可连接的（joinable）
   pthread_attr_init(&attr);
   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 
   for( i=0; i < NUM_THREADS; i++ ){
      cout << "main() : creating thread, " << i << endl;
      rc = pthread_create(&threads[i], NULL, wait, (void *)&i );
      if (rc){
         cout << "Error:unable to create thread," << rc << endl;
         exit(-1);
      }
   }
 
   // 删除属性，并等待其他线程
   pthread_attr_destroy(&attr);
   for( i=0; i < NUM_THREADS; i++ ){
      rc = pthread_join(threads[i], &status);
      if (rc){
         cout << "Error:unable to join," << rc << endl;
         exit(-1);
      }
      cout << "Main: completed thread id :" << i ;
      cout << "  exiting with status :" << status << endl;
   }
 
   cout << "Main: program exiting." << endl;
   pthread_exit(NULL);
}

当上面的代码被编译和执行时，它会产生下列结果：

 main() : creating thread, 0
 main() : creating thread, 1
 main() : creating thread, 2
 main() : creating thread, 3
 main() : creating thread, 4
 Sleeping in thread 
 Thread with id : 4  ...exiting 
 Sleeping in thread 
 Thread with id : 3  ...exiting 
 Sleeping in thread 
 Thread with id : 2  ...exiting 
 Sleeping in thread 
 Thread with id : 1  ...exiting 
 Sleeping in thread 
 Thread with id : 0  ...exiting 
 Main: completed thread id :0  exiting with status :0
 Main: completed thread id :1  exiting with status :0
 Main: completed thread id :2  exiting with status :0
 Main: completed thread id :3  exiting with status :0
 Main: completed thread id :4  exiting with status :0
 Main: program exiting.