网上看到的程序，觉得挺适用的，转载了。。。已经过验证，是可以正确运行的

服务器socket绑定一个端口，然后等待客户机的接入。

客户端socket去连服务器和一个特定端口，连接成功后即可进行通信，发送字符串。

客户端代码：

1. #include <iostream>   
2. #include <string>   
3. #include <winsock2.h>   
4. #pragma comment(lib,"ws2_32.lib")   
5. using namespace std;   
6.   
7. int main()   
8. {      
9.      cout<<"客户端启动"<<endl;   
10.     //初始化winsock   
11.      WSADATA wsaD;   
12.      WSAStartup(MAKEWORD(1,1),&wsaD);   
13.     //创建客户端socket   
14.      SOCKET sclient=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);   
15.     //连接服务器   
16.     struct sockaddr_in servaddr;   
17.      servaddr.sin_family=AF_INET;   
18.      servaddr.sin_addr.s_addr=inet_addr("10.0.70.37"); //指定服务器   
19.      servaddr.sin_port=htons(8080);             //指定端口   
20.      cout<<"确实要建立连接？ yes/no"<<endl;   
21.     char flag[3];   
22.      gets(flag);   
23.     if(strcmp(flag,"yes")==0)   
24.      {   
25.        connect(sclient,(struct sockaddr*)&servaddr,sizeof(servaddr)); //通过套接字连接主机   
26.      }                    
27.               
28.     //发送数据   
29.     char buf[500];   
30.      cout<<"输入发送内容：";   
31.     while(cin.getline(buf,500))   
32.      {   
33.      //通过套接字给主机发送字符串   
34.       send(sclient,buf,strlen(buf)+1,0);  //字符串还有个结束标志，     
35.      }   
36.     return 0;   
37. }  
38. 1. #include <iostream>   
    2. #include <string>   
    3. #include <winsock2.h>   
    4. #pragma comment(lib,"ws2_32.lib")   
    5. using std::cout;   
    6. using std::cin;   
    7. using std::string;   
    8. using std::endl;   
    9.    
    10. int main()   
    11. {   
    12.      cout<<"服务器启动！....."<<endl;   
    13.     //初始化winsock   
    14.       WSADATA wsaD;   
    15.       WSAStartup(MAKEWORD(1,1),&wsaD);   
    16.     //创建监听套接字   
    17.      SOCKET slisten=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);   
    18.     // 绑定主机地址和监听套接字   
    19.     struct sockaddr_in my_addr;   //主机地址   
    20.      my_addr.sin_family=AF_INET;   
    21.      my_addr.sin_port=htons(8080); //指定端口   
    22.      my_addr.sin_addr.s_addr=htonl(INADDR_ANY);   
    23.      bind(slisten,(struct sockaddr *)&my_addr,sizeof(my_addr));   
    24.     //启动监听   
    25.      listen(slisten,5);   
    26.     //开始接收数据   
    27.     struct sockaddr_in c_addr;  //客户地址   
    28.     int addr_len=sizeof(c_addr);   
    29.      SOCKET sconnect=accept(slisten,(struct sockaddr*)&c_addr,&addr_len); //通过监听套接字创建连接套接字   
    30.      cout<<"连接已建立......"<<endl;   
    31.     while(true)   
    32.      {     
    33.        char buf[500]; //存储接收的字符   
    34.        int len=recv(sconnect,buf,sizeof(buf),0);  //通过连接套接字接收数据   
    35.        if(len>0)   
    36.         {   
    37.            cout<<"客户说："<<buf<<endl;   
    38.         }   
    39.      }   
    40.     return 0;   
    41. }  
    42. 1. #include <iostream>   
        2. #include <string>   
        3. #include <winsock2.h>   
        4. #pragma comment(lib,"ws2_32.lib")   
        5. using std::cout;   
        6. using std::cin;   
        7. using std::string;   
        8. using std::endl;   
        9.    
        10. int main()   
        11. {   
        12.      cout<<"服务器启动！....."<<endl;   
        13.     //初始化winsock   
        14.       WSADATA wsaD;   
        15.       WSAStartup(MAKEWORD(1,1),&wsaD);   
        16.     //创建监听套接字   
        17.      SOCKET slisten=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);    
        18.     // 绑定主机地址和监听套接字   
        19.     struct sockaddr_in my_addr;   //主机地址   
        20.      my_addr.sin_family=AF_INET;   
        21.      my_addr.sin_port=htons(8080); //指定端口   
        22.      my_addr.sin_addr.s_addr=htonl(INADDR_ANY);   
        23.      bind(slisten,(struct sockaddr *)&my_addr,sizeof(my_addr));   
        24.     //启动监听   
        25.      listen(slisten,5);    //5是最大连接数
        26.     //开始接收数据   
        27.     struct sockaddr_in c_addr;  //客户地址   
        28.     int addr_len=sizeof(c_addr);   
        29.      SOCKET sconnect=accept(slisten,(struct sockaddr*)&c_addr,&addr_len); //通过监听套接字创建连接套接字   
        30.      cout<<"连接已建立......"<<endl;   
        31.     while(true)   
        32.      {     
        33.        char buf[500]; //存储接收的字符   
        34.        int len=recv(sconnect,buf,sizeof(buf),0);  //通过连接套接字接收数据   
        35.        if(len>0)   
        36.         {   
        37.            cout<<"客户说："<<buf<<endl;   
        38.         }   
        39.      }   
        40.     return 0;   
        41. }  
        42. 在创建socket之前要调用WSAStartup(MAKEWORD(1,1),&wsad);

            这个函数说明使用的版本是1.1版的，wsad存储系统返回的winsocket信息。

             

            创建socket 调用socket(int af,int type,int protocol) af不清楚，type有SOCK_STREAM(tcp),SOCK_DGRAM(udp)

            protocol :通信协议(默认为0)

             

            绑定端口，调用函数bind(SOCKET S,stuct sockaddr *name,int namelen),

            S为监听socket,name为主机地址（里面指定了端口） ，namelen为地址变量长度。

             

            接下来使服务器处于监听状态，调用函数listen(SOCKET s,int backlog)

            s为监听socket, backlog为最大连接数，最大为5.

             

            客户机连进来后就可通信了，但还要创建一个连接socket.调用accept(SOCKET S,struct sockaddr *addr int *addrlen);

            s为监听socket,addr用来存放客户地址，addrlen为长度，然后返回连接socket.

            这一步后就可以利用连接socket接收数据了，调用recv(SOCKET s,char *buf,int len,int flags).

            s为连接socket,buf来存放接收数据，他为一个字符数组首地址。len为buf的最大长度，不是buf的实际长度，flags为此函数调用的方式

             

            1.   
            2. bool my_recv(SOCKET socket,char *buf,int length,int flag){   
            3.      int recv_len = 0;   
            4.      short index = 0;   
            5.      while( length > 0 ){   
            6.         recv_len = recv(socket,&buf[index],length,flag);   
            7.         index = index + recv_len;   
            8.         length = length - recv_len;   
            9.       }   
            10.         
            11.      if( 0 == recv_len ){   
            12.         return true;       
            13.       }else{   
            14.         return false;   
            15.       }   
            16. }