Linux小專案-群聊系統

阿新 • • 發佈：2019-01-26

專案名稱：chat_room群聊系統
背景知識與主要技術：
熟悉Linux基本指令的使用（ls,cd,make,mkdir,top,basename,pwd,cp,mv,rm,touch）
熟悉linux開發環境，熟練使用vi/vim ,gcc/g++,gdb,make,makefile
瞭解網路，熟悉tcp ip udp協議的使用
熟練掌握C/C++,熟練使用C++STL中的容器
熟悉套接字程式設計
熟悉執行緒的使用
熟悉shell指令碼的簡單編寫
使用的開源/系統庫：
1.jsoncpp：基於c++的json庫實現資料的序列化與反序列化的功能。
2.ncurses: 控制螢幕終端顯示的庫，專案中用於實現客戶端介面。
3.pthread：專案中使用該庫提供執行緒支援。
主要功能模組：
1.server模組：基於udp協議完成使用者與伺服器之間的通訊。
2.comm模組：基於jsoncpp庫對通訊資料進行序列化
3.data_pool模組：基於vector與訊號量對資料進行儲存
4.window模組：基於ncurses庫實現客戶端介面（輸入框，輸出框，標題，好友列表）
5.lib模組：專案所需要的動態庫
6.log模組：列印專案的錯誤資訊
7.client模組：採用上述模組實現介面，與資料的傳送與接收。
8.plugin模組：服務起停與程式編譯的控制指令碼
思想圖解
主要模組程式碼

server端

#ifndef _SERVER_H_
#define _SERVER_H_
#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<stdlib.h>
#include<map>
#include<string.h>
#include<pthread.h>
#include"data_pool.h" 

#include"log.h"
#include"data.h"
using namespace std;
class server
{
public:
    server(string ip,int port);
    int sock_init();
    int recvmsg(string &out);
    int  sendmsg(const struct sockaddr_in &client,const string &in);
    int broadcast();
    void *handler(void *arg);
    void add_online_usr(const struct sockaddr_in *client);
    void del_online_usr(const struct sockaddr_in *client);
    ~server();
private:
    string _ip;
    int _port;
    int _sock;
    map<int,struct sockaddr_in> _onlineusr;
    pool data_pool;
};
#endif

#include"udp_server.h"
server::server(string ip,int port)
    :_ip(ip)
    ,_port(port)
    ,_sock(-1)
    ,data_pool(256)
{}
server::~server()
{
    if(_sock > 0)
        close(_sock);
}
int server::sock_init()
{
    _sock = socket(AF_INET,SOCK_DGRAM,0);
    if(_sock < 0)
    {
        print_log("socket error",ERROR);
        return -1;
    }
    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(_port);
    local.sin_addr.s_addr = inet_addr(_ip.c_str());
    if(bind(_sock,(struct sockaddr*)&local,sizeof(local)) < 0)
    {
        print_log("bind error",ERROR);
        return -1;
    }
    return 0;
}

int server::recvmsg(string &out)
{

        struct sockaddr_in client;
        char buf[1024];
        socklen_t len = sizeof(client);
        ssize_t s = recvfrom(_sock,buf,sizeof(buf)-1,0,\
                            (struct sockaddr*)&client,&len);
        if(s > 0)//recv success
        {
            buf[s] = 0;
            out = buf;
            data_pool.put_data(out);
            add_online_usr(&client);
            data _data;
            _data.val_to_unserialize(out);
            if(strcasecmp(_data.cmd.c_str(),"QUIT") == 0)
            {
                del_online_usr(&client);
            }
            return 0;
        }
        return -1;
}
int server::sendmsg(const struct sockaddr_in &client,const string &in)
{
    //const char *msg = in.c_str();
    if(sendto(_sock,in.c_str(),in.size(),0,(struct sockaddr*)&client,sizeof(client)))
    {
        return 0;
    }
   return -1;
}
int server::broadcast()
{
    string in;
    data_pool.get_data(in);
    map<int,struct sockaddr_in>::iterator iter = _onlineusr.begin();
    while(iter != _onlineusr.end())
    {

        sendmsg(iter->second,in);
        iter++;
    }
    return 0;
}
void server::add_online_usr(const struct sockaddr_in* client)
{
    _onlineusr.insert(std::pair<int,struct sockaddr_in>(client->sin_addr.s_addr,*client));
}
void server::del_online_usr(const struct sockaddr_in *client)
{
    map<int,struct sockaddr_in>::iterator iter = _onlineusr.find(client->sin_addr.s_addr);
    if(iter == _onlineusr.end())//can not find
    {
        return;
    }
    else
    {
        _onlineusr.erase(iter);
    }

}

