用C语言实现“电子词典”项目

最新推荐文章于 2023-03-09 09:24:37 发布
最新推荐文章于 2023-03-09 09:24:37 发布
阅读量1.7k 收藏 26
点赞数 3
文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_57325286/article/details/126443730
版权

实现功能：

项目要求：

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

  2. 单词查询功能

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

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

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

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

  7. 按下ctrl+c退出客户端后，注销该客户端的登录信息

格式要求：

  1. main函数只跑逻辑，不允许跑功能代码

  2. 功能代码封装成函数

简略框架图：

 

效果展示：

1.登入界面 

        1.1普通登入

        1.2重复登入

        1.3错误登入

2.注册界面 

        2.1普通注册

        2.2重复注册

  

3.单词查询界面

4.数据库

        4.1dict单词数据库

        4.2用户账号密码数据库

        4.3 历史记录数据库 （表对应每个用户）

服务器：

        Serfun.h：

#ifndef __TEST_H__
#define __TEST_H__

#include <signal.h>
#include <stdio.h>
#include <sqlite3.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <unistd.h>
#include <pthread.h>
#include <time.h>

typedef struct Node
{
	union
	{
		int len;                  //存储头节点数据域，表示结点个数
		struct sockaddr_in cin; 	//数据域，普通结点要存放的值
	};
	char id[20];
	struct Node *next;           //指针域，记录下个结点的地址
}Linklist;

#define ERR_MSG(msg)  do{\
	fprintf(stderr, " __%d__ ", __LINE__);\
	perror(msg);\
}while(0)

//需要传入线程的数据
struct msg
{
	Linklist* L;
	int newfd;
	struct sockaddr_in cin;
};

//用户信息结构体            
struct user_msg             
{    
	char type;
	char id[20];                 
	char password[20];           
};                          

 //查询单词的结构体        
 struct W_ord              
 {                         
     char word[20];        
     char mean[50];    
 };                        
                           


//循环打印已有客户端的线程
void* loop_printf(void* arg);

//将didt单词表添加到 dict.db 数据库中;
int add_dict();

//判断登入注册
int logreg_Interface(sqlite3* userdb,struct user_msg usermsg,int newfd,Linklist* L);

//用户登入函数int user_login(sqlite3* userdb,struct user_msg usermsg,int newfd,Linklist* l);
int user_login(sqlite3* userdb,struct user_msg usermsg,int newfd,Linklist* L);

//用户注册函数
int user_register(sqlite3* userdb,struct user_msg usermsg,int newfd);

//查询对应的单词和解释
int search_word(struct W_ord words,int newfd,struct user_msg usermsg);

//分支线程用户与客户端交互
void* rcv_cli_msg(void* arg);	//void* arg = (void*)&cliInfo

//创建链表
Linklist *list_create();

//头插
int list_intsrt_head(Linklist*L, struct sockaddr_in cin,char id[20]);

//任意删
int list_delete_pos(Linklist *L, char id[20]);

//链表的销毁
void list_free(Linklist *L);

//头删
int list_delete_head(Linklist *L);

//判空
int list_empty(Linklist *L);

//遍历循环打印已有客户端
void list_show(Linklist *L);

//查找用户
int list_search_value(Linklist *L, char id[20]);
#endif

        serfun.c :

#include "serfun.h"                                                                                                                                                                                 
                                                                                                       
//循环打印已有客户端的线程                                                                             
void* loop_printf(void* arg)                                                                           
{                                                                                                      
    Linklist* L = arg;                                                                                 
                                                                                                       
    pthread_detach(pthread_self());                                                                    
    while(1)                                                                                           
    {                                                                                                  
        system("clear");                                                                               
        list_show(L);                                                                                  
        sleep(3);                                                                                      
    }                                                                                                  
                                                                                                       
    pthread_exit(NULL);                                                                                
}                                                                                                      
                                                                                                       
                                                                                                       
                                                                                                       
