碼上歡樂
相關內容    簡體    繁體

Linux下的C++ socket編程實例

本文轉載自   查看原文   2018-10-02 17:38   12864    網絡編程

閱讀目錄

  • 　　基本的局域網聊天
  • 　　客戶端服務端雙向異步聊天源碼
  • 　　局域網內服務端和有限個客戶端聊天源碼
  • 　　完美異步聊天服務端和客戶端源碼
  • 　　C++定時器
  • 　　select異步代碼
  • 　　pthead多線程

服務端：
　　服務器端先初始化socket，然后與端口綁定，對端口進行監聽，調用accept阻塞，等待客戶端連接。
　　socket() -> bind() -> listen() -> accept()
客戶端：
　　客戶端先初始化socket，然后與服務端連接，服務端監聽成功則連接建立完成
　　socket() -> connect()

socket的大概過程是這樣的：

　　服務端先創建一個套接字，端口綁定，對端口進行監聽，調用accpet阻塞，等待客戶端連接。客戶端創建一個套接字，然后通過三次握手完成tcp連接后服務端accpet返回重新建立一個套接字代表返回客戶端的tcp連接，（在accpet成功返回前有一個要注意的是server會有兩個隊列，一個存放完成三次握手的一個是未完成三次握手的，每次accpet會從完成三次握手的隊列中取出一個並一直建立TCP連接，此時才能算是真正的連接成功），完成上面的步驟后即可以開始數據的傳輸了，數據傳輸結束后再調用close關閉連接

　　此外再說一下select函數在server和client雙向通信中的重要作用：網絡編程的過程中，經常會遇到許多阻塞的函數，網絡編程時使用的recv, recvfrom、connect函數都是阻塞的函數，當函數不能成功執行的時候，程序就會一直阻塞在這里，無法執行下面的代碼。selcet函數是一個輪循函數，即當循環詢問文件節點，可設置超時時間，超時時間到了就跳過代碼繼續往下執行，就像我們下面的第一個程序一樣，如果不注釋掉server的send那么如果server不想client發送消息則進程就會停頓在此處等待server發送無法執行下面的代碼，無法接受client發送過來的消息，第二個程序就對此進行的改進，在程序中引入了select當超時后就會跳過當前代碼，執行下一步不會一直阻塞。（poll和epoll是對select的改進）

 

TCP編程的服務器端一般步驟是： UDP編程的服務器端一般步驟是：

1、創建一個socket，用函數socket()； 　　

2、設置socket屬性，用函數setsockopt(); * 可選 

3、綁定IP地址、端口等信息到socket上，用函數bind(); 　

4、開啟監聽，用函數listen()； 　　

5、接收客戶端上來的連接，用函數accept()；

6、收發數據，用函數send()和recv()，或者read()和write(); 　　

7、關閉網絡連接； 　　

8、關閉監聽；

1、創建一個socket，用函數socket()； 　

2、設置socket屬性，用函數setsockopt();* 可選 　　

3、綁定IP地址、端口等信息到socket上，用函數bind();

4、循環接收數據，用函數recvfrom(); 

5、關閉網絡連接；
TCP編程的客戶端一般步驟是： 　UDP編程的客戶端一般步驟是：

1、創建一個socket，用函數socket()； 　　

2、設置socket屬性，用函數setsockopt();* 可選 　　

3、綁定IP地址、端口等信息到socket上，用函數bind();* 可選 　　

4、設置要連接的對方的IP地址和端口等屬性； 　　

5、連接服務器，用函數connect()； 

6、收發數據，用函數send()和recv()，或者read()和write(); 　　

7、關閉網絡連接；

1、創建一個socket，用函數socket()； 　　

2、設置socket屬性，用函數setsockopt();* 可選 　　

3、綁定IP地址、端口等信息到socket上，用函數bind();* 可選 　　

4、設置對方的IP地址和端口等屬性; 

5、發送數據，用函數sendto(); 　　6、關閉網絡連接；

基本的局域網聊天

局域網TCP服務端：

