在线电子词典

最新推荐文章于 2024-08-26 15:26:59 发布
最新推荐文章于 2024-08-26 15:26:59 发布
阅读量53 收藏
点赞数
文章标签： 服务器 网络 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_60591214/article/details/128943385
版权

使用poll函数

登录注册功能，不能重复登录，重复注册

单词查询功能

历史记录功能，存储单词，意思，以及查询时间

基于TCP，支持多客户端连接

采用数据库保存用户信息与历史记录

将dict.txt的数据导入到数据库中保存。

客户端

#include "client.h"

int main(int argc, char const *argv[])
{
    if (argc != 3)
    {
        printf("please input %s <ip> <port>\n", argv[0]);
        return -1;
    }
    //1.创建套接字 socket
    int sockfd;
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket err.");
        return -1;
    }
    printf("socket ok %d\n", sockfd);

    //填充ipv4的通信结构体  服务器端ip和端口
    struct sockaddr_in serveraddr;
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(atoi(argv[2]));
    serveraddr.sin_addr.s_addr = inet_addr(argv[1]);

    //&serveraddr -->struct sockaddr_in *

    //2.请求链接  connect
    if (connect(sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr)) < 0)
    {
        perror("connect err.");
        return -1;
    }
    printf("connect ok.\n");
    MSG msg;

    //3.循环收发消息
    while (1)
    {
        int sum = 0;
        printf("******************************\n");
        printf("*1:注册\t2：登录\t3：退出*\n");
        printf("******************************\n");
        printf("请选择你所要执行的操作选项\n");

        scanf("%d", &sum);
        getchar();
        switch (sum)
        {
        case 1:
            do_regisyer(sockfd, &msg);
            break;
        case 2:
            if (do_login(sockfd, &msg) == 0)
            {
                while (1)
                {
                    int n = 0;
                    printf("******************************\n");
                    printf("*1:查询\t2：历史\t3：退出*\n");
                    printf("******************************\n");
                    printf("请选择你所要执行的操作选项\n");
                    scanf("%d", &n);
                    getchar();
                    switch (n)
                    {
                    case 1:
                        do_query(sockfd, &msg);
                        break;
                    case 2:
                        do_history(sockfd, &msg);
                        break;
                    case 3:
                        close(sockfd);
                        exit(0);
                        break;
                    default:
                        printf("输入错误，没有该操作\n");
                        break;
                    }
                }
            }
            break;
        case 3:
            close(sockfd);
            exit(0);
            break;
        default:
            printf("输入错误，没有该操作\n");
            break;
        }
    }

    return 0;
}
int do_regisyer(int sockfd, MSG *msg)
{
    msg->type = 'R';
    MSG msg_t;
    printf("请输入你要注册的用户名\n");
    scanf("%s", msg->name);
    getchar();
    printf("请输入你要设置的密码\n");
    scanf("%s", msg->data);
    getchar();
    if (send(sockfd, msg, sizeof(MSG), 0) < 0)
    {
        perror("send err");
        return -1;
    }
    if (recv(sockfd, &msg_t, sizeof(MSG), 0) < 0)
    {
        perror("recv err");
        return -1;
    }
    printf("%s\n", msg_t.data);
    return 0;
}
int do_login(int sockfd, MSG *msg)
{
    msg->type = 'L';
    MSG msg_t;
    printf("请输入用户名\n");
    scanf("%s", msg->name);
    getchar();
    printf("请输入密码\n");
    scanf("%s", msg->data);
    getchar();
    if (send(sockfd, msg, sizeof(MSG), 0) < 0)
    {
        perror("send err");
        return -1;
    }
    if (recv(sockfd, &msg_t, sizeof(MSG), 0) < 0)
    {
        perror("recv err");
        return -1;
    }
    printf("%s\n", msg_t.data);
    if (strncmp(msg_t.data, "登录成功", 4) == 0)
    {
        return 0;
    }
    else
    {
        return -1;
    }
}
int do_query(int sockfd, MSG *msg) //查询单词
{
    printf("输入quit!!!返回上一步\n");
    MSG msg_t;
    while (1)
    {
        msg->type = 'Q';
        printf("请输入你要查询的单词\n");
        scanf("%s", msg->data);
        if (strcmp(msg->data, "quit!!!") == 0)
        {
            break;
        }
        else
        {

            if (send(sockfd, msg, sizeof(MSG), 0) < 0)
            {
                perror("send err");
                return -1;
            }
            if (recv(sockfd, &msg_t, sizeof(msg_t), 0) < 0)
            {
                perror("recv err");
                return -1;
            }
            printf("%s\n", msg_t.data);
        }
    }
    return 0;
}
int do_history(int sockfd, MSG *msg) //查询历史
{
    msg->type = 'H';
    MSG msg_t;
    if (send(sockfd, msg, sizeof(MSG), 0) < 0)
    {
        perror("send err");
        return -1;
    }
    while (1)
    {
        if (recv(sockfd, &msg_t, sizeof(msg_t), 0) < 0)
        {
            perror("recv err");
            return -1;
        }
        if (strcmp(msg_t.data, "quit!!!") == 0)
        {
            break;
        }

        printf("%s\t%s\n", msg_t.name, msg_t.data);
    }
    return 0;
}