//线程处理函数                                                                                         
void* rcv_cli_msg(void* arg)    //void* arg = (void*)&cliInfo                                          
{                                                                                                      
    //分离分支线程                                                                                     
    pthread_detach(pthread_self());                                                                    
                                                                                                       
    int newfd = (*(struct msg*)arg).newfd;                                                             
    struct sockaddr_in cin = (*(struct msg*)arg).cin;                                                  
                                                                                                       
    Linklist* L = (*(struct msg*)arg).L;                                                               
                                                                                                       
    //定义结构体：接收客户端发来的用户信息                                                             
    struct user_msg usermsg;                                                                           
                                                                                                       
    //创建用户数据库                                                                                   
    sqlite3* userdb = NULL;                                                                            
    if(sqlite3_open("./user.db", &userdb) != SQLITE_OK)                                                
    {                                                                                                  
        fprintf(stderr, "__%d__ sqlite3_open failed\n", __LINE__);                                     
        return NULL;                                                                                   
    }                                                                                                  
                                                                                                       
    //创建用户数据库账号密码表                                                                         
    char* sql = "create table if not exists userMsg (id char primary key, password char);" ;           
    char* errmsg = NULL;                                                                               
    if(sqlite3_exec(userdb, sql, NULL, NULL, &errmsg) != SQLITE_OK)                                          
    {                                                                                                        
        fprintf(stderr, "__%d__ sqlite3_exec:%s\n", __LINE__, errmsg);                                       
        return NULL;                                                                                         
    }                                                                                                        
                                                                                                             
                              	while(1)
	{
		//接收登入、注册信息
		ssize_t res;
		res = recv(newfd, &usermsg, sizeof(usermsg), 0);                                                                     
		if(res < 0)                                                                                                 
		{                                                                                                           
			ERR_MSG("recv");                                                                                        
			return NULL;                                                                                               
		}                                                                                                           
		else if(0 == res)                                                                                           
		{                                                                                                           
			printf("[%s : %d] newfd = %d 客户端掉线\n", inet_ntoa(cin.sin_addr), ntohs(cin.sin_port),newfd);
			list_delete_pos(L,usermsg.id);
			close(newfd);
			pthread_exit(NULL);
			break;
		}                                                                                                           

		if( logreg_Interface(userdb,usermsg,newfd,L) == 1 ) //1函数成功 -2函数重新需要参数执行
		{
			break;	
		}
	}

	//将网络结构体插入链表
	list_intsrt_head(L,cin,usermsg.id);

	struct W_ord words;
	char buf[128] = "";
	ssize_t res = 0;
	while(1)
	{
		bzero(&words,sizeof(words));
		bzero(buf, sizeof(buf));
		//循环接收 
		res = recv(newfd, &words, sizeof(words), 0);
		if(res < 0)
		{
			ERR_MSG("recv");
			break;
		}
		else if(0 == res)
		{
			printf("[%s : %d] newfd = %d 客户端掉线\n", inet_ntoa(cin.sin_addr), ntohs(cin.sin_port),newfd);
			list_delete_pos(L,usermsg.id);
			break;
		}

		//查询对应的单词和解释
		search_word(words,newfd,usermsg);

	}
	close(newfd);
	
	pthread_exit(NULL);
}


//判断用户登入注册
int logreg_Interface(sqlite3* userdb,struct user_msg usermsg,int newfd,Linklist* L)
{

	if(usermsg.type == 'L')
	{
		return user_login(userdb,usermsg,newfd,L);   //1函数成功 -2函数重新需要参数执行
	}
	else if(usermsg.type == 'R')
	{
		return user_register(userdb,usermsg,newfd); //2为函数运行成功
	}
	
	return 0;
}

//用户登入函数
int user_login(sqlite3* userdb,struct user_msg usermsg,int newfd,Linklist* L)
{

	//查询账号密码是否在数据库中
	char cmp[128] = "";
	sprintf(cmp,"SELECT * FROM userMsg WHERE id like \"%s\" AND password like \"%s\"",usermsg.id,usermsg.password);
	char ** pres = NULL;
	int row,column;     //查询结果的行列数
	char * errmsg = NULL;
	if(sqlite3_get_table(userdb, cmp, &pres, &row, &column, &errmsg) != SQLITE_OK)
	{
		fprintf(stderr, "__%d__ sqlite3_get_table:%s\n", __LINE__, errmsg);
		return -1;
	}

	//发送给客户端确认信息， 1为成功，-1为账号密码错误，-2为已经登入
	int flag = 0;
	if(list_search_value(L,usermsg.id) != 0)
	{
		flag = -2;
		if(send(newfd, &flag, sizeof(flag), 0) < 0)
		{
			ERR_MSG("send");
			return -1;
		}
		return -2;
	}

	if(row == 1)   //账号密码在数据库
	{
		flag = 1;
		if(send(newfd, &flag, sizeof(flag), 0) < 0)
		{
			ERR_MSG("send");
			return -1;
		}
		printf("%s用户登入成功\n",usermsg.id);
		return 1;
	}
	else
	{
		flag = -1;
		if(send(newfd, &flag, sizeof(flag), 0) < 0)
		{
			ERR_MSG("send");
			return -1;
		}
		return -2;
	}

	//释放获取到的空间
	sqlite3_free_table(pres);
	pres = NULL;

	return 0;
}


