网络编程：实现计算器程序的服务器端/客户端(包含+ - * / %)

2021-08-03 21:53:56

一、实验目的

  1. 熟悉应用层协议的制定，并依据协议规则编写程序。
  2. 在Linux和Windows操作系统上编写计算器服务器端/客户端。让服务器端从客户端接收数字和运算符信息，并将计算结果传回客户端。

二、实验内容

  1. 参考“TCP/IP网络编程”第5章计算器程序示例，在Linux操作系统上编写程序，实现计算器服务器端/客户端。可以根据第87页协议编写程序，也可以在此基础上修改协议规则，例如增加除法运算，操作数和结果不一定是整数等。
  2. 在Windows操作系统上编写程序，实现与上述功能相同的计算器服务器端/客户端。基于Windows的实现同样可以修改计算器程序的协议内容。

实验结果

修改后协议内容：

应用层协议：

  • 客户端连接到服务器端后以1字节整数形式传递运算数个数
  • 客户端向服务器端传递的每个待算整数占4字节
  • 传递待算数后传递运算符，运算符占1字节
  • 选择字符+、-、*、/、%之一传递
  • 服务器端以4字节整数形式向客户端传输运算结果
  • 客户端得到结果后保持与服务器端的连接，直至运算数个数输入0终止

Linux端效果图如下：

Linux端的（采用UOS+VScode+g++）
网络编程：实现计算器程序的服务器端/客户端(包含+ - * / %)

Linux端代码如下：

1. 服务器端：
#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/in.h>
#pragma comment (lib, "ws2_32.lib") //加载 ws2_32.dll

#define BUF_SIZE 1024
using namespace std;
int operate(int opnum, int opnds[], char oprator);
int main(){
int strlen;
int result;
int recv_cnt =-1, recv_len = -1;
//创建套接字
int serv_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
//将套接字和IP、端口绑定
struct sockaddr_in serv_addr;
memset(&serv_addr, 0, sizeof(serv_addr)); //每个字节都用0填充
serv_addr.sin_family = AF_INET; //使用IPv4地址
serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1"); //具体的IP地址
serv_addr.sin_port = htons(1234); //端口
bind(serv_sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
//进入监听状态，等待用户发起请求
listen(serv_sock, 20);
//接收客户端请求
char buffer[BUF_SIZE]; //缓冲区
for(int i=0;i<5;i++){
struct sockaddr_in clnt_addr;
socklen_t clnt_addr_size = sizeof(clnt_addr);
int clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_addr, &clnt_addr_size);
if (clnt_sock == -1)
cout<<"accept() error!"<<endl;
else
cout<<"已连接客户端："<<i + 1<<endl;
while(1){
int opnd_cnt = 0;
read(clnt_sock ,&opnd_cnt, 1); //首先获取操作数个数
recv_len = 0;
while( (opnd_cnt*4+1) > recv_len) //循环读取直到完全接收所有数据，read有多少读多少，且TCP不存在数据边界！
{ //或者说TCP是一种字节流
recv_cnt = read(clnt_sock, &buffer[recv_len], BUF_SIZE-1);
recv_len += recv_cnt;
}
result = operate(opnd_cnt, (int*)buffer, buffer[recv_len - 1]);
write(clnt_sock,(char*)&result,sizeof(result)); //将结果返回，如果除数为0，结果也是0
}
close(clnt_sock); //关闭套接字
memset(buffer, 0, BUF_SIZE); //重置缓冲区
}
//关闭套接字
close(serv_sock);
return 0;
}
int operate(int opnum, int opnds[], char oprator)
{
int result = opnds[0];
int i = 0;
switch(oprator)
{
case '+':
for(i=1; i<opnum; i++) {
result += opnds[i]; 
}
break;
case '-':
for(i=1; i<opnum; i++) result -= opnds[i]; 
break;
case '*':
for(i=1; i<opnum; i++) result *= opnds[i]; 
break;
case '/':
for(i=1; i<opnum; i++){
if(opnds[i]==0){
result=0;
break;
}
result /= opnds[i];
}
break;
case '%':
for(i=1; i<opnum; i++) result %= opnds[i]; 
break;
}
return result;
}
2. 客户端：
#include <iostream>
#include <cstring>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#define BUFFER_SIZE 1024
using namespace std;
int main(){
//设置套接字相关属性
struct sockaddr_in sock_addr;
memset(&sock_addr,0,sizeof(sock_addr));
sock_addr.sin_family = AF_INET;
sock_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
sock_addr.sin_port = htons(1234);

//发送缓冲区和接收缓冲区
char bufSend[BUFFER_SIZE];
int result;
int num;
//创建套接字
int sock = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
connect(sock,(struct sockaddr*)&sock_addr,sizeof(sock_addr));
while(1){
//输入
cout<<"这里是Linux端计算器客户端,请输入待运算数字个数(输入0,退出客户端)"<<endl;
cin>>num;
if(num==0)
break;
bufSend[0]=num;
//操作数(每个占4字节)
for (int i = 0; i < num; i++) {
cout<<"请输入第"<<i+1<<"运算数："<<endl;
scanf("%d", (int *)&bufSend[i * 4 + 1]);
}
//运算符(占1字节)
cout<<"请输入运算符(+-*/%)："<<endl;
cin>>bufSend[num*4+1];
//发送数据到服务端
write(sock,bufSend,num*4+2);
//从服务端接收数据并打印
read(sock, &result, 4);
cout<<"服务器返回计算结果："<<result<<endl;
// //清空缓冲区
// memset(bufSend,0,BUFFER_SIZE);
// memset(bufRecv,0,BUFFER_SIZE);
//关闭套接字
}
close(sock);
return 0;
}