#include"udp_server.h"
void *handler(void *arg)
{
    server *ser = (server*)arg;
    while(1)
    {
        ser->broadcast();
    }
}
int main(int argc,char *argv[])
{
    if(argc != 3)
    {
        std::cout << "Usage :" << argv[0] << "[ip]" << "[port]" << std::endl;
        return -1;
    }
    server ser(argv[1],atoi(argv[2]));
    ser.sock_init();
    pthread_t id;
    pthread_create(&id,NULL,handler,(void*)&ser);
    data _data;
    while(1)
    {
        string out;
        ser.recvmsg(out);
        std::cout << "client say#:" << out << std::endl;
    }
}

comm端

#ifndef _JSON_H_
#define _JSON_H_
#include"json/json.h"
#include<string>
int serialize(Json::Value &_v,std::string &str);
int unserialize(Json::Value &_v,std::string &str);
#endif

#include"base_json.h"
int serialize(Json::Value &_v,std::string &str)
{
    Json::StyledWriter _w;
    str = _w.write(_v);
    return 0;
}
int unserialize(Json::Value &_v,std::string &str)
{
    Json::Reader _r;
    if(_r.parse(str,_v,false))
    {
        return 0;
    }
    return -1;
}

#ifndef _DATA_H_
#define _DATA_H_
#include<iostream>
#include<string>
#include"base_json.h"
class data
{
    public:
        data();
        ~data();
        void val_to_serialize(std::string &str);
        void val_to_unserialize(std::string &str);
    public:
    std::string nick_name;
    std::string school;
    std::string msg;
    std::string cmd;
};
#endif

#include"data.h"
data::data()
{}
data::~data()
{}
void data::val_to_serialize(std::string &str)
{
    Json::Value _v;
    _v["nick_name"] = nick_name;
    _v["school"] = school;
    _v["msg"] = msg;
    _v["cmd"] = cmd;
    serialize(_v,str);
}
void data::val_to_unserialize(std::string &str)
{
    Json::Value _v;
    unserialize(_v,str);
    nick_name = _v["nick_name"].asString();
    school = _v["school"].asString();
    msg = _v["msg"].asString();
    cmd = _v["cmd"].asString();
}
/////以下為測試程式碼
//int main()
//{
//  data d;
//  while(1)
//  {
//
//  std::cin >> d.nick_name;
//  std::cin >> d.school;
//  std::cin >> d.msg ;
//  d.cmd = "";
//  std::string str;
//  d.val_to_serialize(str);
//  std::cout << str << std::endl;
//  d.val_to_unserialize(str);
//  std::cout << d.nick_name << std::endl;
//  std::cout << d.school << std::endl;
//  std::cout << d.msg << std::endl;
//
//  }
//
//  return 0;
//}

window端—介面實現

#include<iostream>
#include<string>
#include<ncurses.h>
class window
{
    public:
    window();
    ~window();
    void create_win(WINDOW *& _win,int _h,int _w,int _y,int _x);
    void create_header();
    void create_output();
    void create_input();
    void create_friends_list();
    void put_str_to_window(WINDOW *_win,int _y,int _x,std::string str);
void get_str_window(WINDOW *_win,std::string &msg);
void fflush(WINDOW *_win);
    public:
    WINDOW * _header;
    WINDOW * _output;
    WINDOW * _input;
    WINDOW * _friends_list;
};