//用户注册函数
int user_register(sqlite3* userdb,struct user_msg usermsg,int newfd)
{
	int flag = 1 ;  //注册成功为1，注册失败为-1;

	//调用插入数据库
	char* errmsg = NULL;
	char msg[128] = "";
	sprintf(msg, "insert into userMsg values(\"%s\",\"%s\")", usermsg.id,usermsg.password);
	if(sqlite3_exec(userdb, msg, NULL, NULL, &errmsg) != SQLITE_OK)
	{
		flag = -1; //注册失败，发送-1给客户端
		fprintf(stderr, "__%d__ sqlite3_exec:%s\n", __LINE__,errmsg);
		if(send(newfd, &flag, sizeof(flag), 0) < 0)
		{
			ERR_MSG("send");
			return -2;
		}
		return -2;
	}

	//注册成功,发送1给客户端
	if(send(newfd, &flag, sizeof(flag), 0) < 0)
	{
		ERR_MSG("send");
		return -1;
	}
	printf("%s用户注册成功\n",usermsg.id);

	return 2;
}


//查询对应的单词和解释,并发送给客户端，并加入历史记录
int search_word(struct W_ord words,int newfd,struct user_msg usermsg)
{
	//打开单词数据库
	sqlite3* dictdb = NULL;
	if(sqlite3_open("./dict.db", &dictdb) != SQLITE_OK)
	{
		fprintf(stderr, "__%d__ sqlite3_open:%s\n", __LINE__, sqlite3_errmsg(dictdb));
		return -1;
	}

	//打开所有用户的历史记录数据库
	sqlite3* histroy = NULL;
	if(sqlite3_open("./histroy.db", &histroy) != SQLITE_OK)
	{
		fprintf(stderr, "__%d__ sqlite3_open failed\n", __LINE__);
		return -1;
	}

	//创建对应用户的历史记录表格
	char sql[128] = "";
	sprintf(sql,"create table if not exists %s (word char, mean char,time char);",usermsg.id);
	char* errmsg = NULL;
	if(sqlite3_exec(histroy, sql, NULL, NULL, &errmsg) != SQLITE_OK)
	{
		fprintf(stderr, "__%d__ sqlite3_exec:%s\n", __LINE__, errmsg);
		return -1;
	}


	//查询单词和解释是否在数据库中
	char cmp[128] = "";

	//将命令存入cmp， word像xxx或者意思像xxx的
	sprintf(cmp,"SELECT * FROM dict WHERE word like \"%s\" OR mean like \" %s \"",words.word,words.mean);

	char ** pres = NULL;
	int row,column;     //查询结果的行列数
	if(sqlite3_get_table(dictdb, cmp, &pres, &row, &column, &errmsg) != SQLITE_OK)
	{
		fprintf(stderr, "__%d__ sqlite3_get_table:%s\n", __LINE__, errmsg);
		return -1;
	}

	//判断是否查找到
	if(row == 0)
	{
		strcpy(words.mean,"未找到此单词");
	}
	else
	{
		//将查到的数据存入单词结构体
		bzero(&words,sizeof(words));
		strcpy(words.word,pres[2]);
		strcpy(words.mean,pres[3]);

		//获取查询时间
		time_t t;
		struct tm *info = NULL;
		char timenow[128] = "";
		t = time(NULL);
		info = localtime(&t);
		sprintf(timenow, "%d-%02d-%02d %02d:%02d:%02d",\
				info->tm_year+1900, info->tm_mon+1, info->tm_mday,\
				info->tm_hour, info->tm_min, info->tm_sec);

		//将单词存入历史记录表
		bzero(sql,sizeof(sql));
		sprintf(sql, "insert into %s values(\"%s\",\"%s\",\"%s\");", usermsg.id,pres[2],pres[3],timenow);
		if(sqlite3_exec(histroy, sql, NULL, NULL, &errmsg) != SQLITE_OK)
		{
			fprintf(stderr, "__%d__ sqlite3_exec:%s\n", __LINE__, errmsg);
			return -1;
		}
	}

	//将结构体发送给客户端
	if(send(newfd, &words, sizeof(words), 0) < 0)
	{
		ERR_MSG("send");
		return -1;
	}

	//关闭数据库
	sqlite3_close(dictdb);
	return 0;
}