服务器端

#include "server.h"

sqlite3 *db;
int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("please input %s <port>\n", argv[0]);
        return -1;
    }
    char *errmsg = NULL;
    if (sqlite3_open("./dictionary.db", &db) != 0)
    {
        fprintf(stderr, "err:%s\n", sqlite3_errmsg(db));
        return -1;
    }
    printf("sqlite_open ok\n");

    //创建表
    if (sqlite3_exec(db, "create table user(type char,name char primary key,data char);", NULL, NULL, &errmsg) != SQLITE_OK)
    {
        fprintf(stderr, "err:%s\n", errmsg);
        //return -1;
    }
    //词典
    if (sqlite3_exec(db, "create table dir(word char,paraphrase char);", NULL, NULL, &errmsg) != SQLITE_OK)
    {
        fprintf(stderr, "err:%s\n", errmsg);
        //return -1;
    }
    //历史
    if (sqlite3_exec(db, "create table history(name char,time char,word char);", NULL, NULL, &errmsg) != SQLITE_OK)
    {
        fprintf(stderr, "err:%s\n", errmsg);
        //return -1;
    }
    //1.创建套接字 socket
    int sockfd, acceptfd;
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket err.");
        return -1;
    }
    printf("socket ok %d\n", sockfd);

    //填充ipv4的通信结构体
    struct sockaddr_in serveraddr, caddr;
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(atoi(argv[1]));
    serveraddr.sin_addr.s_addr = INADDR_ANY;

    socklen_t len = sizeof(caddr);

    //2.绑定套接字  bind  （绑定自己的ip和端口，便于别人找到自己）
    if (bind(sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr)) < 0)
    {
        perror("bind err.");
        return -1;
    }
    printf("bind ok.\n");

    //3.listen  监听 将主动套接子变为被动等待
    if (listen(sockfd, 5) < 0)
    {
        perror("listen err.");
        return -1;
    }
    printf("listen ok.\n");
    dictionary(); //字典
    //功能：poll 服务器响应多个客户端请求且进行通信
    //1.创建表 -创建一个结构体数组
    struct pollfd fds[500] = {}; //大小自己确定，没有限定个数
                                 //2.添加关心的文件描述符

    fds[0].fd = sockfd;
    fds[0].events = POLLIN;

    int n = 1, ret;
    char buf[256];
    MSG msg;
    int recvbyte;
    //3.循环调用poll检测 ，poll阻塞等待有事件产生返回 -1
    while (1)
    {
        ret = poll(fds, n, -1);
        if (ret < 0)
        {
            perror("poll err.");
            return -1;
        }
        //处理事件
        for (int i = 0; i < n; i++)
        {
            if (fds[i].revents == POLLIN)
            {
                if (fds[i].fd == sockfd)
                {
                    //4.阻塞等待客户端链接，链接成功返回一个通信文件描述符 accept
                    acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &len);

                    if (acceptfd < 0)
                    {
                        perror("accept err.");
                        return -1;
                    }
                    printf("accept ok.\n");

                    //输出查看链接的客户端的ip和端口
                    printf("ip:%s ,port:%d\n",
                           inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));

                    //需要将产生通信文件描述符添加到表中进行检测
                    fds[n].fd = acceptfd;
                    fds[n].events = POLLIN;
                    n++;
                }
                else
                {
                    //接收消息
                    recvbyte = recv(fds[i].fd, &msg, sizeof(msg), 0);
                    if (recvbyte < 0)
                    {
                        perror("recv err.");
                        return -1;
                    }
                    else if (recvbyte == 0)
                    {
                        printf("%d client exit.\n", fds[i].fd);
                        close(fds[i].fd);
                        fds[i] = fds[n - 1];
                        n--;
                        i--;
                        break;
                    }
                    else
                    {
                        printf("%s %s\n", msg.name, msg.data);
                        //将其他客户端输入的数据作为通知的消息发送给除自身外的所有链接的客户端
                        switch (msg.type)
                        {
                        case 'R':
                            do_regisyer(fds[i].fd, &msg);
                            break;
                        case 'L':
                            do_login(fds[i].fd, &msg);
                            break;
                        case 'Q':
                            do_query(fds[i].fd, &msg);
                            break;
                        case 'H':
                            do_history(fds[i].fd, &msg);
                            break;
                        default:
                            break;
                        }
                    }
                }
            }
        }
    }
    close(sockfd);
    return 0;
}