實現的功能是client到server的半雙工通信，server只能接受接收client發送過來的消息，但是不能向client發送消息。

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/shm.h>
#include <thread>
#include <iostream>
#define PORT 7000
#define QUEUE 20//連接請求隊列
int conn;
void thread_task() 
{
}

int main() 
{
   //printf("%d\n",AF_INET);//IPv4協議
    printf("%d\n",SOCK_STREAM);//字節流套接字
    int ss = socket(AF_INET, SOCK_STREAM, 0);//若成功則返回一個sockfd（套接字描述符）
    //printf("%d\n",ss);
    struct sockaddr_in server_sockaddr;//一般是儲存地址和端口的。用於信息的顯示及存儲使用
	/*設置 sockaddr_in 結構體中相關參數*/
    server_sockaddr.sin_family = AF_INET;
    server_sockaddr.sin_port = htons(PORT);//將一個無符號短整型數值轉換為網絡字節序，即大端模式(big-endian)　
    //printf("%d\n",INADDR_ANY);
	//INADDR_ANY就是指定地址為0.0.0.0的地址，這個地址事實上表示不確定地址，或“所有地址”、“任意地址”。
	//一般來說，在各個系統中均定義成為0值。
    server_sockaddr.sin_addr.s_addr = htonl(INADDR_ANY);//將主機的無符號長整形數轉換成網絡字節順序。　
    if(bind(ss, (struct sockaddr* ) &server_sockaddr, sizeof(server_sockaddr))==-1) 
	{
        perror("bind");
        exit(1);
    }
    if(listen(ss, QUEUE) == -1) 
	{
        perror("listen");
        exit(1);
    }

    struct sockaddr_in client_addr;
    socklen_t length = sizeof(client_addr);
    ///成功返回非負描述字，出錯返回-1
    conn = accept(ss, (struct sockaddr*)&client_addr, &length);
	//如果accpet成功，那么其返回值是由內核自動生成的一個全新描述符，代表與所返回客戶的TCP連接。
	//accpet之后就會用新的套接字conn
    if( conn < 0 ) 
	{
        perror("connect");
        exit(1);
    }

    char buffer[1024];
    //創建另外一個線程
    //std::thread t(thread_task);
    //t.join();
    //char buf[1024];
    //主線程
    while(1)
	{
	//這里把send注釋掉了，所以這個程序中server只能是接收client端的數據並能給client發送數據，即使不注釋掉也沒用，因為沒有對是否有數據傳入和傳入
　　　　　//進行判斷所以按照下面的代碼這樣寫，每次都要先讓server輸入后才能輸出client傳過來的數據，若是server不輸入則程序無法向下走就沒有client發送過來的輸出，
　　　　　//而且每次顯示也只能是一行，這樣顯示就全是錯的了，所以就需要select和FD_ISSET的判斷了
        // memset(buf, 0 ,sizeof(buf));
        // if(fgets(buf, sizeof(buf),stdin) != NULL) {
        //     send(conn, buf, sizeof(buf), 0);    
        // }

        memset(buffer, 0 ,sizeof(buffer));
        int len = recv(conn, buffer, sizeof(buffer), 0);//從TCP連接的另一端接收數據。
		/*該函數的第一個參數指定接收端套接字描述符；
		第二個參數指明一個緩沖區，該緩沖區用來存放recv函數接收到的數據；
		第三個參數指明buf的長度；
		第四個參數一般置0*/
        if(strcmp(buffer, "exit\n") == 0)//如果沒有收到TCP另一端發來的數據則跳出循環不輸出
		{
			break;
		}
        printf("%s", buffer);//如果有收到數據則輸出數據
        //必須要有返回數據， 這樣才算一個完整的請求
        send(conn, buffer, len , 0);//向TCP連接的另一端發送數據。
    }
    close(conn);//因為accpet函數連接成功后還會生成一個新的套接字描述符，結束后也需要關閉
    close(ss);//關閉socket套接字描述符
    return 0;
}

　　

　　

局域網TCP客戶端：

/*局域網TCP客戶端*/
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/shm.h>

#define MYPORT  7000
#define BUFFER_SIZE 1024