//将didt单词表添加到 dict.db 数据库中;
int add_dict()
{
	//打开数据库
	sqlite3* dictdb = NULL;
	if(sqlite3_open("./dict.db", &dictdb) != SQLITE_OK)
	{
		fprintf(stderr, "__%d__ sqlite3_open:%s\n", __LINE__, sqlite3_errmsg(dictdb));
		return -1;
	}

	char sql[400] = "create table if not exists dict (word char, mean char)";
	char* errmsg = NULL;
	//创建表格
	if(sqlite3_exec(dictdb, sql, NULL, NULL, &errmsg) != SQLITE_OK)
	{
		fprintf(stderr, "__%d__ sqlite3_exec:%s\n", __LINE__,errmsg);
		return -1;
	}


	//打开文件
	FILE* fp = fopen("./dict.txt", "r");
	if(NULL == fp)
	{
		perror("fopen");
		return -1;
	}

	//循环读取一行，直到读取完毕为止
	char buf[300] = "";
	char word[50]="", mean[300]="";
	int i = 0;

	while(fgets(buf, sizeof(buf), fp) != NULL)
	{
		buf[strlen(buf)-1] = 0;
		//分离单词和意思
		for(i=0; i<strlen(buf)-2; i++)
		{
			if(buf[i]!=' ' && buf[i+1]==' ' && buf[i+2]==' ')
			{
				strncpy(word, buf, i+1);
				//			printf("wrod = %s\n", word);
			}
			else if(buf[i]==' '&& buf[i+1]==' ' && buf[i+2]!=' ')
			{
				strcpy(mean, (buf+i+2));
				break;
			}
		}

		//插入到数据库中
		sprintf(sql, "insert into dict values(\"%s\", \"%s\")", word, mean);
		//	printf("%s\n", sql);
		if(sqlite3_exec(dictdb, sql, NULL, NULL, &errmsg) != SQLITE_OK)
		{
			fprintf(stderr, "__%d__ sqlite3_exec:%s\n", __LINE__,errmsg);
			return -1;
		}

		bzero(word, sizeof(word));
		bzero(mean, sizeof(mean));
	}
	printf("导入单词库成功\n");
	//关闭文件
	fclose(fp);
	//关闭数据库
	sqlite3_close(dictdb);
}

//创建链表
Linklist *list_create()
{
	Linklist* L = (Linklist*)malloc(sizeof(Linklist));
	if(NULL == L)
	{
		printf("创建失败\n");
		return NULL;
	}

	//初始化
	L->next = NULL;
	L->len = 0;
	return L;
}

//头插
int list_intsrt_head(Linklist*L, struct sockaddr_in cin,char id[20])
{
	//申请节点
	Linklist *p = (Linklist*)malloc(sizeof(Linklist));
	if(NULL==p)
	{
		printf("节点申请失败\n");
		return -1;
	}

	//将要插入的数据放入节点
	p->cin = cin;
	p->next = NULL;
	strcpy(p->id,id);

	//完成头插
	p->next = L->next;
	L->next = p;

	//表的变化
	L->len++;

	printf("头插成功\n");
	return 0;
}


//任意删
int list_delete_pos(Linklist *L, char id[20])
{
	//判断逻辑
	if(NULL==L || list_empty(L) )
	{
		return -1;
	}	
	
	
	Linklist *q = L;
	if(strcmp(q->next->id,id))
	{
		q = q->next;
	}

	//删除逻辑
	Linklist *p = q->next;
	q->next = p->next;
	free(p);
	p = NULL;

	//表的变化
	L->len --;

	return 0;
}


//链表的销毁
void list_free(Linklist *L)
{
	if(NULL == L)
	{
		return;
	}

	//不断调用头删，将结点进行删除
	while(L->next != NULL)
	{
		list_delete_head(L);
	}

	//将头结点释放
	free(L);
	L = NULL;

	printf("释放表完成\n");
	return ;
}

//头删
int list_delete_head(Linklist *L)
{
	//判断逻辑
	if(NULL==L || list_empty(L))
	{
		printf("删除失败\n");
		return -1;
	}

	//头删
	Linklist *p = L->next;    //标记
	L->next = p->next;        //孤立
	free(p);                  //踢开
	p=NULL;

	//表的变化
	L->len--;
	return 0;
}

//判空
int list_empty(Linklist *L)
{
	//1表示空   0表示非空
	if(NULL==L)
	{
		printf("表不合法\n");
		return -1;
	}
	return NULL==L->next ? 1:0;
}