#include"window.h"
window::window()
{
    initscr();
}
window::~window()
{
    delwin(_header);
    delwin(_output);
    delwin(_input);
    delwin(_friends_list);
    endwin();
}
void window::create_win(WINDOW *&_win,int _h,int _w,int _y,int _x)
{
    _win = newwin(_h,_w,_y,_x);
    box(_win,0,0);
}
void window::create_header()
{
    int _h = LINES/5;
    int _w = COLS;
    int _x = 0;
    int _y = 0;
    create_win(_header,_h,_w,_y,_x);
}
void window::create_output()
{
    int _h = (LINES*3)/5;
    int _w = (COLS*3)/4;
    int _x = 0;
    int _y = LINES/5;
    create_win(_output,_h,_w,_y,_x);
}
void window::create_input()
{
    int _h = LINES/5;
    int _w = COLS;
    int _x = 0;
    int _y = (LINES*4)/5;
    create_win(_input,_h,_w,_y,_x);
}
void window::create_friends_list()
{
    int _h = (LINES*3)/5;
    int _w = COLS/4;
    int _x = (COLS*3)/4;
    int _y = LINES/5;
    create_win(_friends_list,_h,_w,_y,_x);
}
void window::put_str_to_window(WINDOW *_win,int _y,int _x,std::string str)
{
    mvwaddstr(_win,_y,_x,str.c_str());
}
void window::get_str_window(WINDOW *_win,std::string &msg)
{
    char buf[1024];
    wgetnstr(_win,buf,sizeof(buf));
    msg = buf;
}
void window::fflush(WINDOW *_win)
{
    wrefresh(_win);
}
//以下為本模組測試程式碼
//int main()
//{
//  window win;
//  win.create_header();
//  wrefresh(win._header);
//  usleep(2000000);
//  win.create_output();
//  wrefresh(win._output);
//  usleep(2000000);
//  win.create_friends_list();
//  wrefresh(win._friends_list);
//  usleep(2000000);
//  win.create_input();
//  std::string str = "Please Entry#";
//  mvwaddstr(win._input,1,1,str.c_str());
//  wrefresh(win._input);
//  usleep(2000000);
//  int j = 1;
//  int _y;
//  int _x;
//  while(1)
//  {
//      std::string str = "Welcome to chat_room!";
//      win.create_header();
//      mvwaddstr(win._header,1,j++,str.c_str());
//      if(str.size() >= _x-j-1)
//          j = 1;
//      wrefresh(win._header);
//      getmaxyx(win._header,_y,_x);
//      j%=(_x-1);
//      wclrtoeol(win._header);
//      usleep(100000);
//      
//  }
//  int i = 1;
//  int y;
//  int x;
//  while(1)
//  {
//      std::string str = "Please Entry#";
//      mvwaddstr(win._output,i++,1,str.c_str());
//      wrefresh(win._output);
//      getmaxyx(win._output,y,x);
//      i%=(y-1);
//      if(i == 0)
//      {
//          i = 1;
//          wclrtoeol(win._output);
//          win.create_output();
//
//      }
//      usleep(1000000);
//  }
//
//  return 0;
//}

client端

#ifndef _CLIENT_H_
#define _CLIENT_H_
#include<iostream>
#include<string>
#include<string.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<stdlib.h>
#include"window.h"
#include"data.h"
#include"log.h"
#include<vector>
#include<signal.h>
using namespace std;
class client
{
public:
    client(string ip,int port);
    ~client();
    int sock_init();
    int recvmsg(string &out);
    int  sendmsg(const string &out);
private:
    string _ip;
    int _port;
    int _sock;
    //map<int struct sockaddr_in> _onlineusr;
};
#endif

#include"udp_client.h"
client::client(string ip,int port)
    :_ip(ip)
    ,_port(port)
    ,_sock(-1)
{}
client::~client()
{
    if(_sock > 0)
        close(_sock);
}
int client::sock_init()
{
    _sock = socket(AF_INET,SOCK_DGRAM,0);
    if(_sock < 0)
    {
        print_log("socket error",ERROR);
        return -1;
    }
    return 0;
}
int client::recvmsg(string &out)
{
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        char buf[1024];
        ssize_t s = recvfrom(_sock,buf,sizeof(buf)-1,0,\
                            (struct sockaddr*)&peer,&len);
        if(s > 0)//recv success
        {
            buf[s] = 0;
            out = buf;
            return 0;
        }
        return -1;
}
int client::sendmsg(const string &in)
{
    struct sockaddr_in peer;
    peer.sin_family = AF_INET;
    peer.sin_port = htons(_port);
    peer.sin_addr.s_addr = inet_addr(_ip.c_str());
    if(sendto(_sock,in.c_str(),in.size(),0,(struct sockaddr*)&peer,sizeof(peer)))
    {
        return 0;
    }
   return -1;
}