Windows端效果图如下：

网络编程：实现计算器程序的服务器端/客户端(包含+ - * / %)

Windows端代码如下：

1. 服务器端：
#include <iostream>
#include <winsock2.h>
#pragma comment (lib, "ws2_32.lib")  //加载 ws2_32.dll

#define BUF_SIZE 1024
using namespace std;
int operate(int opnum, int opnds[], char oprator);
int main(){
    int strLen;
    int result;//计算结果
    int recv_cnt =-1, recv_len = -1;
    WSADATA wsaData;
    WSAStartup( MAKEWORD(2, 2), &wsaData);

    //创建套接字
    SOCKET servSock = socket(AF_INET, SOCK_STREAM, 0);

    //绑定套接字
    sockaddr_in sockAddr;
    memset(&sockAddr, 0, sizeof(sockAddr));  //每个字节都用0填充
    sockAddr.sin_family = PF_INET;  //使用IPv4地址
    sockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");  //具体的IP地址
    sockAddr.sin_port = htons(1234);  //端口
    bind(servSock, (SOCKADDR*)&sockAddr, sizeof(SOCKADDR));

    //进入监听状态
    listen(servSock, 20);

    //接收客户端请求
    SOCKADDR clntAddr;
    int nSize = sizeof(SOCKADDR);
    char buffer[BUF_SIZE];  //缓冲区
    for(int i=0;i<5;i++){
       SOCKET clntSock = accept(servSock, (SOCKADDR*)&clntAddr, &nSize);
       if (clntSock == -1)
            cout<<"accept() error!"<<endl;
        else
            cout<<"已连接客户端："<<i + 1<<endl;

       while(1){
           int opnd_cnt = 0;
           recv(clntSock, (char*)&opnd_cnt, 1, 0);//首先获取操作数个数
           recv_len = 0;
           while( (opnd_cnt*4+1) > recv_len) //循环读取直到完全接收所有数据，read有多少读多少，且TCP不存在数据边界！
                { //或者说TCP是一种字节流
                   recv_cnt = recv(clntSock, &buffer[recv_len], BUF_SIZE-1,0);
                   recv_len += recv_cnt;
                }
           result = operate(opnd_cnt, (int*)buffer, buffer[recv_len - 1]);

            send(clntSock,(char*)&result,sizeof(result),0); //将结果返回，如果除数为0，结果也是0

          }
        closesocket(clntSock);  //关闭套接字
        memset(buffer, 0, BUF_SIZE);  //重置缓冲区
    }

    //关闭套接字
    closesocket(servSock);

    //终止 DLL 的使用
    WSACleanup();
    system("Pause");
    return 0;
}
int operate(int opnum, int opnds[], char oprator)
{
int result = opnds[0];
int i = 0;
switch(oprator)
{
case '+':
for(i=1; i<opnum; i++) {
result += opnds[i]; 
}
break;
case '-':
for(i=1; i<opnum; i++) result -= opnds[i]; 
break;
case '*':
for(i=1; i<opnum; i++) result *= opnds[i]; 
break;
case '/':
for(i=1; i<opnum; i++){
if(opnds[i]==0){
result=0;
break;
}
result /= opnds[i];
}
break;
case '%':
for(i=1; i<opnum; i++) result %= opnds[i]; 
break;
}
return result;
}
2. 客户端
#include <iostream>
#include <WinSock2.h>
#include <windows.h>
#pragma comment(lib, "ws2_32.lib")  //加载 ws2_32.dll

#define BUF_SIZE 1024
using namespace std;
int main(){
    //初始化DLL
    WSADATA wsaData;
    WSAStartup(MAKEWORD(2, 2), &wsaData);

    //向服务器发起请求
    sockaddr_in sockAddr;
    memset(&sockAddr, 0, sizeof(sockAddr));  //每个字节都用0填充
    sockAddr.sin_family = PF_INET;
    sockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    sockAddr.sin_port = htons(1234);
   
    //发送缓冲区和接收缓冲区
    char bufSend[BUF_SIZE];
    int result;
    int num;
    
        //创建套接字
        SOCKET sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
        connect(sock, (SOCKADDR*)&sockAddr, sizeof(SOCKADDR));
    while(1){
        //获取用户输入的字符串并发送给服务器
        cout<<"这里是Linux端计算器客户端,请输入待运算数字个数(输入0,退出客户端)"<<endl;
        cin>>num;
        if(num==0)
           break;
        bufSend[0]=num;
        //操作数(每个占4字节)
        for (int i = 0; i < num; i++) {
             cout<<"请输入第"<<i+1<<"运算数："<<endl;
             scanf("%d", (int *)&bufSend[i * 4 + 1]);
        }
        //运算符(占1字节)
        cout<<"请输入运算符(+-*/%)："<<endl;
        cin>>bufSend[num*4+1];

        //发送数据到服务端
        send(sock, bufSend, num*4+2, 0);
        //接收服务器传回的数据
        recv(sock, (char*)&result, 4, 0);
        //输出接收到的数据
        cout<<"服务器返回消息: "<<result<<endl;
        memset(bufSend, 0, BUF_SIZE);  //重置缓冲区
        //memset(bufRecv, 0, BUF_SIZE);  //重置缓冲区
    }
    closesocket(sock);  //关闭套接字
    WSACleanup();  //终止使用 DLL
    system("Pause");
    return 0;
}
上一篇：C语言网络编程——TCP


下一篇：Liunx系统编程之网络编程——socket