//遍历循环打印已有客户端
void list_show(Linklist *L)
{
	//判断逻辑
	if( NULL==L || list_empty(L))
	{
		printf("还未有客户端用户登入(3s更新一次)\n");
		return;
	}

	//遍历逻辑
	printf("在线的客户端数量为%d,用户分别为(3s更新一次)：\n",L->len);
	Linklist *q = L->next;
	while(q != NULL)
	{
		printf("地址:[%s : %d]\t用户名:[%s]\n", inet_ntoa(q->cin.sin_addr), ntohs(q->cin.sin_port),q->id);
		q = q->next;
	}
	printf("\n");
}


//查找用户
int list_search_value(Linklist *L, char id[20])
{
	//查找逻辑
	Linklist *q = L->next;
	for(int i=1; i<=L->len; i++)
	{
		if(strcmp(q->id,id))
		{
			q = q ->next;
		}
		else
		{
			return i;
		}
	}

	return 0;
}

        main.c:

#include "serfun.h"

#define PORT 8888 				//1024~49151
#define IP 	"192.168.31.188" 	//本机IP,用ifconfig查看

int main(int argc, const char *argv[])
{
	//创建套接字
	int sfd = socket(AF_INET, SOCK_STREAM, 0);
	if(sfd < 0)
	{
		ERR_MSG("socket");
		return -1;
	}
	printf("create socket success\n");

	//允许端口快速重用
	int reuse = 1;
	if(setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0)
	{
		ERR_MSG("setsockopt");
		return -1;
	}

	//填充地址信息结构体，真实的地址信息结构体与协议族相关
	//AF_INET，所以详情请看man 7 ip
	struct sockaddr_in sin;
	sin.sin_family 		= AF_INET;
	sin.sin_port 		= htons(PORT); 	//网络字节序的端口号
	sin.sin_addr.s_addr = inet_addr(IP); 	//网络字节序的IP地址

	//将地址信息结构体绑定到套接字上
	if(bind(sfd, (struct sockaddr*)&sin, sizeof(sin)) < 0)
	{
		ERR_MSG("bind");
		return -1;
	}
	printf("bind success\n");

	//将套接字设置为被动监听状态，让内核去监听是否有客户端连接;
	if(listen(sfd, 10) < 0)
	{
		ERR_MSG("listen");
		return -1;
	}
	printf("listen success\n");

	system("clear");

	//创建存储客户端网络结构体链表
	Linklist *L = list_create();
	if(NULL == L)
	{
		return -1;
	}
	//定义存储客户端网络结构体
	struct sockaddr_in cin;
	socklen_t addrlen = sizeof(cin);

	//将didt单词表添加到 dict.db 数据库中;
	add_dict();

	int newfd = 0;
	pthread_t tid;
	struct msg cliInfo;
	//从已完成连接的队列头中，取出一个客户端的信息，创建生成一个新的套接字文件描述符，
	//该文件描述符才是与客户端通信的文件描述符!!!

	//循环打印已有客户端的线程
	if(pthread_create(&tid, NULL, loop_printf, (void*)L) != 0)
	{
		ERR_MSG("pthread_create");
		return -1;
	}

	while(1)
	{
		//主线程主要负责连接
		newfd = accept(sfd, (struct sockaddr*)&cin, &addrlen);
		if(newfd < 0)
		{
			perror("accept");
			return -1;
		}

		//网络字节序的IP-->点分十进制  网络字节序的port--->本机字节序
		printf("[%s : %d] newfd = %d 客户端连入\n", inet_ntoa(cin.sin_addr), ntohs(cin.sin_port),newfd);

		cliInfo.newfd = newfd;
		cliInfo.cin = cin;
		cliInfo.L = L;


		//一旦连接成功后，创建一个分支线程用户与客户端交互;
		if(pthread_create(&tid, NULL, rcv_cli_msg, (void*)&cliInfo) != 0)
		{
			ERR_MSG("pthread_create");
			return -1;
		}
	}

	close(sfd);
	list_free(L);
	return 0;
}

客户端：

        clifun.h:

#ifndef __CLIFUN_H__
#define __CLIFUN_H__

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

#define ERR_MSG(msg)  do{\
	fprintf(stderr, " __%d__ ", __LINE__);\
	perror(msg);\
}while(0)

//需要传入线程的数据
struct msg
{
	int newfd;
	struct sockaddr_in cin;
};

//用户信息结构体
struct user_msg
{
	char type;
	char id[20];
	char password[20];
};

//查询单词的结构体
struct W_ord
{
	char word[20];
	char mean[50];
};

struct PRES               
{                         
	char ** topres;       
};                        
     

//将didt单词表添加到 dict.db 数据库中;
int add_dict(sqlite3*);

//登入注册界面
int logreg_Interface(int sfd);

//向服务器发送用户登入申请
int user_login(int sfd);

//向服务器发送用户注册申请
int user_register(int sfd);


//分支线程用户与客户端交互
void* rcv_cli_msg(void* arg);	//void* arg = (void*)&cliInfo


#endif

         clifun.c:

#include "clifun.h"

//登入注册界面
int logreg_Interface(int sfd)
{
	while(1)
	{
		printf("-----------洪氏宝典----------\n");
		printf("-----------1.登入------------\n");
		printf("-----------2.注册------------\n");
		printf("-----------3.退出------------\n");

		int num; //存储选择的序号
		printf("请选择:");
		scanf("%d",&num);

		if(num == 1)
		{
			if(user_login(sfd) == -1)
			{
				return -1;
			}
			else
			{
				break;
			}
		}
		else if(num == 2)
		{
			if(user_register(sfd) == -1)
			{
				return -1;
			}
			if(user_login(sfd) == -1)
			{
				return -1;
			}
			break;
		}
		else if(num == 3)
		{
			return -2;
		}
		else
		{
			printf("选择无效，请重新选择\n");
		}
	}
	return 0;
}

//向服务器发送用户登入申请
int user_login(int sfd)
{
	while(1)
	{
		printf("------登入------\n");
		//填入账号密码数据
		struct user_msg usermsg;
		usermsg.type = 'L';
		printf("请输入账号:");
		scanf("%s",usermsg.id);
		getchar();
		printf("请输入密码:");
		scanf("%s",usermsg.password);
		getchar();

		//发送给服务器
		if(send(sfd, &usermsg , sizeof(usermsg), 0) < 0)
		{
			ERR_MSG("send");
			return -1;
		}

		//接受服务器发来的确认信息	
		int flag;
		ssize_t res;
		res = recv(sfd, &flag, sizeof(flag), 0);
		if(res < 0)
		{
			ERR_MSG("recv");
			return -1;
		}
		else if(0 == res)
		{
			return -1;
		}

		//判断服务器发来的确认信息 1为成功,-1为失败(数据错误)
		if(flag == 1)
		{
			printf("登入成功\n");
			break;
		}
		else if(flag == -1)
		{
			printf("用户账号密码错误\n");
		}
		else if(flag == -2)
		{
			printf("该用户已经登入\n");
		}
	}
	return 0;
}


//向服务器发送用户注册申请
int user_register(int sfd)
{
	printf("------注册------\n");
	while(1)
	{
		//填入要注册账号密码数据
		struct user_msg usermsg;
		usermsg.type = 'R';
		printf("请输入注册账号(不能纯数字):");
		scanf("%s",usermsg.id);
		getchar();
		printf("请输入注册密码:");
		scanf("%s",usermsg.password);
		getchar();

		//发送给服务器
		if(send(sfd, &usermsg , sizeof(usermsg), 0) < 0)
		{
			ERR_MSG("send");
			return -1;
		}

		//接受服务器发来的确认信息	
		int flag;
		ssize_t res;
		res = recv(sfd, &flag, sizeof(flag), 0);
		if(res < 0)
		{
			ERR_MSG("recv");
			return -1;
		}
		else if(0 == res)
		{
			printf("server is off-line\n");
			return -1;
		}

		//判断服务器发来的确认信息 1为成功,-1为失败(数据错误)
		if(flag == 1)
		{
			printf("注册成功\n");
			break;
		}
		else if(flag < 0)
		{
			printf("注册失败，重复注册\n");
		}
	}
	return 0;
}

         cli.c:

#define PORT 8888                                    
#define IP  "192.168.31.188"  