#include"udp_client.h"
string name;
string school;
client *pcli;
vector<string> flist;
int flag = 1;
typedef struct win_cli
{
    client *_cli;
    window *_win;
} win_cli,*pwin_cli;
void add_user(string friends)
{
    int i = 0;
    for(; i < flist.size();++i)
    {
        if(flist[i] == friends)
        {
            flag = 0;
            return;
        }
    }
    flist.push_back(friends);
    flag = 1;
}
void del_user(string friends)
{
    vector<string>::iterator iter = flist.begin();
    while(iter != flist.end())
    {
        if(*iter == friends)
        {
            iter = flist.erase(iter);
            flag = 1;
            break;
        }
        iter++;
    }
}
void quit(int sig)
{
    data _data;
    _data.nick_name = name;
    _data.school = school;
    _data.msg = "";
    _data.cmd = "QUIT";
    string in;
    _data.val_to_serialize(in);
    pcli->sendmsg(in);
    endwin();
    exit(0);
}
void *show_header(void *arg)
{
    pwin_cli wc = (pwin_cli)arg;
    window *win = wc->_win;
    int j = 1;
    int _y;
    int _x;
    while(1)
    {
        string str = "Welcome to chat_room!";
        win->create_header();
        mvwaddstr(win->_header,1,j++,str.c_str());
        if(str.size() >= _x-j-1)
            j = 1;
        wrefresh(win->_header);
        getmaxyx(win->_header,_y,_x);
        j%=(_x-1);
        wclrtoeol(win->_header);
        usleep(100000);

    }
}
void *show_output(void *arg)
{
    pwin_cli wc = (pwin_cli)arg;
    client *cli = wc->_cli;
    window *win = wc->_win;
    int i = 1;
    int j = 1;
    int y;
    int x;
    int fy;
    int fx;
    win->create_output();
    wrefresh(win->_output);
    win->create_friends_list();
    wrefresh(win->_friends_list);
    string out;
    string friends;
    data _d;
    string str;
    while(1)
    {
        cli->recvmsg(out);
        _d.val_to_unserialize(out);
        str=_d.nick_name;
        str+="-";
        str+=_d.school;
        friends = str;
        str+="#";
        str+=_d.msg;
        if(strcmp(_d.cmd.c_str(),"QUIT") == 0)
        {
            del_user(friends);
            wclrtoeol(win->_friends_list);
            wrefresh(win->_friends_list);
            win->create_friends_list();
            wrefresh(win->_friends_list);
        }
        else
        {
            win->put_str_to_window(win->_output,i++,1,str);
            wrefresh(win->_output);
            add_user(friends);
            getmaxyx(win->_output,y,x);
            i%=(y-1);
            if(i == 0)
            {
                i = 1;
                wclrtoeol(win->_output);
                win->create_output();
                wrefresh(win->_output);
            }
        }
            if(flag)
            {
                int k = 0;
                getmaxyx(win->_friends_list,fy,fx);
                for(; k < flist.size();++k)
                {
                    mvwaddstr(win->_friends_list,j++,1,flist[k].c_str());
                    wrefresh(win->_friends_list);
                    j %= (fy-1);
                    if(j == 0)
                    {
                        j = 1;
                        wclrtoeol(win->_friends_list);
                        wrefresh(win->_friends_list);
                        win->create_friends_list();
                        wrefresh(win->_friends_list);
                    }
                }
                j = 1;
        }


    }
}
void *show_input(void *arg)
{
    pwin_cli wc = (pwin_cli)arg;
    client *cli = wc->_cli;
    window *win = wc->_win;
    data _data;
    _data.nick_name = name;
    _data.school = school;
    while(1){
        win->create_input();
        wrefresh(win->_input);
        string ptr = "Please Entry#";
        mvwaddstr(win->_input,1,1,ptr.c_str());
        wrefresh(win->_input);
        win->get_str_window(win->_input,_data.msg);
        wrefresh(win->_input);
        _data.cmd = "";
        string in;
        _data.val_to_serialize(in);
        cli->sendmsg(in);
    }
}
int main(int argc,char *argv[])
{
    if(argc != 3)
    {
        cout << "Usage :" << argv[0] << "[ip]" << "[port]" << std::endl;
        return -1;
    }
    client cli(argv[1],atoi(argv[2]));
    cout << "Please Enteryour nick_name#";
    cin >> name;
    cout << "Please Enter your school#";
    cin >> school;
    cli.sock_init();
    window win;
    win_cli _wc = {&cli,&win};
    pcli = &cli;
    signal(2,quit);
    pthread_t header;
    pthread_t output;
    pthread_t input;
    pthread_create(&input,NULL,show_input,(void*)&_wc);
    pthread_create(&header,NULL,show_header,(void*)&_wc);
    pthread_create(&output,NULL,show_output,(void*)&_wc);
    pthread_join(header,NULL);
    pthread_join(output,NULL);
    pthread_join(input,NULL);

}
//以下為本模組測試程式碼
//int main(int argc,char *argv[])
//{
//  if(argc != 3)
//  {
//      cout << "Usage :" << argv[0] << "[ip]" << "[port]" << std::endl;
//      return -1;
//  }
//  client cli(argv[1],atoi(argv[2]));
//  cli.sock_init();
//    data _data;
//  cout << "Please Enteryour nick_name#";
//      cin >> _data.nick_name;
//      cout << "Please Enter your school#";
//      cin >> _data.school;
//  while(1)
//  {
//      cout << "please input*";
//      cin >> _data.msg;
//      _data.cmd = "";
//      string in;
//      _data.val_to_serialize(in);
//      cli.sendmsg(in);
//      string out;
//      cli.recvmsg(out);
//      cout << "out:" << out << endl;
//      _data.val_to_unserialize(out);
//      string str;
//          str+=_data.nick_name;
//          str+="-";
//  str+=_data.school;
//  str+="# ";
//  str+=_data.msg;
//      cout << str << endl;
//
//  }
//}