int do_regisyer(int sockfd, MSG *msg) //插入用户
{
    MSG msg_t;
    char sql[512];
    char *errmsg = NULL;

    sprintf(sql, "insert into user values(%d,\"%s\",\"%s\");", msg->type, msg->name, msg->data);
    printf("sql:%s\n", sql);
    if (sqlite3_exec(db, sql, NULL, NULL, &errmsg) != SQLITE_OK)
    {
        strcpy(msg_t.data, "该用户已存在");

        fprintf(stderr, "err:%s\n", errmsg);
        return -1;
    }
    else
    {

        strcpy(msg->data, "注册成功");
        if (send(sockfd, &msg_t, sizeof(msg_t), 0) < 0)
        {
            perror("send err");
        }
        printf("%s:插入成功\n", msg->name);
        return 0;
    }
}
int do_login(int sockfd, MSG *msg) //登录
{
    char **sp = NULL;
    int nrow, lie;
    MSG msg_t;
    char *errmsg = NULL;
    char sql1[128];
    printf("name:%s data:%s\n", msg->name, msg->data);
    sprintf(sql1, "select * from user where name=\"%s\";", msg->name);
    if (sqlite3_get_table(db, sql1, &sp, &nrow, &lie, &errmsg) != SQLITE_OK)
    {
        fprintf(stderr, "err:%s\n", errmsg);
        return -1;
    }

    if (nrow == 1)
    {
        if (strcmp(sp[5], msg->data) == 0)
        {
            printf("%s:登录成功\n", msg->name);
            strcpy(msg_t.data, "登录成功");
            send(sockfd, &msg_t, sizeof(msg_t), 0);
            return 0;
        }
        else
        {
            strcpy(msg_t.data, "密码错误");
            printf("%s:密码错误\n", msg->name);
            send(sockfd, &msg_t, sizeof(msg_t), 0);
        }
    }
    else
    {
        strcpy(msg_t.data, "该用户不存在");
        printf("%s:该用户不存在\n", msg->name);
        send(sockfd, &msg_t, sizeof(msg_t), 0);
    }
}
int do_query(int sockfd, MSG *msg) //查询
{
    char **sp = NULL;
    int nrow, lie;
    MSG msg_t;
    char *errmsg = NULL;
    char sql[128];
    sprintf(sql, "select * from dir where word=\"%s\";", msg->data);
    if (sqlite3_get_table(db, sql, &sp, &nrow, &lie, &errmsg) != SQLITE_OK)
    {
        fprintf(stderr, "err:%s\n", errmsg);
        return -1;
    }
    else
    {
        if (nrow == 1)
        {
            history_t(msg);
            strcpy(msg_t.data, sp[3]);
            send(sockfd, &msg_t, sizeof(msg_t), 0);
        }
        else
        {
            history_t(msg);
            strcpy(msg_t.data, "没有查询到该单词");
            send(sockfd, &msg_t, sizeof(msg_t), 0);
        }
        return 0;
    }
}
int do_history(int sockfd, MSG *msg) //历史
{
    char **sp = NULL;
    int nrow, lie;
    MSG msg_t;
    char *errmsg = NULL;
    char sql[128];
    sprintf(sql, "select * from history where name=\"%s\";", msg->name);
    if (sqlite3_get_table(db, sql, &sp, &nrow, &lie, &errmsg) != SQLITE_OK)
    {
        fprintf(stderr, "err:%s\n", errmsg);
        return -1;
    }
    else
    {
        if (nrow != 0)
        {
            int i, j, k = 1;
            for (i = 0; i < nrow + 1; i++)
            {
                for (j = 1; j < lie; j++)
                {
                    strcpy(msg_t.name, sp[k]);
                    strcpy(msg_t.data, sp[k + 1]);
                    
                }
                send(sockfd, &msg_t, sizeof(msg_t), 0);
                k = k + 3;
            }
            strcpy(msg_t.data, "quit!!!");
            send(sockfd, &msg_t, sizeof(msg_t), 0);

            return 0;
        }
    }
}
int history_t(MSG *msg)
{
    char sql[512];
    time_t timep;
    struct tm *p;
    char time1[28];
    time(&timep);
    p = gmtime(&timep);
    sprintf(time1, "%d年%d月%d日 %d:%d:%d", 1900 + p->tm_year, 1 + p->tm_mon, p->tm_mday, 8 + p->tm_hour, p->tm_min, p->tm_sec);
    char *errmsg = NULL;
    sprintf(sql, "insert into history values(\"%s\",\"%s\",\"%s\");", msg->name, time1, msg->data);
    if (sqlite3_exec(db, sql, NULL, NULL, &errmsg) != SQLITE_OK)
    {
        fprintf(stderr, "err:%s\n", errmsg);
        return -1;
    }
    return 0;
}
int dictionary(void) //字典
{
    FILE *fd = fopen("./dict.txt", "r");
    char buf[1024];
    char sum[128];
    char sun[1024];
    char *p = NULL, *q = NULL;
    MSG msg_t;
    char sql[1024];
    char *errmsg = NULL;
    while (fgets(buf, sizeof(buf), fd) != NULL)
    {
        p = buf;
        q = p + 1;
        while (1)
        {
            if (*q == '\n')
            {
                strcpy(sum, buf);

                strcpy(sun, "0");
                sprintf(sql, "insert into dir values(\"%s\",\"%s\");", sum, sun);
                if (sqlite3_exec(db, sql, NULL, NULL, &errmsg) != SQLITE_OK)
                {
                    fprintf(stderr, "err:%s\n", errmsg);
                    return -1;
                }
                break;
            }

            else if (*p == ' ' && *q == ' ')
            {
                *p = '\0';
                strcpy(sum, buf);
                strcpy(sun, q);
                sprintf(sql, "insert into dir values(\"%s\",\"%s\");", sum, sun);
                if (sqlite3_exec(db, sql, NULL, NULL, &errmsg) != SQLITE_OK)
                {
                    fprintf(stderr, "err:%s\n", errmsg);
                    return -1;
                }
                break;
            }
            p++;
            q++;
        }
    }
    fclose(fd);
}
weixin_60591214
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
在线电子词典项目
爱捣蛋的小仙儿。
07-25 2343
在线词典实现框架： 1、在线词典 2、项目功能描述 3、用户注册和登录验证 4、服务器端将用户信息和历史记录保存在数据库中，客户端输入用户名和密码，服务器端在数据库中查找、匹配，返回结果 5、单次在线翻译 6、根据客户端输入的单次在字典文件中搜索 7、历史记录查询 8、项目分析 服务器流程图： 客户端流程图： /*server*/ #include <stdio.h> #include <unistd.h> #include <stdlib.h> #include
网络编程项目——在线电子词典
weixin_54239317的博客
08-27 1498
登录注册功能，不能重复登录，重复注册单词查询功能历史记录功能，存储单词，意思，以及查询时间基于TCP，支持多客户端连接采用数据库保存用户信息与历史记录将dict.txt的数据导入到数据库中保存。按下ctrl+c退出客户端后，注销该客户端的登录信息格式要求：main函数只跑逻辑，不允许跑功能代码功能代码封装成函数。...
嵌入式培训经验分享——网络编程项目实战（在线电子词典）
x2751961352的博客
09-05 778
嵌入式培训经验分享——网络编程项目实战（在线电子词典）
特大喜讯！鸿蒙项目来了：在线电子词典
一个被知识诅咒的人
12-01 1075
完整的项目视频课程请识别下面的二维码进入我的B站：本项目是基于鸿蒙的电子词典，支持使用本地词库和远程词库。本地词库使用SQLite数据库、远程词典使用爬虫获取的单词数据。爬虫使用JSou...
基于TCP的在线电子词典的完整工程文件
10-18
在这个基于TCP的在线电子词典项目中，我们深入探讨了如何利用网络通信协议TCP（Transmission Control Protocol）构建一个高效、可靠的在线词汇查询系统。这个完整的工程文件包括了服务端和客户端的源代码，数据库...
多进程和多线程基础概念LINUX
2301_79109608的博客
08-22 1116
直接访问物理地址,会导致地址空间没有隔离,很容易导致数据被修改通过虚拟地址空间可以实现每个进程空间都是独立的，操作系统会映射到不用的物理地址区间，在访问时互不干扰.进程状态分为三个基本状态，即运行态，就绪态，阻塞态。在五态模型中，进程分为新建态、终止态，运行态，就绪态，阻塞态。并发：有限的 cpu 核芯的情况下 ,利用快速交替(时间片轮转)执行来达到宏观上的同时执行。虚拟地址 : 虚拟地址并不代表真实的内存空间,而是一个用于寻址的编号。并行：在 cpu 多核的支持下，实现物理上的同时执行。
黑神话悟空无法登录服务器怎么办
IDC_USA的博客
08-23 576
黑神话悟空游戏在登录的时候会遇到无法登录服务器的问题，玩家可以采用一些有效的方法进行解决，其中最主要的措施就是优化网络环境和减少网络干扰。Rak小编为您整理黑神话悟空无法登录服务器如何解决的步骤及注意事项。
仿Muduo库实现高并发服务器——Acceptor模块
2201_75324712的博客
08-22 492
Acceptor模块是为了创建套接字，并且接收新到来的客户端套接字，将对应套接字的Channel对象添加到Poller对象中，进行事件监控。
Windows Server查看W3SVC IIS服务器中对应的网站日志
滴水石穿
08-22 367
W3SVC1、W3SVC2、W3SVC3…基本上每个网站存放日志的文件夹名称都是以W3SVC开头，区别在于后面的ID/编号/序号，对应的是网站各自的ID。如果没有自定义站点的日志路径，日志默认的路径是C:\inetpub\logs\LogFiles\。W3SVC日志文件夹中序号的含义，格式就是W3SVC+网站ID。
香港服务器IIS网站怎么实现应用程序初始化和预加载
JttiSEO的博客
08-22 476
在香港服务器上使用 IIS 来初始化和预加载网站应用程序，可以显著提高网站的响应速度和性能，尤其是在首次访问时。这里的 initializationPage="/" 表示预加载首页，你可以根据需要指定其他页面。在应用程序池设置中，确保 "启动模式"(Start Mode)为 AlwaysRunning。这样配置可以帮助你确保应用程序在用户首次访问前就已经启动，减少首次加载的延迟。在 IIS 中配置站点或应用程序池的 "预加载" 设置。在右侧操作面板中，点击 "高级设置"。勾选 "启用应用程序初始化"。
HighConcurrencyCommFramework c++通讯服务器框架 ：TCP粘包解决
wuxiaoyu0806的博客
08-23 815
用。
黑神话：悟空游戏用的什么服务器？
petaexpress的博客
08-21 9802
黑神话：悟空游戏用的什么服务器？《黑神话：悟空》游戏使用的是基于云计算的强大服务器，具体型号和配置未公开。这些服务器在游戏发布初期就表现出极强的处理能力和稳定性，尽管同时在线人数一度突破百万，但整体运行仍然十分稳定。
【网络编程】select实现服务器与客户端进行通信
2301_77133426的博客
08-21 350
select实现服务器与客户端进行通信
生信圆桌：专业生信服务器与平台服务的提供者
最新发布
bioRoundTable的博客
08-26 348
生信圆桌专注于提供高性能生信服务器和云端生信分析平台服务，帮助全球科研机构和企业高效处理生物信息学数据，保障数据安全，支持技术咨询和定制化解决方案
浪潮服务器主板集成RAID常见问题
2401_86544677的博客
08-22 499
这里的 ID 号对应的就是硬盘托架上的编号，例如上图中，硬盘托架上的编号是 3，那么对 应的就是 ID 号是 3 的这排显示信息。同时和实际主板上对应的 sata 接口槽位是 sata3磁盘对应的关系就是在 Intel raid 配置界面信息中的 ID3 硬盘对应硬盘托架上 的编号 3 的硬盘，同时也是主板上 sata3 接口连接的硬盘。通过此 SN 号的对应，就可以将 raid 配置界面显示的硬盘和前端的物理硬盘各自对应起来，方便后续对于硬盘的识别和更换的操作。★更换故障硬盘修复阵列的方法。
服务器数据恢复—重建RAID失败导致数据丢失的数据恢复案例
beiya123的博客
08-23 413
某品牌服务器中有一组由4块SAS磁盘做的RAID5磁盘阵列。该服务器操作系统为windows server，运行了一个单节点Oracle，数据存储为文件系统，无归档。该oracle数据库的数据量不大，oracle数据库内只有一个用户，使用默认的users表空间，users表空间下仅有一个数据文件。
linuxc 在线电子词典
03-16
Linuxc 在线电子词典是一款基于Linux操作系统的在线电子词典软件，可以帮助用户快速查询单词的含义、发音、例句等信息。该软件具有界面简洁、查询速度快、支持多种语言等特点，是Linux系统下非常实用的工具之一。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值