int main(int argc, const char *argv[])
{

	//创建流式套接字
	int sfd = socket(AF_INET, SOCK_STREAM, 0);
	if(sfd < 0)
	{
		ERR_MSG("socket");
		return -1;
	}
	printf("create socket success\n");


	//绑定客户端的地址信息结构体--》非必须绑定 
	
	//填充要连接的服务器的地址信息结构体
	struct sockaddr_in sin;
	sin.sin_family 		= AF_INET;
	sin.sin_port 		= htons(PORT);
	sin.sin_addr.s_addr = inet_addr(IP);

	//连接服务器 connect
	if(connect(sfd, (struct sockaddr*)&sin, sizeof(sin)) < 0)
	{
		ERR_MSG("connect");
		return -1;
	}

	int reslog;
	reslog = logreg_Interface(sfd);
	if(reslog== 0)
	{
	
	}
	else if(reslog == -1)
	{
		printf("服务器掉线\n");
		return -1;
	}
	else
	{
		return -1;
	}

	system("clear");
	//查询单词操作
	char buf[128] = "";
	ssize_t res = 0;
	struct W_ord words = {"",""};
	struct PRES sinpres;
	while(1)
	{
		bzero(&words,sizeof(words));
		bzero(buf, sizeof(buf));
		//发送
		printf("请输入要查询的单词>>>");
		fgets(buf, sizeof(buf), stdin);
		buf[strlen(buf)-1] = 0;
	
		//判断输入的是单词还是解释
		if(buf[0] > 0) //如果第一个是字母的话
		{
			strcpy(words.word,buf); //将输入存到word里面
		}
		else
		{
			strcpy(words.mean,buf);//如果不是将输入存到explain里面
		}

		if(send(sfd, &words, sizeof(words), 0) < 0)
		{
			ERR_MSG("send");
			return -1;
		}

		//接收 
		bzero(&words, sizeof(words));
		res = recv(sfd, &words, sizeof(words), 0);
		if(res < 0)
		{
			ERR_MSG("recv");
			return -1;
		}
		else if(0 == res)
		{
			printf("服务器已掉线\n");
			break;
		}
		printf("%s\t%s\n", words.word, words.mean);
	}

	//关闭套接字
	close(sfd);

	return 0;
}

 

 

 

 

 

 

 

