• 基于Qt的在线抢答系统

    目录

    Server客户端

    Server.pro

    tcpserver.h

    thread.h

    tcpsocket.h

    db.h

    user.h

    myserver.h

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

    tcpserver.cpp

    thread.cpp

    tcpsocket.cpp

    db.cpp

    user.cpp

    myserver.cpp

    main.cpp

    Client客户端

    Client.pro

    register.h

    login.h

    communicate.h

    brainstorm.h

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

    register.cpp

    login.cpp

    communicate.cpp

    brainstorm.cpp

    main.cpp

    1. 开发环境/工具： Linux，QT，libevent库，Mysql数据库，jsoncpp库。
    2. 基于 Qt 平台：分别在 windows 和 Linux 下构建客户端和服务器，实现“头脑 风暴”                            在线对战小游戏。
    3. 实现功能：实现了用户注册、用户登录、排位匹配对战答题、个人训练答题、段位记                      录系统、段位匹配系统等功能。

    Server服务器端

    Server.pro

    补上需要的代码：

    1.  
    2. CONFIG += console c++11
    3.  
    4.  
    5. #jsoncpp
    6. LIBS +=-L/usr/local/lib -levent -lpthread -lmysqlclient -ljson

    tcpserver.h

    1. #ifndef TCPSERVER_H
    2. #define TCPSERVER_H
    3. #include"thread.h"
    4. #include
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. #include
    10. #include
    11. #include"tcpsocket.h"
    12.  
    13. class TcpSocket;
    14.  
    15. //Tcp服务器的基类
    16. class TcpServer
    17. {
    18.     friend class TcpSocket;
    19. public:
    20.     TcpServer(int threadNum=8);
    21.     int listen(int port, const char *ip=NULL);
    22.  
    23.     //服务器开始运行
    24.     void start();
    25.  
    26. protected:
    27.     //监听回调函数，有客户端连接的时候会调用
    28.     static void listenCb(struct evconnlistener *, evutil_socket_t fd, struct sockaddr *clientAdd, int socklen, void *data);
    29.  
    30.     //监听处理函数
    31.     void listenEvent(evutil_socket_t fd, struct sockaddr_in *clientAdd);
    32.  
    33.     //--------虚函数，去具体处理客户端的逻辑--------
    34.     //客户端连接事件
    35.     virtual void connectEvent(TcpSocket *){}
    36.     //客户端可读事件
    37.     virtual void readEvent(TcpSocket *){}
    38.     //客户端可写事件
    39.     virtual void writeEvent(TcpSocket *){}
    40.     //客户端可读事件
    41.     virtual void closeEvent(TcpSocket *,short){}
    42.  
    43. private:
    44.     int m_threadNum;//线程个数
    45.     Thread *m_threadPool;//线程池
    46.     struct event_base *m_base;
    47.     struct evconnlistener *m_listener;//监听客户端的连接(事件)。类似于监听套接字。
    48.     int m_nextThread;     //记录下一个线程的下标
    49. };
    50.  
    51. #endif // TCPSERVER_H

    thread.h

    1. #ifndef THREAD_H
    2. #define THREAD_H
    3.  
    4. #include
    5. #include
    6. #include 
    7. #include
    8.  
    9. #include
    10. #include
    11. #include
    12. class Thread
    13. {
    14. public:
    15.     Thread();
    16.     void start();//线程运行
    17.  
    18.     //获取事件集合
    19.     struct event_base *getBase();
    20.  
    21. protected:
    22.     //在类的内部调用回调函数就要变成静态，加static
    23.     static void* worker(void*);//线程的工作函数
    24.     static void pipeRead(evutil_socket_t,short,void *);//管道可读
    25.     void run();            //线程的逻辑处理函数
    26.  
    27. private:
    28.     struct event_base *m_base;//事件集合
    29.     pthread_t m_threadId;     //线程ID
    30.     int m_pipeReadFd;        //管道的读端
    31.     int m_pipeWriteFd;       //管道的写端
    32.     struct event m_pipeEvent;   //管道事件
    33.  
    34. };
    35.  
    36. #endif // THREAD_H

    tcpsocket.h

    1. #ifndef TCPSOCKET_H
    2. #define TCPSOCKET_H
    3.  
    4. #include"tcpserver.h"
    5. #include
    6.  
    7. class TcpServer;
    8.  
    9. //通信类，负责与客户端进行通信
    10. class TcpSocket
    11. {
    12.  
    13. public:
    14.     TcpSocket(TcpServer *tcpServer, struct bufferevent *bev, char *ip, u_int16_t port);
    15.  
    16.     //可读事件的回调函数
    17.     static void readEventCb(struct bufferevent *bev,void *etc);
    18.     //可写事件的回调函数
    19.     static void writeEventCb(struct bufferevent *bev,void *etc);
    20.     //异常事件的回调函数
    21.     static void closeEventCb(struct bufferevent *bev,short what,void *etc);
    22.  
    23.     char *getIp();//获取IP地址
    24.     u_int16_t getPort();//获取端口
    25.  
    26.     //从客户端读数据
    27.     int readDate(void *data, int size);
    28.     //向客户端写数据
    29.     int writeDate(const void *data, int size);
    30.  
    31.     void setUserName(std::string name);
    32.     std::string getUserName();
    33.  
    34. private:
    35.     static TcpServer *m_tcpServer;//服务器类对象。需要初始化
    36.     struct bufferevent *m_bev;//通信用的句柄,用来与客户端通信
    37.     char *m_ip;              //客户端的IP地址
    38.     u_int16_t m_port;       //客户端的端口
    39.  
    40.     std::string _userName;//当前使用他这个用户
    41. };
    42.  
    43. #endif // TCPSOCKET_H

    db.h

    1. #ifndef DB_H
    2. #define DB_H
    3. #include"mysql/mysql.h"
    4. #include
    5. #include
    6. #include
    7.  
    8. class DB
    9. {
    10. public:
    11.     DB(const char *host,const char *userName,const char *passwd,const char *dbName);
    12.     //执行数据库语句
    13.     bool db_exec(const char *sql);
    14.  
    15.     //数据库查询
    16.     //[in] sql        查询语句
    17.     //[out] outJson   查询结果到json变量中
    18.     bool db_select(const char *sql,Json::Value &outJson);
    19.  
    20.  
    21.  
    22. private:
    23.     std::mutex _mutex;//数据库句柄互斥锁
    24.     MYSQL *_mysql;//数据库
    25. };
    26.  
    27. #endif // DB_H

    user.h

    1. #ifndef USER_H
    2. #define USER_H
    3. #include
    4. #include"tcpsocket.h"
    5.  
    6. class User
    7. {
    8. public:
    9.     User(std::string n,std::string p,int rank,TcpSocket *s);
    10.  
    11.     TcpSocket *getSocket();
    12.     const char *getName();
    13.  
    14.     int getRank();
    15.  
    16.     void setRank(int rank);
    17.  
    18. private:
    19.     std::string _userName;  //用户名
    20.     std::string _passwd;    //用户密码
    21.     int _rank;             //rank分数
    22.  
    23.  
    24.     TcpSocket *_s;          //通信类套接字
    25. };
    26.  
    27. #endif // USER_H

    myserver.h

    1. #ifndef MYSERVER_H
    2. #define MYSERVER_H
    3.  
    4. #include"tcpserver.h"
    5. #include
    6. #include"db.h"
    7. #include
    8. #include
    9. #include"../common.h"
    10. #include
    11. #include
    12. #include"user.h"
    13. #define DEBUG
    14. //#define QUESTION_NUM 5
    15.  
    16. class MyServer:public TcpServer//继承
    17. {
    18. public:
    19.     MyServer();
    20.  
    21.     void connectEvent(TcpSocket *);
    22.  
    23.     void readEvent(TcpSocket *);
    24.  
    25.     void writeEvent(TcpSocket *);
    26.  
    27.     void closeEvent(TcpSocket *s, short);
    28.  
    29. private:
    30.     //发送数据
    31.     void writeData(TcpSocket *s,const Json::Value &inJson);
    32.  
    33.     //用户注册
    34.     void Register(TcpSocket *s,const Json::Value &inJson);
    35.  
    36.     //用户登录
    37.     void Login(TcpSocket *s,const Json::Value &inJson);
    38.  
    39.     //获取个人训练题目
    40.     void get_SingleQuestion(TcpSocket *s);
    41.  
    42.     //进行排位
    43.     void Rank(TcpSocket *s);
    44.  
    45.     //rank 回答一道问题
    46.     void rankAnswerOneQuestion(TcpSocket *s,const Json::Value &inJson);
    47.  
    48.     //开始对决
    49.     void startRank(TcpSocket *first,TcpSocket *second);
    50.  
    51.     //rank结果
    52.     void rankResult(TcpSocket *s, const Json::Value &inJson);
    53.  
    54.     //初始化rank积分对照表
    55.     void initRankMap();
    56.  
    57. private:
    58.     std::shared_ptr _log;//记录日志的句柄
    59.     DB* _db;//数据库句柄
    60.  
    61.     //键是用户名，值是用户指针
    62.     std::mutex _userLock;//锁_Users
    63.     std::map _users;    //在线用户列表
    64.  
    65.     //key : rank积分
    66.     //值  : 对应的段位说明
    67.     std::map<int,std::string> _rankMap;    //rank积分比对表
    68.  
    69.     //key   : rank积分
    70.     //value : 参与rank的用户socket句柄
    71.     std::mutex _rankLock;
    72.     std::map<int,TcpSocket*> _rankQueue;   //等待排位的队列
    73. };
    74.  
    75. #endif // MYSERVER_H

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

    tcpserver.cpp

    1. #include "tcpserver.h"
    2.  
    3. TcpServer::TcpServer(int threadNum):m_nextThread(0)//下标初始化为0
    4. {
    5.     if(threadNum<=0)
    6.     {
    7.         printf("threadNum<=0");
    8.         exit(-1);
    9.     }
    10.     m_threadNum=threadNum;
    11.     m_threadPool=new Thread[threadNum];
    12.     if(m_threadPool==NULL)
    13.     {
    14.         printf("create threadPool error\n");
    15.         exit(-1);
    16.     }
    17.     m_base=event_base_new();
    18.     if(!m_base)
    19.     {
    20.         printf("Could not initialize libevent!\n");
    21.         exit(-1);
    22.     }
    23. }
    24.  
    25. //evutil_socket_t fd:   与客户端通信的文件描述符
    26. //struct sockaddr *clientAdd:  客户端的IP地址，地址信息。
    27. void TcpServer::listenCb(struct evconnlistener *,evutil_socket_t fd,struct sockaddr *clientAdd,int ,void *data)
    28. {
    29.     TcpServer *p=(TcpServer*)data;
    30.     p->listenEvent(fd,(struct sockaddr_in *)clientAdd);
    31. }
    32.  
    33. void TcpServer::listenEvent(evutil_socket_t fd,struct sockaddr_in *clientAdd)
    34. {
    35.     char *ip     =inet_ntoa(clientAdd->sin_addr);//客户端的IP地址
    36.     uint16_t port=ntohs(clientAdd->sin_port);//客户端的使用的端口
    37.  
    38.     //从线程池中选择一个线程去处理客户端的请求
    39.     //以论寻的方式选择线程
    40.     struct event_base *base=m_threadPool[m_nextThread].getBase();
    41.     m_nextThread=(m_nextThread+1) % m_threadNum;
    42.  
    43.     //base监测fd
    44.     struct bufferevent *bev=bufferevent_socket_new(base,fd,BEV_OPT_CLOSE_ON_FREE);
    45.     if(!bev)
    46.     {
    47.         fprintf(stderr,"Error constructing bufferevent!");
    48.         event_base_loopbreak(base);
    49.         return;
    50.     }
    51.  
    52.     //创建一个对象
    53.     TcpSocket *s=new TcpSocket(this,bev,ip,port);
    54.  
    55.     //单独封装一个类负责和客户端的通信
    56.  
    57.     bufferevent_setcb(bev,s->readEventCb,s->writeEventCb,s->closeEventCb,s);
    58.     bufferevent_enable(bev,EV_WRITE);//打开是否可写
    59.     bufferevent_enable(bev,EV_READ);//打开是否可读
    60.     bufferevent_enable(bev,EV_SIGNAL);
    61.  
    62.     //调用客户端连接函数
    63.     connectEvent(s);
    64. }
    65.  
    66. int TcpServer::listen(int port,const char *ip)
    67. {
    68.     struct sockaddr_in sin;
    69.     memset(&sin,0,sizeof(sin));
    70.     sin.sin_family=AF_INET;
    71.     sin.sin_port=htons(port);
    72.     if(ip!=NULL)
    73.         inet_aton(ip,&sin.sin_addr);
    74.  
    75.     m_listener=evconnlistener_new_bind(m_base,listenCb,this,LEV_OPT_REUSEABLE | LEV_OPT_CLOSE_ON_FREE,-1,(struct sockaddr*)&sin,sizeof(sin));
    76.     if(!m_listener)
    77.     {
    78.         printf("Could not create a listener!\n");
    79.         return -1;
    80.     }
    81.  
    82.     //开启线程池
    83.     for(int i=0;i
    84.     {
    85.         m_threadPool[i].start();
    86.         printf("线程 %d 启动\n",i+1);
    87.     }
    88.     return 0;
    89. }
    90.  
    91. void TcpServer::start()
    92. {
    93.     event_base_dispatch(m_base);
    94.     evconnlistener_free(m_listener);
    95.     event_base_free(m_base);
    96.     printf("done\n");
    97. }

    thread.cpp

    1. #include "thread.h"
    2.  
    3. Thread::Thread()
    4. {
    5.     m_base=event_base_new();
    6.     if(!m_base)
    7.     {
    8.         printf("Couldn't creat an event_base:exiting\n");
    9.         exit(-1);
    10.     }
    11.     //在构造函数里创建管道
    12.     int fd[2];
    13.     if (pipe(fd) == -1)
    14.     {
    15.         perror("fork");
    16.         exit(-1);
    17.     }
    18.     //管道的读写端
    19.     m_pipeReadFd=fd[0];
    20.     m_pipeWriteFd=fd[1];
    21.  
    22.     //让管道事件监听管道的读端
    23.     //如果监听到，管道的读端有数据可读
    24.     //EV_READ:监听管道是否有可读事件
    25.     //EV_PERSIST:让事件永久有效，不然读完一次下次就不监听了
    26.     //pipeRead：管道事件来了之后自动调用这个函数，类似于槽函数
    27.     event_set(&m_pipeEvent,m_pipeReadFd,EV_READ | EV_PERSIST,pipeRead,this);
    28.  
    29.     //将事件添加到m_base集合中
    30.     event_base_set(m_base,&m_pipeEvent);
    31.  
    32.     //开始事件的监听
    33.     event_add(&m_pipeEvent,0);
    34.  
    35. }
    36.  
    37. void Thread::pipeRead(int, short, void *)
    38. {
    39.  
    40. }
    41.  
    42. void Thread::start()
    43. {
    44.     //创建线程
    45.     pthread_create(&m_threadId,NULL,worker,this);
    46.     //线程分离
    47.     pthread_detach(m_threadId);
    48. }
    49.  
    50. void* Thread::worker(void* arg)
    51. {
    52.     Thread* p=(Thread*)arg;
    53.     p->run();       //
    54.     return NULL;
    55. }
    56.  
    57. void Thread::run()
    58. {
    59. /*测试用的
    60.     while(1)
    61.     {
    62.         printf("thread:%d\n",m_threadId);
    63.         sleep(2);
    64.     }
    65. */
    66.     //printf("%d:start\n",m_threadId);
    67.     //监听base事件集合
    68.     //dispatch是一个死循环,一直监听。用来处理事件，类似于qt的exec（）
    69.     //如果m_base集合是空的，则event_base_dispatch不运行会立马返回
    70.     //初始化的时候需要给m_base添加一个事件，让它不空
    71.     event_base_dispatch(m_base);
    72.     event_base_free(m_base);
    73.  
    74.     //printf("%d:done\n",m_threadId);
    75. }
    76.  
    77. struct event_base *Thread::getBase()
    78. {
    79.     return m_base;
    80. }

    tcpsocket.cpp

    1. #include "tcpsocket.h"
    2.  
    3. TcpServer *TcpSocket::m_tcpServer=NULL;
    4.  
    5. TcpSocket::TcpSocket(TcpServer *tcpServer,struct bufferevent *bev,char *ip,u_int16_t port)
    6. {
    7.     m_tcpServer=tcpServer;
    8.     m_bev=bev;
    9.     m_ip=ip;
    10.     m_port=port;
    11. }
    12.  
    13. //可读事件的回调函数
    14. void TcpSocket::readEventCb(struct bufferevent *,void *etc)
    15. {
    16.     TcpSocket *s=(TcpSocket*)etc;
    17.     m_tcpServer->readEvent(s);
    18. }
    19.  
    20. //可写事件的回调函数
    21. void TcpSocket::writeEventCb(struct bufferevent *,void *etc)
    22. {
    23.     TcpSocket *s=(TcpSocket*)etc;
    24.     m_tcpServer->writeEvent(s);
    25. }
    26.  
    27. //异常事件的回调函数
    28. void TcpSocket::closeEventCb(struct bufferevent *,short what,void *etc)
    29. {
    30.     TcpSocket *s=(TcpSocket*)etc;
    31.     m_tcpServer->closeEvent(s,what);
    32.     delete s;
    33. }
    34.  
    35. char *TcpSocket::getIp()
    36. {
    37.     return m_ip;
    38. }
    39.  
    40. u_int16_t TcpSocket::getPort()
    41. {
    42.     return m_port;
    43. }
    44.  
    45. //从客户端读数据
    46. int TcpSocket::readDate(void *data,int size)
    47. {
    48.  
    49.     return bufferevent_read(m_bev,data,size);
    50. }
    51.  
    52. //向客户端写数据
    53. int TcpSocket::writeDate(const void *data,int size)
    54. {
    55.     return bufferevent_write(m_bev,data,size);
    56. }
    57.  
    58. void TcpSocket::setUserName(std::string name)
    59. {
    60.     _userName=name;
    61. }
    62.  
    63. std::string TcpSocket::getUserName()
    64. {
    65.     return _userName;
    66. }

    db.cpp

    1. #include "db.h"
    2.  
    3. DB::DB(const char *host, const char *userName, const char *passwd, const char *dbName)
    4. {
    5.     //初始化数据库句柄
    6.     _mysql =mysql_init(NULL);
    7.     if(_mysql==NULL)
    8.     {
    9.         spdlog::get("BrainStorm")->error("mysql_init error\n");
    10.         exit(-1);
    11.     }
    12.  
    13.     //连接数据库
    14.     MYSQL *con=mysql_real_connect(_mysql,host,userName,passwd,dbName,0,NULL,0);
    15.     if(con==NULL)
    16.     {
    17.         spdlog::get("BrainStorm")->error("连接数据库失败：{}",mysql_error(_mysql));
    18.         exit(-1);
    19.     }
    20.     _mysql=con;
    21.  
    22.     //设置字符集
    23.     int ret=mysql_query(_mysql,"set names utf8");//设置中文
    24.     if(ret!=0)
    25.     {
    26.         spdlog::get("BrainStorm")->error("设置字符集失败：%s",mysql_error(_mysql));
    27.         exit(-1);
    28.     }
    29.  
    30. }
    31.  
    32. bool DB::db_exec(const char *sql)
    33. {
    34.     std::unique_lock loc(_mutex);//智能锁，数据库句柄上锁
    35.     int ret=mysql_query(_mysql,sql);
    36.     if(ret!=0)
    37.     {
    38.         spdlog::get("BrainStorm")->error("mysql_query error：%s",mysql_error(_mysql));
    39.         return false;
    40.     }
    41.     return true;
    42. }
    43.  
    44. bool DB::db_select(const char *sql,Json::Value &outJson)
    45. {
    46.     std::unique_lock loc(_mutex);//智能锁，数据库句柄上锁
    47.     int ret=mysql_query(_mysql,sql);
    48.     if(ret!=0)
    49.     {
    50.         spdlog::get("BrainStorm")->error("mysql_query error：%s",mysql_error(_mysql));
    51.         return false;
    52.     }
    53.  
    54.     //从mysql服务器下载查询结果
    55.     MYSQL_RES *sql_res=mysql_store_result(_mysql);
    56.     if(sql_res==NULL)
    57.     {
    58.         if(mysql_errno(_mysql)==0)
    59.         {
    60.             return true;
    61.         }
    62.         else
    63.         {
    64.             spdlog::get("BrainStorm")->error("mysql_store_result error：%s",mysql_error(_mysql));
    65.         }
    66.     }
    67.  
    68.     //看字段，先看有多少列，
    69.     MYSQL_ROW row;//从结果集中一行一行获取
    70.     unsigned int num_fields=mysql_num_fields(sql_res);//获取列数
    71.     MYSQL_FIELD *fetch_field=mysql_fetch_field(sql_res);//获取表头（字段）
    72.  
    73.     //一行一行的获取数据结构
    74.     while(row=mysql_fetch_row(sql_res))//然后就要填这个数据结构
    75.     {
    76.         for(unsigned int i=0;i
    77.         {
    78.             outJson[fetch_field[i].name].append(row[i]);
    79.         }
    80.     }
    81.  
    82.     //获取完把结构给删掉
    83.     mysql_free_result(sql_res);
    84.  
    85.     return true;
    86. }

    user.cpp

    1. #include "user.h"
    2.  
    3. User::User(std::string n,std::string p,int rank,TcpSocket *s)
    4.     :_userName(n),_passwd(p),_rank(rank),_s(s)
    5. {
    6.  
    7. }
    8.  
    9. TcpSocket *User::getSocket()
    10. {
    11.     return _s;
    12. }
    13.  
    14. const char *User::getName()
    15. {
    16.     return _userName.c_str();
    17. }
    18.  
    19. int User::getRank()
    20. {
    21.     return _rank;
    22. }
    23.  
    24. void User::setRank(int rank)
    25. {
    26.     if(rank<=0)
    27.         rank=0;
    28.     _rank=rank;
    29. }

    myserver.cpp

    1. #include "myserver.h"
    2.  
    3. MyServer::MyServer()
    4. {
    5.     //日志
    6. #ifdef DEBUG//向控制台写
    7.     _log=spdlog::stdout_color_mt("console");
    8. #else
    9.     _log=spdlog::rotating_logger_mt("BrainStorm","BrainStorm",1024*1024*5,3);
    10.     _log->flush_on(spdlog::level::info);
    11. #endif
    12.     //_log->info("11111111111");//写在控制台
    13.  
    14.     _db=new DB(NULL,"xiaowang","xiaowang","BrainStorm");
    15.     initRankMap();
    16. }
    17.  
    18. void MyServer::connectEvent(TcpSocket *s)
    19. {
    20.     _log->info("有一个新的连接[{}:{}]\n",s->getIp(),s->getPort());
    21.     //printf("客户端连接%s","端口连接%s",s->getIp(),s->getPort());
    22. }
    23.  
    24. void MyServer::readEvent(TcpSocket *s)
    25. {
    26.     char buf[1024]={0};
    27.     while(1)
    28.     {
    29.         int len=0;
    30.         s->readDate(&len,sizeof(len));
    31.         if(len<=0)
    32.             break;
    33.         s->readDate(buf,len);
    34.         //数据解析
    35.         Json::Value root;
    36.         Json::Reader reader;//json解析器
    37.         if(!reader.parse(buf,root))
    38.         {
    39.             _log->error("json数据解析失败");
    40.             return;
    41.         }
    42.  
    43.         int cmd=root["cmd"].asInt();
    44.         switch (cmd)
    45.         {
    46.         case REGISTER:
    47.             Register(s,root);
    48.             break;
    49.         case LOGIN:
    50.             Login(s,root);
    51.             break;
    52.         case SINGLE_QUESTION:
    53.             get_SingleQuestion(s);
    54.             break;
    55.         case RANK:
    56.             Rank(s);
    57.             break;
    58.         case ANSWER:
    59.             rankAnswerOneQuestion(s,root);
    60.             break;
    61.         case RANKRESULT:
    62.             rankResult(s,root);
    63.             break;
    64.         default:
    65.             break;
    66.         }
    67.  
    68.     }
    69. }
    70.  
    71. void MyServer::writeEvent(TcpSocket *)
    72. {
    73.  
    74. }
    75.  
    76. void MyServer::closeEvent(TcpSocket *s,short)
    77. {
    78.     //将用户从 等待 rank 的列表中删除
    79.     {
    80.         std::unique_lock _lock(_rankLock);
    81.         int rank=_users[s->getUserName()]->getRank();
    82.         auto it=_rankQueue.find(rank);//然后从队列里面去找他
    83.         if(it != _rankQueue.end())
    84.             _rankQueue.erase(it);
    85.     }
    86.  
    87.     //printf("客户端退出,ip：%s,端口：%d\n",s->getIp(),s->getPort());
    88.     //_log->error("用户{}[{}:{}] logout",userName,s->getIp(),s->getPort());
    89.     std::unique_lock _lock(_userLock);
    90.     std::map::iterator it=_users.begin();
    91.     while(it!=_users.end())
    92.     {
    93.         if(it->second->getSocket()==s)
    94.         {
    95.             _users.erase(it);
    96.             _log->info("用户{}[{}:{}] logout",it->second->getName(),s->getIp(),s->getPort());
    97.             break;
    98.  
    99.             //移除完之后释放User
    100.             delete it->second;
    101.             return;
    102.         }
    103.  
    104.         it++;
    105.     }
    106.     _log->info("用户{}[{}:{}] logout",s->getIp(),s->getPort());
    107.  
    108. }
    109.  
    110. void MyServer::writeData(TcpSocket *s,const Json::Value &inJson)
    111. {
    112.     std::string data=inJson.toStyledString();
    113.     s->writeDate(data.c_str(),data.length());
    114. }
    115.  
    116. void MyServer::Register(TcpSocket *s,const Json::Value &inJson)
    117. {
    118.     std::string userName=inJson["userName"].asString();
    119.     std::string passwd=inJson["passwd"].asString();
    120.  
    121.     //检测用户是否已经存在
    122.     char sql[100]={0};
    123.     sprintf(sql,"select *from user where name='%s' and passwd='%s'",userName.c_str(),passwd.c_str());
    124.  
    125.     int result=OK;
    126.     Json::Value outJson;
    127.     bool ret=_db->db_select(sql,outJson);
    128.     if(!ret)
    129.     {
    130.         result=ERROR;
    131.         _log->error("Register select user error");
    132.     }
    133.  
    134.     if(outJson.isMember("name"))    //用户存在，表明已经做过了
    135.         result=USEREXIST;
    136.     else
    137.     {
    138.         sprintf(sql,"insert into user(name,passwd,rank) values('%s','%s',0)",userName.c_str(),passwd.c_str());
    139.         bool ret=_db->db_exec(sql);
    140.         if(!ret)
    141.         {
    142.             result=ERROR;
    143.             _log->error("Register insert user error");
    144.         }
    145.         else
    146.             _log->info("Register user={} succeed",userName);
    147.  
    148.     }
    149.  
    150.     //最后整合数据
    151.     Json::Value json;
    152.     json ["cmd"]=REGISTER;
    153.     json ["result"]=result;
    154.  
    155.     writeData(s,json);
    156.  
    157. }
    158.  
    159. void MyServer::Login(TcpSocket *s,const Json::Value &inJson)
    160. {
    161.     std::string userName=inJson["userName"].asString();
    162.     std::string passwd=inJson["passwd"].asString();
    163.     int rank=0;
    164.  
    165.     //检测用户是否已经登录
    166.  
    167.     char sql[100]={0};
    168.     sprintf(sql,"select *from user where name='%s' and passwd='%s'",userName.c_str(),passwd.c_str());
    169.  
    170.     int result=OK;
    171.     Json::Value outJson;
    172.     bool ret=_db->db_select(sql,outJson);
    173.     if(!ret)
    174.     {
    175.         result=ERROR;
    176.         _log->error("Login select user error");
    177.     }
    178.  
    179.     if(outJson.isMember("name"))    //用户存在，表明已经注册了
    180.     {
    181.         std::unique_lock _lock(_userLock);//先上一把锁
    182.         if(_users.find(userName)!=_users.end())//用户已经登录
    183.             result=USERLOGIN;
    184.         else
    185.         {
    186.             int i=0;
    187.             rank=atoi(outJson["rank"][i].asString().c_str());
    188.             User* user=new User(userName,passwd,rank,s);
    189.             _users.insert(make_pair(userName,user));//用户创建完，把他放进列表里,user为指针
    190.             _log->info("用户{}[{}:{}] login",userName,s->getIp(),s->getPort());
    191.             s->setUserName(userName);
    192.         }
    193.     }
    194.     else
    195.         result=NAMEORPASSWD;
    196.  
    197.     //最后整合数据
    198.     Json::Value json;
    199.     json ["cmd"]     =LOGIN;
    200.     json ["result"]  =result;
    201.     json ["userName"]=userName;
    202.     json ["rank"]    =_rankMap[rank];
    203.  
    204.     writeData(s,json);
    205. }
    206.  
    207. void MyServer::get_SingleQuestion(TcpSocket *s)
    208. {
    209.     char sql[100]={0};
    210.     sprintf(sql,"select * from question order by rand() limit %d",QUESTION_NUM);
    211.  
    212.     int result=OK;
    213.     Json::Value outJson;
    214.     bool ret=_db->db_select(sql,outJson);
    215.     if(!ret || outJson["question"].size()!=QUESTION_NUM)
    216.     {
    217.         result=ERROR;
    218.         _log->error("get_SingleQuestion select question error");
    219.     }
    220.  
    221.     Json::Value json;
    222.     json ["cmd"]     =SINGLE_QUESTION;
    223.     json ["result"]  =result;
    224.     json ["question"]=outJson;
    225.  
    226.     _log->info("用户{}[{}:{}] 获取题目: {}\n",s->getUserName(),s->getIp(),s->getPort(),json.toStyledString());
    227.  
    228.     //服务器把数据发送给客户端
    229.     writeData(s,json);
    230. }
    231.  
    232. void MyServer::startRank(TcpSocket *first,TcpSocket *second)
    233. {
    234.     char sql[100]={0};
    235.     sprintf(sql,"select * from question order by rand() limit %d",QUESTION_NUM);
    236.  
    237.     int result=OK;
    238.     Json::Value outJson;
    239.     bool ret=_db->db_select(sql,outJson);
    240.     if(!ret || outJson["question"].size()!=QUESTION_NUM)
    241.     {
    242.         result=ERROR;
    243.         _log->error("startRank select question error");
    244.     }
    245.  
    246.     Json::Value json;
    247.     json ["cmd"]     =RANK;
    248.     json ["result"]  =result;
    249.     json ["question"]=outJson;
    250.  
    251.     //first user
    252.     json ["enemyName"] =second->getUserName();
    253.     json ["enemyRank"] =_rankMap[_users[second->getUserName()]->getRank()];
    254.     json ["enemyScore"]=0;
    255.     writeData(first,json);
    256.  
    257.     //second user
    258.     json ["enemyName"] =first->getUserName();
    259.     json ["enemyRank"] =_rankMap[_users[first->getUserName()]->getRank()];
    260.     writeData(second,json);
    261.  
    262.     _log->info(" 获取 rank 题目: {}\n",json.toStyledString());
    263. }
    264.  
    265. void MyServer::Rank(TcpSocket *s)
    266. {
    267.     TcpSocket *other=NULL;//对手
    268.     int rank=_users[s->getUserName()]->getRank();//当前用户 rank 积分
    269.  
    270.     std::unique_lock lock(_rankLock);
    271.     //查找同一段位的对手
    272.     std::map<int,TcpSocket*>::iterator it=_rankQueue.find(rank);
    273.     if(it!=_rankQueue.end())//找到了
    274.     {
    275.         other=it->second;
    276.         _rankQueue.erase(it);
    277.     }
    278.     else
    279.     {
    280.         //查找其他段位的选手 积分差值的绝对值小于5的都可以进行对决
    281.         for(int i=0;i<=5;i++)
    282.         {
    283.             it=_rankQueue.find(rank+i);
    284.             if(it!=_rankQueue.end())
    285.             {
    286.                 other=it->second;
    287.                 _rankQueue.erase(it);
    288.                 break;
    289.             }
    290.             it=_rankQueue.find(rank-i);
    291.             if(it!=_rankQueue.end())
    292.             {
    293.                 other=it->second;
    294.                 _rankQueue.erase(it);
    295.                 break;
    296.             }
    297.         }
    298.     }
    299.     _log->info("rank 分数：{}",rank);
    300.     if(other==NULL)//没有匹配到用户
    301.     {
    302.         _rankQueue.insert(std::make_pair(rank,s));
    303.         _log->info("当前等候 rank 人数：{}",_rankQueue.size());
    304.  
    305.     }
    306.     else//找到
    307.     {
    308.         //开始对决
    309.         startRank(s,other);
    310.     }
    311. }
    312.  
    313. void MyServer::rankAnswerOneQuestion(TcpSocket *s,const Json::Value &inJson)
    314. {
    315.     std::string enemyName=inJson["enemyName"].asString();
    316.     User *user=_users[enemyName];
    317.  
    318.     Json::Value json;
    319.     json ["cmd"]            =ANSWER;
    320.     json ["enemyscore"]     =inJson["score"].asInt();
    321.     json ["enemyQuestionId"]=inJson["questionId"].asInt();
    322.  
    323.     writeData(user->getSocket(),json);
    324. }
    325.  
    326. void MyServer::rankResult(TcpSocket *s,const Json::Value &inJson)
    327. {
    328.     std::unique_lock lock(_userLock);
    329.     User *user=_users[s->getUserName()];
    330.  
    331.     int score     =inJson["score"].asInt();
    332.     int enemyscore=inJson["enemyscore"].asInt();
    333.  
    334.     if(score
    335.         user->setRank(user->getRank()-1);
    336.     else if(score>enemyscore)
    337.         user->setRank(user->getRank()+1);
    338.  
    339.     Json::Value json;
    340.     json ["cmd"]     =RANKRESULT;
    341.     json ["newRank"] =_rankMap[user->getRank()];
    342.  
    343.     writeData(s,json);//发送给客户端
    344. }
    345.  
    346. void MyServer::initRankMap()
    347. {
    348.     char buf[100]={0};
    349.     int rank=0;
    350.     int num=0;
    351.     for(int i=0;i<100;i++)
    352.     {
    353.         if(i<9)
    354.         {
    355.             rank=i/3;
    356.             num=i%3;
    357.             sprintf(buf,"青铜%d %d颗星",3-rank,num+1);
    358.         }
    359.         else if(9<=i && i<18)
    360.         {
    361.             rank=(i-9)/3;
    362.             num=(i-9)%3;
    363.             sprintf(buf,"白银%d %d颗星",3-rank,num+1);
    364.         }
    365.         else if(9<=i && i<18)
    366.         {
    367.             rank=(i-9)/4;
    368.             num=(i-9)%4;
    369.             sprintf(buf,"黄金%d %d颗星",4-rank,num+1);
    370.         }
    371.         else if(18<=i && i<34)
    372.         {
    373.             rank=(i-18)/4;
    374.             num=(i-18)%4;
    375.             sprintf(buf,"铂金%d %d颗星",4-rank,num+1);
    376.         }
    377.         else if(34<=i && i<50)
    378.         {
    379.             rank=(i-34)/5;
    380.             num=(i-34)%5;
    381.             sprintf(buf,"钻石%d %d颗星",5-rank,num+1);
    382.         }
    383.         else if(50<=i && i<75)
    384.         {
    385.             rank=(i-50)/5;
    386.             num=(i-50)%5;
    387.             sprintf(buf,"星曜%d %d颗星",5-rank,num+1);
    388.         }
    389.         _rankMap.insert(std::make_pair(i,buf));
    390.     }
    391.  
    392.     /*
    393.     for(int i=0;i<100;i++)
    394.     {
    395.         std::cout<
    396.     }
    397.     */
    398.  
    399. }

    main.cpp

    1. #include 
    2. #include"thread.h"
    3. #include"tcpserver.h"
    4. #include"myserver.h"
    5.  
    6. using namespace std;
    7.  
    8. int main1()
    9. {
    10.     Thread *pt1=new Thread;
    11.     Thread *pt2=new Thread;
    12.  
    13.     pt1->start();
    14.     pt2->start();
    15.  
    16.     while(1)
    17.     {
    18.         printf("1111\n");
    19.         sleep(1);
    20.     }
    21.     return 0;
    22. }
    23.  
    24. int main2()
    25. {
    26.     TcpServer s;
    27.     s.listen(9999);
    28.     s.start();
    29.     return 0;
    30. }
    31.  
    32. int main()
    33. {
    34.     MyServer s;
    35.     s.listen(9999);
    36.     s.start();
    37.     return 0;
    38. }

    Client客户端

    Client.pro

    补上需要的代码：

    1.  
    2.  
    3. QT       += core gui network
    4.

    register.h

    1. #ifndef REGISTER_H
    2. #define REGISTER_H
    3.  
    4. #include 
    5. #include
    6. #include"communicate.h"
    7. #include"../common.h"
    8.  
    9. namespace Ui {
    10. class Register;
    11. }
    12.  
    13. class Register : public QDialog
    14. {
    15.     Q_OBJECT
    16.  
    17. public:
    18.     explicit Register(Communicate *com,QWidget *parent = 0);
    19.     ~Register();
    20.  
    21. private slots:
    22.     void on_RegNButton_clicked();
    23.  
    24.     void on_BackButton_clicked();
    25.  
    26.     void rstResult(int);
    27.  
    28. private:
    29.     Ui::Register *ui;
    30.     Communicate *_com;
    31. };
    32.  
    33. #endif // REGISTER_H

    login.h

    1. #ifndef WIDGET_H
    2. #define WIDGET_H
    3.  
    4. #include 
    5. #include"register.h"
    6. #include"communicate.h"
    7.  
    8.  
    9. namespace Ui {
    10. class Widget;
    11. }
    12.  
    13. class Widget : public QWidget
    14. {
    15.     Q_OBJECT
    16.  
    17. public:
    18.     explicit Widget(QWidget *parent = 0);
    19.     ~Widget();
    20.  
    21. private slots:
    22.     void on_LogButton_clicked();
    23.  
    24.     void on_RegButton_clicked();
    25.  
    26.     void login(QJsonObject json);
    27.  
    28. private:
    29.     Ui::Widget *ui;
    30.  
    31.     Communicate *_com;//通信类指针，负责和服务器通信
    32. };
    33.  
    34. #endif // WIDGET_H

    communicate.h

    1. #ifndef COMMUNICATE_H
    2. #define COMMUNICATE_H
    3.  
    4. #include 
    5. #include
    6. #include
    7. #include
    8. #include"../common.h"
    9. #include
    10.  
    11. class Communicate : public QObject
    12. {
    13.     Q_OBJECT
    14. public:
    15.     explicit Communicate(QObject *parent = nullptr);
    16.     void writeData(const QJsonObject &json);
    17.  
    18. signals:
    19.     void rstResult(int );
    20.     void login(QJsonObject json);
    21.     void receiveSingleQuestion(QJsonObject json);
    22.  
    23.     void Rank(QJsonObject json);
    24.  
    25. public slots:
    26.     void readData();
    27.  
    28.  
    29. private:
    30.     QTcpSocket s;
    31.  
    32. };
    33.  
    34. #endif // COMMUNICATE_H

    brainstorm.h

    1. #ifndef BRAINSTORM_H
    2. #define BRAINSTORM_H
    3.  
    4. #include 
    5. #include"communicate.h"
    6. #include
    7. #include
    8.  
    9. namespace Ui {
    10. class BrainStorm;
    11. }
    12.  
    13. class BrainStorm : public QDialog
    14. {
    15.     Q_OBJECT
    16.  
    17. public:
    18.     explicit BrainStorm(Communicate *_com,QJsonObject &json,QWidget *parent = 0);
    19.     ~BrainStorm();
    20.  
    21. private:
    22.     //单人训练，从服务器获取题目
    23.     void getSingleQuestion();
    24.  
    25.     //单人训练设置问题
    26.     void SingleSetQuestion();
    27.  
    28.     //单人训练答题
    29.     void SingleAnswerQuestion(int select);
    30.  
    31.     //设置得分
    32.     void setEnemyScore();
    33.     void setSelfScore();
    34. 	
    35. 	//--------------------------------------------------------
    36.  
    37.     //rank设置问题
    38.     void rankSetQuestion();
    39.  
    40.     //rank结果
    41.     void rankSetResult(QJsonObject &json);
    42.  
    43.     //rank答题
    44.     void RankAnswerQuestion(int select);
    45.  
    46. private slots:
    47.     void on_RankButton_clicked();
    48.  
    49.     void on_SingleButton_clicked();
    50.  
    51.     void on_SingleBack_clicked();
    52.  
    53.     void on_SingleStart_clicked();
    54.  
    55.     //单人训练从服务器接收到题目
    56.     void receiveSingleQuestion(QJsonObject json);
    57.     //个人训练计时器
    58.     void SingleTimerOut();
    59.  
    60.     void on_OverBack_clicked();
    61.  
    62.     void on_SingleButtonA_clicked();
    63.  
    64.     void on_SingleButtonB_clicked();
    65.  
    66.     void on_SingleButtonC_clicked();
    67.  
    68.     void on_SingleButtonD_clicked();
    69. 	
    70. //----------------------------------------------------------------------
    71.  
    72.     //接受排位
    73.     void Rank(QJsonObject json);
    74.  
    75.     //排位计时器
    76.     void RankTimerOut();
    77.  
    78.     void on_RankButtonA_clicked();
    79.  
    80.     void on_RankButtonB_clicked();
    81.  
    82.     void on_RankButtonC_clicked();
    83.  
    84.     void on_RankButtonD_clicked();
    85.  
    86.     void on_overButton_clicked();
    87.  
    88. private:
    89.     Ui::BrainStorm *ui;
    90.     Communicate    *_com;    //通信类指针，负责和服务器通信
    91.  
    92.     QJsonObject    _singleQuestion;
    93.     int            _currentSingleQuestion;//当前回答哪一个问题的下标
    94.     QTimer         _singleTimer;     //个人训练定时器
    95.     int            _singleSec;           //个人训练答题时间
    96.     int            _singleScore;         //个人训练得分
    97.  
    98.     //----------------------Rank---------------------
    99.     QJsonObject _rankQuestion;   //rank的题
    100.     QString     _enemyName;//对手的名字
    101.     QString     _enemyRank;//对手的段位
    102.     int         _enemyScore;   //对手的得分
    103.  
    104.     int _rankSec;     //rank 答题计时
    105.     int _myScore;     //自己的得分
    106.  
    107.     QString _userName;//自己的名字
    108.     QString _userRank;//自己的段位
    109.  
    110.     int _currentRankQuestion;//当前回答哪一个问题的下标
    111.  
    112.     int _enemyRankQuestion;//对手当前回答问题的下标
    113.  
    114.     QTimer _rankTimer;     //排位定时器
    115.  
    116. };
    117.  
    118. #endif // BRAINSTORM_H

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

    register.cpp

    1. #include "register.h"
    2. #include "ui_register.h"
    3. #include
    4.  
    5. Register::Register(Communicate *com,QWidget *parent) :
    6.     QDialog(parent),
    7.     ui(new Ui::Register)
    8. {
    9.     ui->setupUi(this);
    10.     _com=com;
    11.  
    12.     connect(_com,SIGNAL(rstResult(int)),this,SLOT(rstResult(int)));
    13. }
    14.  
    15. Register::~Register()
    16. {
    17.     delete ui;
    18. }
    19.  
    20. void Register::on_RegNButton_clicked()
    21. {
    22.     QString userName=ui->UserlineEdit->text();
    23.     QString passwd=ui->PasswdlineEdit->text();
    24.  
    25.     //发送注册信息
    26.     QJsonObject json;
    27.     json["cmd"]=REGISTER;
    28.     json["userName"]=userName;
    29.     json["passwd"]=passwd;
    30.  
    31.     //给服务器发送数据
    32.     _com->writeData(json);
    33. }
    34.  
    35. void Register::rstResult(int ret)
    36. {
    37.     switch (ret)
    38.     {
    39.     case OK:
    40.         QMessageBox::information(this,"注册","注册成功");
    41.         break;
    42.     case ERROR:
    43.         QMessageBox::critical(this,"注册","注册失败,未知错误");
    44.         break;
    45.     case USEREXIST:
    46.         QMessageBox::critical(this,"注册","注册失败,用户存在");
    47.         break;
    48.     default:
    49.         break;
    50.     }
    51. }
    52.  
    53. void Register::on_BackButton_clicked()
    54. {
    55.     close();
    56. }

    login.cpp

    1. #include "login.h"
    2. #include "ui_widget.h"
    3. #include"register.h"
    4. #include
    5. #include"brainstorm.h"
    6. #include"../common.h"
    7.  
    8. Widget::Widget(QWidget *parent) :
    9.     QWidget(parent),
    10.     ui(new Ui::Widget)
    11. {
    12.     ui->setupUi(this);
    13.     _com=new Communicate();
    14.  
    15.     connect(_com,SIGNAL(login(QJsonObject)),this,SLOT(login(QJsonObject)));
    16. }
    17.  
    18. Widget::~Widget()
    19. {
    20.     delete ui;
    21. }
    22.  
    23. void Widget::on_LogButton_clicked()
    24. {
    25.     QString userName=ui->UserlineEdit->text();
    26.     QString passwd=ui->PasswdlineEdit->text();
    27.  
    28.     //将登录信息发送给服务器
    29.     QJsonObject json;
    30.     json["cmd"]=LOGIN;
    31.     json["userName"]=userName;
    32.     json["passwd"]=passwd;
    33.  
    34.     //给服务器发送数据
    35.     _com->writeData(json);
    36.  
    37.  
    38. }
    39.  
    40. void Widget::login(QJsonObject json)
    41. {
    42.     int result=json["result"].toInt();
    43.     switch (result)
    44.     {
    45.     case OK:
    46.     {
    47.         this->hide();
    48.         BrainStorm *dlg=new BrainStorm(_com,json);
    49.         dlg->show();
    50.         dlg->setAttribute(Qt::WA_DeleteOnClose);//属性，把new出来的自己销毁
    51.         break;
    52.     }
    53.     case ERROR:
    54.         QMessageBox::critical(this,"登录","登录失败,未知错误");
    55.         break;
    56.     case USERLOGIN:
    57.         QMessageBox::critical(this,"登录","登录失败,不允许重复登录");
    58.         break;
    59.     case NAMEORPASSWD:
    60.         QMessageBox::critical(this,"登录","用户名或密码错误");
    61.         break;
    62.     default:
    63.         break;
    64.     }
    65. }
    66.  
    67. void Widget::on_RegButton_clicked()
    68. {
    69.     this->hide();
    70.     Register reg(_com);
    71.     reg.exec();
    72.     this->show();
    73. }

    communicate.cpp

    1. #include "communicate.h"
    2. #include
    3.  
    4. Communicate::Communicate(QObject *parent) : QObject(parent)
    5. {
    6.     //连接服务器
    7.     s.connectToHost(QHostAddress("***.***.***.***"),****);
    8.  
    9.     connect(&s,SIGNAL(readyRead()),this,SLOT(readData()));
    10. }
    11.  
    12. void Communicate::readData()
    13. {
    14.     QByteArray data;
    15.     while(s.bytesAvailable())
    16.     {
    17.         data +=s.readAll();//读完
    18.     }
    19.  
    20.     //数据解析
    21.     QJsonDocument dt=QJsonDocument::fromJson(data);//通过QJsonDocument转换成json字符串
    22.     if(dt.isNull())//没有读到数据
    23.     {
    24.         return;
    25.     }
    26.  
    27.     QJsonObject root=dt.object();//拿到json这样的一个对象
    28.  
    29.     //具体的逻辑处理
    30.     int cmd=root["cmd"].toInt();
    31.     switch (cmd)
    32.     {
    33.     case REGISTER:
    34.         emit rstResult(root["result"].toInt());//发给注册那一端
    35.         break;
    36.     case LOGIN:
    37.         emit login(root);//发给注册那一端
    38.         break;
    39.     case SINGLE_QUESTION:
    40.         emit receiveSingleQuestion(root["question"].toObject());
    41.         break;
    42.     case RANK:
    43.         emit Rank(root);
    44.         break;
    45.     case ANSWER:
    46.         emit Rank(root);
    47.         break;
    48.     case RANKRESULT:
    49.         emit Rank(root);
    50.         break;
    51.     default:
    52.         break;
    53.     }
    54. }
    55.  
    56. void Communicate::writeData(const QJsonObject &json)
    57. {
    58.     QJsonDocument d(json);
    59.     QByteArray sendData=d.toJson();
    60.     int len=sendData.size();
    61.  
    62.     s.write((char *)&len,sizeof(int));//发送数据长度
    63.     s.write(sendData);//发送数据
    64. }

    brainstorm.cpp

    1. #include "brainstorm.h"
    2. #include "ui_brainstorm.h"
    3.  
    4. BrainStorm::BrainStorm(Communicate *com, QJsonObject &json, QWidget *parent) :
    5.     QDialog(parent),
    6.     ui(new Ui::BrainStorm)
    7. {
    8.     ui->setupUi(this);
    9.     _com=com;
    10.  
    11.     _userName=json["userName"].toString();
    12.     _userRank=json["rank"].toString();
    13.  
    14.     connect(&_singleTimer,SIGNAL(timeout()),this,SLOT(SingleTimerOut()));
    15.     connect(&_rankTimer,SIGNAL(timeout()),this,SLOT(RankTimerOut()));
    16.  
    17.     connect(_com,SIGNAL(receiveSingleQuestion(QJsonObject)),this,SLOT(receiveSingleQuestion(QJsonObject)));
    18.     connect(_com,SIGNAL(Rank(QJsonObject)),this,SLOT(Rank(QJsonObject)));
    19.  
    20. }
    21.  
    22. BrainStorm::~BrainStorm()
    23. {
    24.     delete ui;
    25. }
    26.  
    27. //进入个人训练赛
    28. void BrainStorm::on_SingleButton_clicked()
    29. {
    30.     ui->stackedWidget->setCurrentWidget(ui->SingleMenu);
    31. }
    32.  
    33. //个人训练计时器
    34. void BrainStorm::SingleTimerOut()
    35. {
    36.     --_singleSec;
    37.     if(_singleSec==0)
    38.     {
    39.         ui->Singleresult->setText("回答错误");
    40.         QString str=QString("本次得分：%1").arg(_singleScore);
    41.         ui->Singlescore->setText(str);
    42.         _singleTimer.stop();
    43.         ui->stackedWidget->setCurrentWidget(ui->SingleScore);
    44.     }
    45.     ui->lcdNumber->display(_singleSec);
    46.  
    47. }
    48.  
    49. //单人训练，从服务器获取题目
    50. void BrainStorm::getSingleQuestion()
    51. {
    52.     QJsonObject json;
    53.     json["cmd"]=SINGLE_QUESTION;
    54.  
    55.     _com->writeData(json);
    56.  
    57. }
    58.  
    59. //单人训练设置问题
    60. void BrainStorm::SingleSetQuestion()
    61. {
    62.     //题目结束
    63.     if(_currentSingleQuestion==QUESTION_NUM)
    64.     {
    65.         ui->Singleresult->setText("恭喜全部答对");
    66.         QString str=QString("本次得分：%1").arg(_singleScore);
    67.         ui->Singlescore->setText(str);
    68.         ui->stackedWidget->setCurrentWidget(ui->SingleScore);
    69.         _singleTimer.stop();
    70.         return;
    71.     }
    72.     ui->SingleQuestion->setText(_singleQuestion["question"].toArray().at(_currentSingleQuestion).toString());
    73.     ui->SingleButtonA->setText(_singleQuestion["selectionA"].toArray().at(_currentSingleQuestion).toString());
    74.     ui->SingleButtonB->setText(_singleQuestion["selectionB"].toArray().at(_currentSingleQuestion).toString());
    75.     ui->SingleButtonC->setText(_singleQuestion["selectionC"].toArray().at(_currentSingleQuestion).toString());
    76.     ui->SingleButtonD->setText(_singleQuestion["selectionD"].toArray().at(_currentSingleQuestion).toString());
    77. }
    78.  
    79. //单人训练答题
    80. void BrainStorm::SingleAnswerQuestion(int select)
    81. {
    82.     //回答正确
    83.     if(select==_singleQuestion["answer"].toArray().at(_currentSingleQuestion).toString().toInt())
    84.     {
    85.         _singleScore +=20*_singleSec;
    86.         _currentSingleQuestion++;
    87.         SingleSetQuestion();  //设置下一题
    88.         _singleSec=10;
    89.         _singleTimer.stop();
    90.         ui->lcdNumber->display(_singleSec);
    91.         _singleTimer.start(1000);
    92.     }
    93.     else//回答错误
    94.     {
    95.         ui->Singleresult->setText("回答错误");
    96.         QString str=QString("本次得分：%1").arg(_singleScore);
    97.         ui->Singlescore->setText(str);
    98.         ui->stackedWidget->setCurrentWidget(ui->SingleScore);
    99.         _singleTimer.stop();
    100.     }
    101. }
    102.  
    103. //单人训练从服务器接收到题目
    104. void BrainStorm::receiveSingleQuestion(QJsonObject json)
    105. {
    106.     _singleQuestion=json;
    107.     _singleSec=10;
    108.     _currentSingleQuestion=0;
    109.     _singleScore=0;
    110.  
    111.     ui->lcdNumber->display(_singleSec);
    112.     SingleSetQuestion();
    113.  
    114.     //开启定时器
    115.     _singleTimer.start(1000);
    116.  
    117.     ui->stackedWidget->setCurrentWidget(ui->SingleRuning);
    118. }
    119.  
    120. //从个人训练返回
    121. void BrainStorm::on_SingleBack_clicked()
    122. {
    123.     ui->stackedWidget->setCurrentWidget(ui->MainMenu);
    124. }
    125.  
    126. //个人训练赛开始答题
    127. void BrainStorm::on_SingleStart_clicked()
    128. {
    129.     getSingleQuestion();
    130. }
    131.  
    132. void BrainStorm::on_OverBack_clicked()
    133. {
    134.     ui->stackedWidget->setCurrentWidget(ui->MainMenu);
    135. }
    136.  
    137. void BrainStorm::on_SingleButtonA_clicked()
    138. {
    139.     SingleAnswerQuestion(1);
    140. }
    141.  
    142. void BrainStorm::on_SingleButtonB_clicked()
    143. {
    144.     SingleAnswerQuestion(2);
    145. }
    146.  
    147. void BrainStorm::on_SingleButtonC_clicked()
    148. {
    149.     SingleAnswerQuestion(3);
    150. }
    151.  
    152. void BrainStorm::on_SingleButtonD_clicked()
    153. {
    154.     SingleAnswerQuestion(4);
    155. }
    156.  
    157. //--------------------------------------rank------------------------------------------
    158.  
    159. //排位赛
    160. void BrainStorm::on_RankButton_clicked()
    161. {
    162.     QJsonObject json;
    163.     json["cmd"]=RANK;
    164.  
    165.     _com->writeData(json);
    166.  
    167.     //跳到等待页面
    168.     ui->stackedWidget->setCurrentWidget(ui->RankWait);
    169. }
    170.  
    171. void BrainStorm::RankTimerOut()
    172. {
    173.     _rankSec--;
    174.     if(_rankSec==0)
    175.     {
    176.         if(ui->RankButtonA->isEnabled())//判断随便一个按钮状态
    177.         {
    178.             _currentRankQuestion++;
    179.         }
    180.         rankSetQuestion();
    181.         _rankSec=10;
    182.     }
    183.     ui->lcdNumber_2->display(_rankSec);
    184. }
    185.  
    186. void BrainStorm::setEnemyScore()
    187. {
    188.     QString str=QString("%1(%2):%3").arg(_enemyName,-5).arg(_enemyRank).arg(_enemyScore);
    189.     ui->enemyStatus->setText(str);
    190. }
    191.  
    192. void BrainStorm::setSelfScore()
    193. {
    194.     QString str=QString("%1(%2):%3").arg(_userName,-5).arg(_userRank).arg(_myScore);
    195.     ui->selfStatus->setText(str);
    196. }
    197.  
    198. void BrainStorm::rankSetQuestion()
    199. {
    200.     ui->RankQuestion->setText(_rankQuestion["question"].toArray().at(_currentRankQuestion).toString());
    201.     ui->RankButtonA->setText(_rankQuestion["selectionA"].toArray().at(_currentRankQuestion).toString());
    202.     ui->RankButtonB->setText(_rankQuestion["selectionB"].toArray().at(_currentRankQuestion).toString());
    203.     ui->RankButtonC->setText(_rankQuestion["selectionC"].toArray().at(_currentRankQuestion).toString());
    204.     ui->RankButtonD->setText(_rankQuestion["selectionD"].toArray().at(_currentRankQuestion).toString());
    205.  
    206.     ui->RankButtonA->setEnabled(true);
    207.     ui->RankButtonB->setEnabled(true);
    208.     ui->RankButtonC->setEnabled(true);
    209.     ui->RankButtonD->setEnabled(true);
    210.  
    211.     ui->RankButtonA->setStyleSheet("");
    212.     ui->RankButtonB->setStyleSheet("");
    213.     ui->RankButtonC->setStyleSheet("");
    214.     ui->RankButtonD->setStyleSheet("");
    215.  
    216.     if(_currentRankQuestion==QUESTION_NUM)
    217.     {
    218.         _rankTimer.stop();
    219.         //将结果发给服务器
    220.         QJsonObject json;
    221.         json["cmd"]       =RANKRESULT;
    222.         json["score"]     =_myScore;
    223.         json["enemyName"] =_enemyName;
    224.         json["enemyScore"]=_enemyScore;
    225.  
    226.         _com->writeData(json);
    227.     }
    228. }
    229.  
    230. void BrainStorm::rankSetResult(QJsonObject &json)
    231. {
    232.     QString newRank=json["newRank"].toString();
    233.     if(_myScore==_enemyScore)
    234.         ui->rankResult->setText("平局");
    235.     else if(_myScore<_enemyScore)
    236.         ui->rankResult->setText("失败");
    237.     else if(_myScore>_enemyScore)
    238.         ui->rankResult->setText("成功");
    239.  
    240.     QString str=QString("%1 ---> %2").arg(_userRank).arg(newRank);
    241.     ui->newRank->setText(str);
    242.     _userRank=newRank;
    243.  
    244.     ui->stackedWidget->setCurrentWidget(ui->RankResult);
    245. }
    246.  
    247. void BrainStorm::Rank(QJsonObject json)
    248. {
    249.     int cmd=json["cmd"].toInt();
    250.     if(cmd==RANK)
    251.     {
    252.         _rankQuestion=json["question"].toObject();
    253.         _enemyName   =json["enemyName"].toString();
    254.         _enemyRank   =json["enemyRank"].toString();
    255.         _enemyScore  =json["enemyScore"].toInt();
    256.  
    257.         _rankSec=10;
    258.         _myScore=0;
    259.         ui->lcdNumber_2->display(_rankSec);
    260.  
    261.         _currentRankQuestion=0;
    262.         _enemyRankQuestion  =0;
    263.  
    264.         setEnemyScore();
    265.         setSelfScore();
    266.         rankSetQuestion();
    267.  
    268.         _rankTimer.start(1000);
    269.  
    270.         ui->stackedWidget->setCurrentWidget(ui->RankRunning);
    271.     }
    272.     else if(cmd==ANSWER)//同步答题
    273.     {
    274.         _enemyScore       =json["enemyscore"].toInt();
    275.         _enemyRankQuestion=json["enemyQuestionId"].toInt();
    276.         setEnemyScore();
    277.  
    278.         if(_currentRankQuestion==_enemyRankQuestion)
    279.         {
    280.             _rankSec=10;
    281.             _rankTimer.stop();
    282.             ui->lcdNumber_2->display(_rankSec);
    283.             _rankTimer.start(1000);
    284.             rankSetQuestion();
    285.         }
    286.     }
    287.     else if(cmd==RANKRESULT)
    288.     {
    289.         rankSetResult(json);
    290.     }
    291. }
    292.  
    293. void BrainStorm::RankAnswerQuestion(int select)
    294. {
    295.     //计算得分
    296.     if(select==_rankQuestion["answer"].toArray().at(_currentRankQuestion).toString().toInt())
    297.         _myScore +=20*_rankSec;
    298.     setSelfScore();
    299.     _currentRankQuestion++;
    300.     //判断是否跳到下一题
    301.     if(_currentRankQuestion==_enemyRankQuestion)
    302.     {
    303.         _rankSec=10;
    304.         _rankTimer.stop();
    305.         ui->lcdNumber_2->display(_rankSec);
    306.         _rankTimer.start(1000);
    307.         rankSetQuestion();
    308.     }
    309.  
    310.     QJsonObject json;
    311.     json["cmd"]      =ANSWER;
    312.     json["enemyName"]=_enemyName;
    313.     json["score"]    =_myScore;
    314.     json["questionId"] =_currentRankQuestion;
    315.  
    316.     _com->writeData(json);//发送给服务器
    317. }
    318.  
    319. void BrainStorm::on_RankButtonA_clicked()
    320. {
    321.     ui->RankButtonA->setStyleSheet("background-color:rgb(255, 0, 0)");
    322.     ui->RankButtonA->setEnabled(false);
    323.     ui->RankButtonB->setEnabled(false);
    324.     ui->RankButtonC->setEnabled(false);
    325.     ui->RankButtonD->setEnabled(false);
    326.     RankAnswerQuestion(1);
    327. }
    328.  
    329. void BrainStorm::on_RankButtonB_clicked()
    330. {
    331.     ui->RankButtonB->setStyleSheet("background-color:rgb(255, 0, 0)");
    332.     ui->RankButtonA->setEnabled(false);
    333.     ui->RankButtonB->setEnabled(false);
    334.     ui->RankButtonC->setEnabled(false);
    335.     ui->RankButtonD->setEnabled(false);
    336.     RankAnswerQuestion(2);
    337. }
    338.  
    339. void BrainStorm::on_RankButtonC_clicked()
    340. {
    341.     ui->RankButtonC->setStyleSheet("background-color:rgb(255, 0, 0)");
    342.     ui->RankButtonA->setEnabled(false);
    343.     ui->RankButtonB->setEnabled(false);
    344.     ui->RankButtonC->setEnabled(false);
    345.     ui->RankButtonD->setEnabled(false);
    346.     RankAnswerQuestion(3);
    347. }
    348.  
    349. void BrainStorm::on_RankButtonD_clicked()
    350. {
    351.     ui->RankButtonD->setStyleSheet("background-color:rgb(255, 0, 0)");
    352.     ui->RankButtonA->setEnabled(false);
    353.     ui->RankButtonB->setEnabled(false);
    354.     ui->RankButtonC->setEnabled(false);
    355.     ui->RankButtonD->setEnabled(false);
    356.     RankAnswerQuestion(4);
    357. }
    358.  
    359. void BrainStorm::on_overButton_clicked()
    360. {
    361.     ui->stackedWidget->setCurrentWidget(ui->MainMenu);
    362. }

    main.cpp

    1. #include "login.h"
    2. #include 
    3.  
    4. int main(int argc, char *argv[])
    5. {
    6.     QApplication a(argc, argv);
    7.     Widget w;
    8.     w.show();
    9.  
    10.     return a.exec();
    11. }

  • 相关阅读:
    Laravel框架 - IOC容器详解
    【STM32 CubeMX】移植u8g2(一次成功)
    fluke dtx-1800测试精度有必要进行原厂校准吗？
    Python接口自动化测试数据驱动DDT使用实战
    架构师之路3. 富士康 - 再也不见
    MySQL性能分析工具的使用
    Hadoop和关系型数据库间的数据传输工具——Sqoop
    中秋节祝福程序源代码分享：土地分类数据阈值筛选和重投影分类
    怎样将例化的uvn test包含在verdi的instance中，并将其中变量加入到dump的波形中（方便verdi追test以及debug）
    SpringBootWeb 篇-入门了解 Apache POI 使用方法
  • 原文地址：https://blog.csdn.net/xaf21/article/details/126525122