makefile編寫

ROOT=$(shell pwd)
LOG=${ROOT}/log
POOL=${ROOT}/data_pool
SERVER=${ROOT}/server
CLIENT=${ROOT}/client
SERVER_BIN=chat_system
CLIENT_BIN=chat_client
BIN=${ROOT}/lib
DATA=${ROOT}/comm
WINDOW=${ROOT}/window
CONF=${ROOT}/conf
PLUGIN=${ROOT}/plugin
INCLUDE=-I$(LOG) -I$(POOL) -I$(BIN)/include -I$(DATA) -I$(WINDOW)
SERVER_OBJ=$(shell ls $(SERVER)/ | grep -E '\.cpp$$' | sed 's/\.cpp/\.o/')
SERVER_OBJ+=$(shell ls $(LOG)/ | grep -E '\.cpp$$' | sed 's/\.cpp/\.o/')
SERVER_OBJ+=$(shell ls $(DATA)/ | grep -E '\.cpp$$' | sed 's/\.cpp/\.o/')
SERVER_OBJ+=$(shell ls $(POOL)/ | grep -E '\.cpp$$' | sed 's/\.cpp/\.o/')
CLIENT_OBJ=$(shell ls $(CLIENT)/ | grep -E '\.cpp$$' | sed 's/\.cpp/\.o/')
CLIENT_OBJ+=$(shell ls $(LOG)/ | grep -E '\.cpp$$' | sed 's/\.cpp/\.o/')
CLIENT_OBJ+=$(shell ls $(DATA)/ | grep -E '\.cpp$$' | sed 's/\.cpp/\.o/')
CLIENT_OBJ+=$(shell ls $(WINDOW)/ | grep -E '\.cpp$$' | sed 's/\.cpp/\.o/')
cc=g++
FLAGS=-lpthread
.PHONY:all
all:${SERVER_BIN} ${CLIENT_BIN}

${SERVER_BIN}:${SERVER_OBJ}
    @${cc} -o [email protected] $^ $(FLAGS) -L$(BIN)/lib -ljsoncpp
    @echo "linking [$^] [[email protected]] ....done"

${CLIENT_BIN}:${CLIENT_OBJ}
    @${cc} -o [email protected] $^ -L$(BIN)/lib -ljsoncpp -lncurses
    @echo "linking [$^] [[email protected]] ....done"

%.o:$(SERVER)/%.cpp
    @$(cc) -c $< $(INCLUDE)
    @echo "comping  [$^] [[email protected]] ....done"

%.o:$(LOG)/%.cpp
    @$(cc) -c $< 
    @echo "comping  [$^] [[email protected]] ....done"

%.o:$(POOL)/%.cpp
    @$(cc) -c $< $(INCLUDE) 
    @echo "comping  [$^] [[email protected]] ....done"

%.o:$(CLIENT)/%.cpp
    @$(cc) -c $< $(INCLUDE)
    @echo "comping  [$^] [[email protected]] ....done"
%.o:$(DATA)/%.cpp
    @$(cc) -c $< $(INCLUDE)
    @echo "comping  [$^] [[email protected]] ....done"
%.o:$(WINDOW)/%.cpp
    @$(cc) -c $< $(INCLUDE)
    @echo "comping  [$^] [[email protected]] ....done"
.PHONY:output
output:
    @mkdir -p outut/server
    @mkdir -p output/server/log
    @mkdir -p output/client
    @cp $(SERVER_BIN) output/server/
    @cp $(CLIENT_BIN) output/client/
    @cp $(PLUGIN)/ctl_server.sh  output/server/
    @cp -rf $(CONF) output/server
.PHONY:clean
clean:
    @rm -rf *.o $(SERVER_BIN) $(CLIENT_BIN) output

成果展示
這裡寫圖片描述

Linux小專案-群聊系統

專案名稱：chat_room群聊系統背景知識與主要技術：熟悉Linux基本指令的使用（ls,cd,make,mkdir,top,basename,pwd,cp,mv,rm,touch）熟悉linux開發環境，熟練使用vi/vim ,gcc/g++,g

mini聊天室（Linux下基於UDP實現的群聊系統）

一.原理（1）客戶端從標準輸入讀取資料，將資料序列化後傳送至網路；（2）伺服器端使用多執行緒+生產者消費者模型；生產者從網路中讀取資料，並將讀取到的使用者資訊新增至使用者列表，將資料放至資料池中；消費者從資料池讀取資料，並廣播給所有在使用者列表中的使用者。

java小專案鮮花銷售系統

專案：七彩鮮花銷售系統一、練習目標 1.體會陣列的作用 2.找到分層開發的感覺 3.收穫分層開發的興趣 4.作出效果，找到自信 5.學會除錯錯誤 6.掌握陣列的增刪改查方法全部講解和練習時間控制在3小時以內二、專案需求 1.使用分層開發：表示層（測試類）、業務層（鮮花管理類）、

SSH框架結合MySql資料庫實現常用小專案（名片系統、商品管理、商品推薦、登陸註冊）

概述這裡主要使用hibernate3.0、struts2.0和spring框架結合mysql資料庫搭建的開發環境，實現了幾個在開發學習中常用到的功能，名片系統、商品管理、商品推薦、登陸註冊、css結合js簡單優化頁面

JAVA小專案-銀行管理系統（圖形化介面）3-登入與查詢

還是老規矩，先上圖，得清晰的認識到自己寫到哪了，還差多少我們看圖出了掛失ReportLose和資訊註冊Register 我們不要進行資訊驗證其他在途中都必須進行但我為什麼要綜合成一個呢，因為懶，覺得寫6個一樣的貼上都感覺很狗但

小遊戲群聊分享又有新套路，小程式實現全面佈局

11 月 5 日晚，微信宣稱「為了讓使用者更好地發現和使用基於地理位置的小程式服務」，對附近的小程式進行了升級，新增了分類導航、服務標籤、線上客服展示等功能。同時，小程式新增了帶有狀態的群分享卡片、區域網通訊等功能。本次更新幾乎將微信小程式的整體佈局一一展現

基於UDP的網路群聊系統

為什麼用UDP？ UDP是一個無連線的，不可靠的協議。傳送端的UDP協議層只把應用層傳來的資料封裝成端給IP協議層就完成任務了。如果因為網路故障無法傳送到對方，UDP協議層也不會給應用層返回任何錯誤資訊。那麼，為什麼用UDP協議？很明顯簡單，快

java學習之小專案彩票購買系統

專案需求雙色球投注區分為紅色球號碼區和藍色球號碼區，紅色球號碼區由1-33共33個號碼組成，藍色球號碼區由1-16共16個號碼組成。投注時選擇6個紅球號碼和1個藍球號碼組成一注進行單式投注，每注金額2元。一等獎：投注號碼與當期開獎號碼全部相同（順序不限，下同），即中

JAVA小專案--銀行管理系統

銀行新使用者現金業務辦理 1.任務描述編寫一個銀行新使用者現金業務辦理程式，使其模擬新使用者到銀行辦理現金存取業務時的場景。要求此場景中，要模擬出銀行對使用者到來的歡迎動作、對使用者離開的提醒動作，以及使用者的開戶、存款和取款

Linux小專案：停車場的實現。

標頭檔案： /****************************wddv587************************************* FileName: 停車場/parking.h Verson: 1.0 Date: 2018.0814

基於itchat的微信群聊小助手基礎開發（一）

log 表達式數據包 gin 找到 ont 基本時間 msg 前段時間由於要管理微信群，基於itchat開發了一個簡單的微信機器人主要功能有：圖靈機器人功能群聊昵稱格式修改提示消息防撤回功能鬥圖功能要開發一個基於itchat的最基本的聊天機器人，

自制linux小系統

linux自制linux今天說一說怎麽自制一個linux，也就是用一塊新硬盤來自己搞一個linux。硬盤拆掉撞到其他機器上可以照常使用，需要什麽東西都是自己添加的哦。那我就在虛擬機裏進行了嘿嘿嘿。。。1.在我的centos裏加了一塊新的硬盤並順便分了個區，並且格式化了一下。[[email prote

Linux（小專案）————shell的實現，包含重定向、內建命令。

bash原理：通過上面bash的原理我們可以，瞭解到shell的框架與流程： 1.等待使用者輸入命令。 2.解析使用者輸入的字串。 3.建立子程序執行exec程式替換 4.父程序等待子程序退出。迴圈執行1~4步驟，即可完成my_shell。最簡單版本的my_shell實現：

Linux:實現程序間的群聊（類似於聊天室）

思路：運用共享記憶體來儲存當前聊天的人數，訊息佇列來儲存訊息，執行緒來實現讀取。先通過create.c來建立共享記憶體，並初始化在chat.c中實現資訊的讀取，在主函式中將訊息寫進訊息佇列中，建立執行緒來實現訊息的讀取。每執行一次chatc.c檔案，共享記憶

Linux伺服器集群系統(二)

LVS叢集的體系結構章文嵩 ([email protected]) 2002 年 4 月本文主要介紹了LVS叢集的體系結構。先給出LVS叢集的通用體系結構，並討論了其的設計原則和相應的特點；最後將LVS叢集應用於建立可伸縮的Web、Media、Cache

Linux伺服器集群系統(一)

LVS專案介紹章文嵩 ([email protected]) 2002 年 3 月本文介紹了Linux伺服器集群系統--LVS（Linux Virtual Server）專案的產生背景和目標，並描述了LVS伺服器叢集框架及目前提供的軟體，列舉LVS集群系統

專案之暢聊系統

這個專案是我真正意義上的第一個專案，它的名字是基於UDP實現的群聊系統。目錄：實現功能及原理應用知識與技能專案的具體模組的問題注意的問題心得與體會一。實現功能及其原理： 1.功能：首先這個專案是在Linux下用C++編寫的程式，而且是基於UDP的。

linux專案 --- 圖書管理系統（資料庫版）

在 /home/openwrt/Desktop/IS/book_manager_sqlite 目錄下提供了“圖書管理系統”專案，是使用sqlite3資料庫進行資料管理。在該目錄下，提供了bm_sqlite可執行程式，直接執行如下： ./bm_

linux專案 -- 圖書管理系統（連結串列版）

在ubuntu系統的/home/openwrt/Desktop/IS目錄下，提供了筆者的一些專案，使用者可以直接測試，瞭解linux系統下C程式專案的開發。提供瞭如下的專案：其中book_manager_json專案是一個“圖書管理系統”的

arm-linux-gcc編譯時出現的一些小插曲-----64位系統需要32位的庫

最近由於工作的需要，重新弄起arm-linux-gcc編譯。離上一次弄這些有整整10年了。我是在一臺64位的機器上實機安裝的 centos7 發行版，系統和交叉編譯器的安裝過程自是沒話說，問題出在使用arm-linux-gcc編譯 arm程式時， $ arm-linu

Linux小專案-群聊系統

相關推薦