洪乐乐
关注
基于C语言的网络电子词典
m0_73315736的博客
08-19 3330
本文章是来自于华清远见的一个基于C语言的网络电子词典项目，使用到了tcp协议的并发服务器设计、网络编程、文件I/O、数据库等多方面的知识。可以满足多用户同时登陆，用户登陆后可以查询单词及历史记录，具有查找快速，保密性好等优点。对于初学嵌入式的同学们是一个非常不错的练习项目。
C语言在线词典项目—Linux
weixin_45367439的博客
10-24 5034
C语言-在线词典项目 功能：基于网络编程和数据库实现在线词典功能，客户端可以注册，登入，查询历史信息等操作，服务器基于多进程实现多客户端的并发访问，并使用sqlite数据库实现对用户信息的管理。 客户端 #include<stdio.h> #include<string.h> #include<unistd.h> #include<strings.h> #include<stdlib.h> #include<sys/types.h>
c项目——电子词典
07-09
主要是对c语言的巩固， 【考察知识点】 （1）变量数据类型 （2）数组 （3）结构体 （4）typedef关键字的使用 （5）控制结构 （6）函数接口设计 （7）static关键字的使用 （8）文件拆分与代码组织 （9）模块化设计思想 （10）简单的面向对象程序设计思想
C语言小项目之基于sqlite3数据库的电子词典项目
m0_57730390的博客
09-07 1923
该电子词典项目主要有如下功能：1、用户注册和登录验证2、服务器端将用户信息和历史记录保存在数据库中。客户端输入用户名和密码，服务器端在数据库中查找、匹配，返回结果3、单词在线翻译4、根据客户端输入的单词在字典文件中搜索5、历史记录查询提示：以下是本篇文章正文内容，下面案例可供参考例如：以上就是今天要讲的内容，本文仅仅简单介绍了C语言中常见函数的使用，涉及到了应用层的编程知识，例如socket编程、数据库编程，文件IO等。
C语言实现电子辞典（电子词典）
weixin_44144366的博客
03-09 863
C语言实现电子辞典（电子词典）
第十九周—c语言 电子词典项目
代码屋-CODE HOUSE
01-03 1007
/* 烟台大学计算机学院 2016 作者：张威 完成日期：2016年1月3日 版本号：v1.0 */ #include #include #include int num=0;   //用来统计单词的数量 char e[8000][20],c[8000][20]; //e二维数组存储英语，c二维数组存储中文意思；8000代表单词数，20表示单词中字母数。 int sea
C++第15周项目5——-电子词典
迂者-贺利坚的专栏
12-06 6745
课程首页地址：http://blog.csdn.net/sxhelijian/article/details/7910565【项目5-电子词典】：做一个简单的电子词典。在文件dictionary.txt中（本文后附了一部分（b打头的词）作为调试，校内同学到我的BB教学平台中找，校外人士感兴趣的告知我Email），保存的是英汉对照的一个词典，词汇量近8000个，英文与释义间用’\t’隔开。编程序，将
C语言实现电子词典.
09-11
《C语言实现电子词典——基于epoll的并发服务器与sqlite3数据库应用》 在信息技术领域，编程语言是实现各种应用程序的基础，而C语言作为其中的经典代表，以其高效、灵活的特点，广泛应用于系统级编程和嵌入式开发。...
C语言实现小型电子词典
08-26
C语言实现小型电子词典 本文主要介绍了使用C语言实现小型电子词典的过程，用户可以进行英译汉、汉译英等...通过本文，读者可以了解到C语言在电子词典开发中的应用，并可以作为参考材料用于开发自己的电子词典项目。
基于C语言实现电子英汉词典
05-22
在电子词典项目中，我们可以创建一个结构体来存储单词及其对应的翻译。例如： ```c typedef struct { char englishWord[50]; char chineseTranslation[100]; } DictionaryEntry; ``` 接着，我们需要一个数据结构...
Linux C语言实现在线电子词典，sqlite，升级版
最新发布
08-01
【在线词典代码】项目涉及了多个IT领域的关键知识点，主要涵盖了网络通信、TCP通信协议以及数据库的使用，特别是SQLite3数据库在C语言环境下的应用。以下是对这些核心概念的详细解析： 网络通信是计算机之间通过...
电子词典C语言代码（华清）
05-02
基于C语言、Sqlite3编写的在线电子词典小项目，运用到进程、线程、网络套接字等知识，该电子词典适用于华清培训的小项目，最好自己能够实现
c 语言tcp实现电子词典项目
m0_66097247的博客
07-22 849
c语言 网络编程 数据库 登录 注册 查询 历史纪录
C项目-在线词典查询
aukshduiw的博客
08-09 731
在线词典C语言
C小项目——电子词典
血染风采2019
03-13 7348
C语言项目——查字典 宗旨：技术的学习是有限的，分享的精神的无限的。 【项目需求描述】 一、单词查询 给定文本文件“dict.txt”，该文件用于存储词库。词库为“英-汉”，“汉-英”双语词典，每个单词和其解释的格式固定，如下所示： #单词 Trans:解释1@解释2@…解释n 每个新单词由“#”开头，解释之间使用“@”隔开。一个词可能有多个解释，解释均存储在一行
电子词典项目
L-Smeng
10-27 1891
电子词典项目 1. 功能说明 用户可以登录和注册 登录凭借用户名密码即可 注册要求用户必须填写用户名和密码其他内容自定 用户名要求不能重复 用户数据要求使用数据库长期保存 数据表自定 能够满足多个用户同时登录操作的需求 功能分为客户端和服务端，客户端主要发出请求，服务端处理请求 用户启动客户端即进入一级界面 登录 注册 退出 用户登陆后即进入二级界面 查单词 查看历史记录...
C++第16周项目3 -电子词典
迂者-贺利坚的专栏
06-14 4371
课程首页地址：http://blog.csdn.net/sxhelijian/article/details/7910565，本周题目链接：http://blog.csdn.net/sxhelijian/article/details/9078413【项目3】电子词典　　　做一个简单的电子词典。在文件dictionary.txt中，保存的是英汉对照的一个词典，词汇量近8000个，英文、中文释义与词
2014秋C++第14周项目4参考-电子词典
迂者-贺利坚的专栏
11-30 2491
课程主页在http://blog.csdn.net/sxhelijian/article/details/39152703，课程资源在云学堂“贺老师课堂”同步展示，使用的帐号请到课程主页中查看。 【项目4-电子词典】做一个简单的电子词典。在文件dictionary.txt中，保存的是英汉对照的一个词典，词汇量近8000个，英文与释义间用’\t’隔开。编程序，将文件中的内容读到两个数组e[]和c[]
c语言哈希表电子辞典_C语言实现的哈希表实现程序
weixin_28863779的博客
12-30 175
下面我们一起来看一个C语言实现的哈希表实现程序了，这个程序没有过多的说明只是一个例子，大家有兴趣可以进入看看或测试一下。为了巩固一下链表知识，自己实现的一个哈希表，在GCC 4.4.7下编译通过；hash.h 代码如下 复制代码 /*** Author : maben* Date : 2014-12-23*/#ifndef __HASH_H__#define...
C语言实现电子词典程序
1. **结构体（Struct）**：在这个电子词典项目中，`struct dic` 定义了一个结构体，用来存储单词和其对应的描述。它包含三个成员：一个整型变量`number`，一个最大长度为`MAXWORDS`的字符数组`word`，以及一个最大...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值