int main()
{
    ///定義sockfd
    int sock_cli = socket(AF_INET,SOCK_STREAM, 0);

    ///定義sockaddr_in
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(MYPORT);  //服務器端口
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");  //服務器ip，inet_addr用於IPv4的IP轉換（十進制轉換為二進制）
	//127.0.0.1是本地預留地址
    //連接服務器，成功返回0，錯誤返回-1
    if (connect(sock_cli, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
    {
        perror("connect");
        exit(1);
    }

    char sendbuf[BUFFER_SIZE];
    char recvbuf[BUFFER_SIZE];

    while (fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)
    {/*每次讀取一行，讀取的數據保存在buf指向的字符數組中，成功，則返回第一個參數buf；*/
        send(sock_cli, sendbuf, strlen(sendbuf),0); ///發送
        if(strcmp(sendbuf,"exit\n")==0)
            break;
        recv(sock_cli, recvbuf, sizeof(recvbuf),0); ///接收
        fputs(recvbuf, stdout);

        memset(sendbuf, 0, sizeof(sendbuf));//接受或者發送完畢后把數組中的數據全部清空（置0）
        memset(recvbuf, 0, sizeof(recvbuf));
    }
    close(sock_cli);
    return 0;
}
/*在TCP三次握手完成后會進入等待連接隊列，等待服務端調用accpet與之建立連接，這時候是server端調用accept跟客戶端建立
通信，客戶端並不需要調用accpet，因為有很多個客戶端要跟服務端建立連接，這時候服務端就會有一個隊列，對已經經過三次握
手的才可以建立連接（類似緩存信息），這個是由服務端來確認的，客戶端並不知道什么時候服務端才能跟它建立連接，在服務端
沒有調用accept與之連接或者還未排隊到它，只能是一直等待，直到服務端准備好了才能跟客戶端建立連接，所以主動權在服務端*/

　　

客戶端服務端雙向異步聊天源碼

以上的局域網聊天應用有一個很重要的缺點， 服務器只能顯示客戶端發送的消息， 卻無法給客戶端發送消息， 這個很尷尬；

通過使用C中的select()函數， 實現一個異步聊天工具：

異步聊天服務端代碼：

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/shm.h>
#include <iostream>
#define PORT 7000
#define QUEUE 20

int main() 
{
    fd_set rfds;
    struct timeval tv;
    int retval, maxfd;
    int ss = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in server_sockaddr;
    server_sockaddr.sin_family = AF_INET;
    server_sockaddr.sin_port = htons(PORT);
    //printf("%d\n",INADDR_ANY);
    server_sockaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    if(bind(ss, (struct sockaddr* ) &server_sockaddr, sizeof(server_sockaddr))==-1) 
	{
        perror("bind");
        exit(1);
    }
    if(listen(ss, QUEUE) == -1) 
	{
        perror("listen");
        exit(1);
    }

    struct sockaddr_in client_addr;
    socklen_t length = sizeof(client_addr);
    ///成功返回非負描述字，出錯返回-1
    int conn = accept(ss, (struct sockaddr*)&client_addr, &length);
	/*沒有用來存儲accpet返回的套接字的數組，所以只能實現server和單個client雙向通信*/
    if( conn < 0 ) 
	{
        perror("connect");
        exit(1);
    }
    while(1) 
	{
        /*把可讀文件描述符的集合清空*/
        FD_ZERO(&rfds);
        /*把標准輸入的文件描述符加入到集合中*/
        FD_SET(0, &rfds);
        maxfd = 0;
        /*把當前連接的文件描述符加入到集合中*/
        FD_SET(conn, &rfds);
        /*找出文件描述符集合中最大的文件描述符*/    
        if(maxfd < conn)
            maxfd = conn;
        /*設置超時時間*/
        tv.tv_sec = 5;//設置倒計時
        tv.tv_usec = 0;
        /*等待聊天*/
        retval = select(maxfd+1, &rfds, NULL, NULL, &tv);
        if(retval == -1)
		{
            printf("select出錯，客戶端程序退出\n");
            break;
        }
		else if(retval == 0)
		{
            printf("服務端沒有任何輸入信息，並且客戶端也沒有信息到來，waiting...\n");
            continue;
        }
		else
		{
            /*客戶端發來了消息*/
            if(FD_ISSET(conn,&rfds))
			{
                char buffer[1024];    
                memset(buffer, 0 ,sizeof(buffer));
                int len = recv(conn, buffer, sizeof(buffer), 0);
                if(strcmp(buffer, "exit\n") == 0) break;
                printf("%s", buffer);
                //send(conn, buffer, len , 0);把數據回發給客戶端
            }
            /*用戶輸入信息了,開始處理信息並發送*/
            if(FD_ISSET(0, &rfds))
			{
                char buf[1024];
                fgets(buf, sizeof(buf), stdin);
                //printf("you are send %s", buf);
                send(conn, buf, sizeof(buf), 0);    
            }
        }
    }
    close(conn);
    close(ss);
    return 0;
}

異步聊天客戶端代碼：

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/shm.h>

#define MYPORT  7000
#define BUFFER_SIZE 1024
int main()
{
    int sock_cli;
    fd_set rfds;
    struct timeval tv;
    int retval, maxfd;

    ///定義sockfd
    sock_cli = socket(AF_INET,SOCK_STREAM, 0);
    ///定義sockaddr_in
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(MYPORT);  ///服務器端口
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");  ///服務器ip

    //連接服務器，成功返回0，錯誤返回-1
    if (connect(sock_cli, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
    {
        perror("connect");
        exit(1);
    }

    while(1){
        /*把可讀文件描述符的集合清空*/
        FD_ZERO(&rfds);
        /*把標准輸入的文件描述符加入到集合中*/
        FD_SET(0, &rfds);
        maxfd = 0;
        /*把當前連接的文件描述符加入到集合中*/
        FD_SET(sock_cli, &rfds);
        /*找出文件描述符集合中最大的文件描述符*/    
        if(maxfd < sock_cli)
            maxfd = sock_cli;
        /*設置超時時間*/
        tv.tv_sec = 5;
        tv.tv_usec = 0;
        /*等待聊天*/
        retval = select(maxfd+1, &rfds, NULL, NULL, &tv);
        if(retval == -1)
		{
            printf("select出錯，客戶端程序退出\n");
            break;
        }
		else if(retval == 0)
		{
            printf("客戶端沒有任何輸入信息，並且服務器也沒有信息到來，waiting...\n");
            continue;
        }
		else
		{
            /*服務器發來了消息*/
            if(FD_ISSET(sock_cli,&rfds))
			{
                char recvbuf[BUFFER_SIZE];
                int len;
                len = recv(sock_cli, recvbuf, sizeof(recvbuf),0);
                printf("%s", recvbuf);
                memset(recvbuf, 0, sizeof(recvbuf));
            }
            /*用戶輸入信息了,開始處理信息並發送*/
            if(FD_ISSET(0, &rfds))
			{
                char sendbuf[BUFFER_SIZE];
                fgets(sendbuf, sizeof(sendbuf), stdin);
                send(sock_cli, sendbuf, strlen(sendbuf),0); //發送
                memset(sendbuf, 0, sizeof(sendbuf));
            }
        }
    }

    close(sock_cli);
    return 0;
}

　　

局域網內服務端和有限個客戶端聊天源碼

以上的局域網聊天只能支持一個用戶， 我們還要改改， 必須是支持多用戶的聊天室：

局域網TCP2人聊天服務端代碼

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/shm.h>
#include <iostream>
#include <thread>
#define PORT 7000
#define QUEUE 20
int ss;
struct sockaddr_in client_addr;
socklen_t length = sizeof(client_addr);
int conns[2] = {};//定義了一個容量為2的數組來存放套接字，所以server最多只能跟2個client通信
int z = 0;
void thread_fn() 
{
    //成功返回非負描述字，出錯返回-1
    int conn = accept(ss, (struct sockaddr*)&client_addr, &length);
    if( conn < 0 ) 
	{
        perror("connect");
        exit(1);
    }
    //把連接保存到臨時數組中;
    conns[z] = conn;
    z++;

    fd_set rfds;
    struct timeval tv;//linux編程中，如果用到計時，可以用struct timeval獲取系統時間
    int retval, maxfd;
    while(1) 
	{
        /*把可讀文件描述符的集合清空*/
        FD_ZERO(&rfds);
        /*把標准輸入的文件描述符加入到集合中*/
        FD_SET(0, &rfds);
        maxfd = 0;
        /*把當前連接的文件描述符加入到集合中*/
        FD_SET(conn, &rfds);
        /*找出文件描述符集合中最大的文件描述符*/    
        if(maxfd < conn)
		{
			maxfd = conn;
		}
        /*設置超時時間*/
        tv.tv_sec = 5;//5秒
        tv.tv_usec = 0;
        /*等待聊天*/
        retval = select(maxfd+1, &rfds, NULL, NULL, &tv);
        if(retval == -1)
		{
            printf("select出錯，客戶端程序退出\n");
            break;
        }
		else if(retval == 0)
		{
            printf("服務端沒有任何輸入信息，並且客戶端也沒有信息到來，waiting...\n");
            continue;
        }
		else
		{
            /*客戶端發來了消息*/
            if(FD_ISSET(conn,&rfds))//判斷conn是否在rfds中如果在返回非零，不再返回0
			{
                char buffer[1024];    
                memset(buffer, 0 ,sizeof(buffer));//把buffer中的所有值賦值為0，即清空buffer
                int len = recv(conn, buffer, sizeof(buffer), 0);//把接收到的數據存放於buffer中
                if(strcmp(buffer, "exit\n") == 0)//如果接受到的是空的，即沒有收到任何信息 
					break;
                printf("%s", buffer);
                //send(conn, buffer, len , 0);把數據回發給客戶端
            }
            /*用戶輸入信息了,開始處理信息並發送*/
            if(FD_ISSET(0, &rfds))
			{
                char buf[1024];
                fgets(buf, sizeof(buf), stdin);//每次讀取一行數據存放在buf中
                //printf("you are send %s", buf);
                for(int i=0; i<z; i++) 
				{
                    send(conns[i], buf, sizeof(buf), 0);
                }    
            }
        }
    }
    close(conn);
}
void thread_select(int conn) 
{
	
}
int main() 
{
    ss = socket(AF_INET, SOCK_STREAM, 0);//SOCK_STREAM即tcp協議，AF_INET是IPv4套接字
    struct sockaddr_in server_sockaddr;
    server_sockaddr.sin_family = AF_INET;
    server_sockaddr.sin_port = htons(PORT);
    //printf("%d\n",INADDR_ANY);
    server_sockaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    if(bind(ss, (struct sockaddr* ) &server_sockaddr, sizeof(server_sockaddr))==-1) 
	{
        perror("bind");
        exit(1);
    }
    if(listen(ss, QUEUE) == -1) 
	{
        perror("listen");
        exit(1);
    }
    std::thread t(thread_fn);//因為創建了兩個線程所以只能連接兩個client
    std::thread t1(thread_fn);//這里把收發數據都存放在thread_fn中，所以創建一個這樣的線程就能使得server能多連接一個server
    t.join();
    t1.join();
    close(ss);
    return 0;
}

局域網TCP2人聊天客戶端代碼：

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/shm.h>

#define MYPORT  7000
#define BUFFER_SIZE 1024
int main()
{
    int sock_cli;
    fd_set rfds;
    struct timeval tv;
    int retval, maxfd;

    ///定義sockfd
    sock_cli = socket(AF_INET,SOCK_STREAM, 0);
    ///定義sockaddr_in
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(MYPORT);  ///服務器端口
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");  ///服務器ip

    //連接服務器，成功返回0，錯誤返回-1
    if (connect(sock_cli, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
    {
        perror("connect");
        exit(1);
    }

    while(1){
        /*把可讀文件描述符的集合清空*/
        FD_ZERO(&rfds);
        /*把標准輸入的文件描述符加入到集合中*/
        FD_SET(0, &rfds);
        maxfd = 0;
        /*把當前連接的文件描述符加入到集合中*/
        FD_SET(sock_cli, &rfds);
        /*找出文件描述符集合中最大的文件描述符*/    
        if(maxfd < sock_cli)
            maxfd = sock_cli;
        /*設置超時時間*/
        tv.tv_sec = 5;
        tv.tv_usec = 0;
        /*等待聊天*/
        retval = select(maxfd+1, &rfds, NULL, NULL, &tv);
        if(retval == -1)
		{
            printf("select出錯，客戶端程序退出\n");
            break;
        }else if(retval == 0)
		{
            printf("客戶端沒有任何輸入信息，並且服務器也沒有信息到來，waiting...\n");
            continue;
        }
		else
		{
            /*服務器發來了消息*/
            if(FD_ISSET(sock_cli,&rfds))
			{
                char recvbuf[BUFFER_SIZE];
                int len;
                len = recv(sock_cli, recvbuf, sizeof(recvbuf),0);
                printf("%s", recvbuf);
                memset(recvbuf, 0, sizeof(recvbuf));
            }
            /*用戶輸入信息了,開始處理信息並發送*/
            if(FD_ISSET(0, &rfds))
			{
                char sendbuf[BUFFER_SIZE];
                fgets(sendbuf, sizeof(sendbuf), stdin);
                send(sock_cli, sendbuf, strlen(sendbuf),0); //發送
                memset(sendbuf, 0, sizeof(sendbuf));
            }
        }
    }

    close(sock_cli);
    return 0;
}

　　

完美異步聊天服務端和客戶端源碼

以上的多客戶聊天不是很好， 因為只允許兩個客戶端連接， 體驗非常差， 如果支持無限個客戶端聊天的話那該多好啊， 哈哈， 這個也是可以的， 我們只要使用c＋＋的list即可， 它是可以自增的數組(其實算是鏈表)， 引用 頭文件<list>即可：

無限個客戶聊天的 服務端代碼：

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/shm.h>
#include <iostream>
#include <thread>
#include <list>

#define PORT 7000
#define IP "127.0.0.1"

int s;
struct sockaddr_in servaddr;
socklen_t len;
std::list<int> li;//用list來存放套接字，沒有限制套接字的容量就可以實現一個server跟若干個client通信

void getConn() 
{
    while(1)
	{
        int conn = accept(s, (struct sockaddr*)&servaddr, &len);
        li.push_back(conn);
        printf("%d\n", conn);
    }
}

void getData() 
{
    struct timeval tv;
    tv.tv_sec = 10;//設置倒計時時間
    tv.tv_usec = 0;
    while(1) 
	{
        std::list<int>::iterator it;
        for(it=li.begin(); it!=li.end(); ++it)
		{            
            fd_set rfds;    
            FD_ZERO(&rfds);
            int maxfd = 0;
            int retval = 0;
            FD_SET(*it, &rfds);
            if(maxfd < *it)
			{
                maxfd = *it;
            }
            retval = select(maxfd+1, &rfds, NULL, NULL, &tv);
            if(retval == -1)
			{
                printf("select error\n");
            }
			else if(retval == 0) 
			{
                //printf("not message\n");
            }
			else
			{
                char buf[1024];
                memset(buf, 0 ,sizeof(buf));
                int len = recv(*it, buf, sizeof(buf), 0);
                printf("%s", buf);
            }
        }
        sleep(1);

    }
}

void sendMess() 
{
    while(1) 
	{
        char buf[1024];
        fgets(buf, sizeof(buf), stdin);
        //printf("you are send %s", buf);
        std::list<int>::iterator it;
        for(it=li.begin(); it!=li.end(); ++it)
		{
            send(*it, buf, sizeof(buf), 0);
        }
    }
}

int main() 
{
    //new socket
    s = socket(AF_INET, SOCK_STREAM, 0);
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(PORT);
    servaddr.sin_addr.s_addr = inet_addr(IP);
    if(bind(s, (struct sockaddr* ) &servaddr, sizeof(servaddr))==-1) 
	{
        perror("bind");
        exit(1);
    }
    if(listen(s, 20) == -1) 
	{
        perror("listen");
        exit(1);
    }
    len = sizeof(servaddr);

    //thread : while ==>> accpet
    std::thread t(getConn);
    t.detach();//detach的話后面的線程不同等前面的進程完成后才能進行，如果這里改為join則前面的線程無法判斷結束，就會
	//一直等待，導致后面的線程無法進行就無法實現操作
    //printf("done\n");
    //thread : input ==>> send
    std::thread t1(sendMess);
    t1.detach();
    //thread : recv ==>> show
    std::thread t2(getData);
    t2.detach();
    while(1)//做一個死循環使得主線程不會提前退出
	{

    }
    return 0;
}
/*這個跟前面的不一樣的地方是，把獲得連接套接字getConn和發送信息sendMess和接收信息getData放在三個函數中，創建
的三個線程分別對應處理三個函數，就可以使得server能跟若干個client通信*/

問：為什么要創建三個線程去處理三個函數，單個線程並不可以嗎，多線程和單線程處理起來有什么不同？

答：首先，這里用到多線程的目的是為了提高處理能力，減少等待時間，多線程可以並發執行，即可以同時對三個函數進行處理，處理起來會快很多。這里也是可以用單線程來處理的，但是單線程每次只能做一件事情，不能同時去獲得連接套接字、發送消息、接收消息，這樣在做其中一件事情的時候其他的兩件事情就要等待，這樣處理時間會比多線程慢很多。多線程可以及時的響應，單線程不能及時響應。

無限個客戶端連接的客戶端代碼：

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/shm.h>

#define MYPORT  7000
#define BUFFER_SIZE 1024
int main()
{
    int sock_cli;
    fd_set rfds;
    struct timeval tv;
    int retval, maxfd;

    ///定義sockfd
    sock_cli = socket(AF_INET,SOCK_STREAM, 0);
    ///定義sockaddr_in
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(MYPORT);  ///服務器端口
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");  ///服務器ip

    //連接服務器，成功返回0，錯誤返回-1
    if (connect(sock_cli, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
    {
        perror("connect");
        exit(1);
    }

    while(1){
        /*把可讀文件描述符的集合清空*/
        FD_ZERO(&rfds);
        /*把標准輸入的文件描述符加入到集合中*/
        FD_SET(0, &rfds);
        maxfd = 0;
        /*把當前連接的文件描述符加入到集合中*/
        FD_SET(sock_cli, &rfds);
        /*找出文件描述符集合中最大的文件描述符*/    
        if(maxfd < sock_cli)
            maxfd = sock_cli;
        /*設置超時時間*/
        tv.tv_sec = 10;
        tv.tv_usec = 0;
        /*等待聊天*/
        retval = select(maxfd+1, &rfds, NULL, NULL, &tv);
        if(retval == -1){
            printf("select出錯，客戶端程序退出\n");
            break;
        }else if(retval == 0){
            printf("客戶端沒有任何輸入信息，並且服務器也沒有信息到來，waiting...\n");
            continue;
        }else{
            /*服務器發來了消息*/
            if(FD_ISSET(sock_cli,&rfds)){
                char recvbuf[BUFFER_SIZE];
                int len;
                len = recv(sock_cli, recvbuf, sizeof(recvbuf),0);
                printf("%s", recvbuf);
                memset(recvbuf, 0, sizeof(recvbuf));
            }
            /*用戶輸入信息了,開始處理信息並發送*/
            if(FD_ISSET(0, &rfds)){
                char sendbuf[BUFFER_SIZE];
                fgets(sendbuf, sizeof(sendbuf), stdin);
                send(sock_cli, sendbuf, strlen(sendbuf),0); //發送
                memset(sendbuf, 0, sizeof(sendbuf));
            }
        }
    }

    close(sock_cli);
    return 0;
}

　　

-------------------------------------------------------------------------------------------------------------

局域網通過UDP實現服務端和客戶端的通信， UDP的服務端不需要執行listen函數和accept函數：

 


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 linux：C++的socket編程 linux：C++的socket編程 Linux C Socket編程原理及簡單實例 Linux C Socket編程原理及簡單實例 c++ linux socket編程 c++網絡編程 [C++] Linux TCP Socket 實例- 阻塞 c++ 網絡編程（五） LINUX下 socket編程 多種I/O函數 -以及readv和writev函數用法 【C++】socket編程（二）：最簡單的socket通信（下） Linux下C語言的socket網絡編程 C++ Socket 編程
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM