学习笔记 c++（ socket网络编程，心跳监测，断线重连，结构体发送接收）

最新推荐文章于 2023-08-31 14:40:25 发布
最新推荐文章于 2023-08-31 14:40:25 发布
阅读量2.6k 收藏 33
点赞数 4
分类专栏： c++学习 ubuntu
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42145185/article/details/109547660
版权

server.h

/*
 * @Author: Li Chao 
 * @Date: 2020-11-03 08:38:56 
 * @Last Modified by: Li Chao
 * @Last Modified time: 2020-11-03 17:03:45
 */

#include <arpa/inet.h>
#include <errno.h>
#include <netinet/in.h>
#include <poll.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/un.h>
#include <thread>
#include <stdio.h>
#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <sys/time.h>

using namespace std;

#define BUF_SIZE 0xFFFF
#define EXIT "EXIT"

struct Msg
{
    int type;
    int fromID;
    int toID;
    char content[1024];
};

class Server
{
private:
    thread *send_thread, *recv_thread, *heartbeat_thread;
    int socket_fd, client_fd;
    string server_ip;
    unsigned short server_port;
    bool isServerwork;
    bool heart_flag;
    uint64_t heartbeat_time;
    char recv_buf[BUF_SIZE];
    char send_buf[BUF_SIZE];
    char key_input_buf[BUF_SIZE];
    bool init_server(string ip, unsigned short port);
    void start();
    void on_connected();
    void on_disconnected();
public:
    Server();
    void send_msg(char *buf);
    void recv_msg(); 

    void send_thread_function();
    void recv_thread_function(); 
    void heartbeat_send_thread_function(); //发送心跳
    void send_server_msg(); //制作并发送结构体信息

    void handle_msg(Msg &msg); //处理打印结构体信息
    void handle_heartbeat(); //处理心跳

};

server.cpp

/*
 * @Author: Li Chao 
 * @Date: 2020-11-03 10:50:47 
 * @Last Modified by: Li Chao
 * @Last Modified time: 2020-11-03 17:43:41
 */

#include "server.h"

Server::Server()
{
    socket_fd = -1;
    server_ip = "127.0.0.1";
    server_port = 8888;
    heart_flag = false;
    isServerwork = true;
    
    init_server(server_ip,server_port);
}

bool Server::init_server(string ip, unsigned short port)
{
    socket_fd = socket(AF_INET, SOCK_STREAM, 0);
    if(socket_fd == -1)
    {
        perror("socket");
        exit(-1);
    }

    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = inet_addr(ip.c_str());

    int reuseaddr = 1;
    setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(reuseaddr));

    int ret = bind(socket_fd, (struct sockaddr*)&addr, sizeof(addr));
    if(ret == -1)
    {
        perror("bind");
        exit(-1);
    }

    listen(socket_fd, 30);
    cout<<"wait client connect"<<endl;    

    start();

    return true;
}

void Server::start()
{
    struct sockaddr_in client;
    socklen_t len = sizeof(client);
 
    while (isServerwork) //不输入exit退出，就一直循环等等客户端接入
    {
        client_fd = accept(socket_fd, (struct sockaddr*)&client, &len);
        if(client_fd == -1)
        {
            perror("accept");
            exit(-1);
        }

        char *client_ip = inet_ntoa(client.sin_addr);
        cout<<"client ip:"<<client_ip<<"connect ok!"<<endl;

        if(!heart_flag)
        {
            send_thread = new thread(bind(&Server::send_thread_function, this));
            recv_thread = new thread(bind(&Server::recv_thread_function, this));
            heartbeat_thread = new thread(bind(&Server::handle_heartbeat, this));
            heart_flag = true;
        }

    }
    
    on_disconnected();
}

void Server::send_msg(char *buf)
{
    memset(send_buf,0,BUF_SIZE);
    memcpy(send_buf, buf, sizeof(buf));
    send(client_fd, send_buf, strlen(send_buf), 0);
}

void Server::recv_msg()
{   
    int recv_size = recv(client_fd, recv_buf, sizeof(recv_buf), 0);
    if(recv_size <= 0)
    {
        return;
    }
    if(recv_size == 8)//进入心跳打印
    {
        cout<<"recv_size:"<<recv_size<<endl;
        cout<<"recv content:"<<recv_buf<<endl;
        struct timeval recv_now;
        gettimeofday(&recv_now, NULL);
        heartbeat_time = recv_now.tv_sec * 1000 + recv_now.tv_usec / 1000;
    }
    else  //处理结构体信息
    {
        Msg msg;
        memset(msg.content, 0 ,sizeof(msg.content));
        memcpy(&msg, recv_buf, sizeof(msg));
        handle_msg(msg);
    }
}

void Server::on_disconnected()
{
    //send_thread->join();
    //recv_thread->join();
    //delete send_thread;
    //delete recv_thread;
    //send_thread = nullptr;
    //recv_thread = nullptr;
    close(socket_fd);
    close(client_fd);
}

void Server::send_thread_function()
{
    while (true)
    {
        memset(key_input_buf,0,BUF_SIZE);
        fgets(key_input_buf,BUF_SIZE, stdin);
        if(strncasecmp(key_input_buf, EXIT, strlen(EXIT)) == 0 )
        {
            cout<<"exit"<<endl;
            isServerwork = false;
            break;
        }
        //send_msg(key_input_buf);//发送手动输入信息
        send_server_msg();//发送结构体信息
    }
    
}

void Server::recv_thread_function()
{
    while (true)
    {
        recv_msg();
    }
}

void Server::heartbeat_send_thread_function()
{
    while (isServerwork)
    {
        unsigned char sendbuf[8] = {0};
        sendbuf[0] = 'h';
        sendbuf[1] = 'e';
        sendbuf[2] = 'a';
        sendbuf[3] = 'r';
        sendbuf[4] = 't';
        send(client_fd, sendbuf, sizeof(sendbuf), 0);
        sleep(2);
    }        
}

void Server::send_server_msg()  //制作并发送结构体信息
{
    Msg msg;
    memset(msg.content, 0 ,sizeof(msg.content));
    msg.type = 11;
    msg.fromID = 22;
    msg.toID = 33;
    char send_content[] = "hello this is server send message info";
    memcpy(msg.content, send_content, sizeof(send_content));

    send(client_fd, (char *)&msg, sizeof(msg), 0);
}

void Server::handle_msg(Msg &msg) //处理打印结构体信息
{
    cout<<"msg.type:"<<msg.type<<endl;
    cout<<"msg.fromID:"<<msg.fromID<<endl;
    cout<<"msg.toID:"<<msg.toID<<endl;
    cout<<"msg.content:"<<msg.content<<endl;
}

void Server::handle_heartbeat()  //监听心跳
{
    struct timeval now;
    static int heartbeat_timeout_cnt = 0;

    while (heart_flag)
    {
        usleep(500 * 1000);
        gettimeofday(&now, NULL);
        uint64_t now_time = now.tv_sec * 1000 + now.tv_usec/1000; //每次获取当前时间
        if( (now_time - heartbeat_time) > 1000)
        {
            //cout<<"heartbeat_timeout_cnt++"<<endl;
            heartbeat_timeout_cnt++;
        }else
        {
            heartbeat_timeout_cnt = 0;
        }
        if(heartbeat_timeout_cnt > 5)  //判断5次心跳超时，退出心跳检测，关闭client_fd等等重新连接
        {
            cout<<"heartbeat timeout!!!"<<endl;
            heart_flag = false;
            heartbeat_timeout_cnt = 0;
            //cout<<"client_fd:"<<client_fd<<endl;
            if (client_fd > 0) {
                shutdown(client_fd, SHUT_RDWR);
                close(client_fd);
                client_fd = -1;
                cout<<"close connection, and reconnect"<<endl;
            }
            break;
        }
    }
}

server_main.cpp

/*
 * @Author: Li Chao 
 * @Date: 2020-11-03 14:44:12 
 * @Last Modified by: Li Chao
 * @Last Modified time: 2020-11-03 14:49:42
 */

#include "server.h"

int main()
{
    Server server;
    return 0;
}

client.h

/*
 * @Author: Li Chao 
 * @Date: 2020-11-03 15:00:12 
 * @Last Modified by: Li Chao
 * @Last Modified time: 2020-11-03 16:54:12
 */

#include <arpa/inet.h>
#include <errno.h>
#include <netinet/in.h>
#include <poll.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/un.h>
#include <thread>
#include <stdio.h>
#include <iostream>
#include <unistd.h>
#include <pthread.h>

using namespace std;

#define BUF_SIZE 0xFFFF
#define EXIT "EXIT"

struct Msg
{
    int type;
    int fromID;
    int toID;
    char content[1024];
};

class Client
{
private:
    thread *send_thread, *recv_thread, *heartbeat_thread;
    int socket_fd;
    string server_ip;
    unsigned short server_port;
    bool isClientwork;
    char recv_buf[BUF_SIZE];
    char send_buf[BUF_SIZE];
    char key_input_buf[BUF_SIZE];
    bool init_client(string ip, unsigned short port);
    void on_connected();
    void on_disconnected();

public:
    Client();
    void send_msg(char *buf);
    void recv_msg();

    void send_thread_function();
    void recv_thread_function(); 
    void heartbeat_send_thread_function(); //发送心跳
    void send_server_msg(); //制作并发送结构体信息

    void handle_msg(Msg &msg); //处理打印结构体信息
};

client.cpp

/*
 * @Author: Li Chao 
 * @Date: 2020-11-03 15:20:30 
 * @Last Modified by: Li Chao
 * @Last Modified time: 2020-11-03 17:25:22
 */

#include "client.h"

Client::Client()
{
    socket_fd = -1;
    server_ip = "127.0.0.1";
    server_port = 8888;
    init_client(server_ip,server_port);
}

bool Client::init_client(string ip, unsigned short port)
{
reconnect:
    socket_fd = socket(AF_INET, SOCK_STREAM, 0);
    if(socket_fd == -1)
    {
        perror("socket");
        exit(-1);
    }

    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(server_port);
    addr.sin_addr.s_addr = inet_addr(server_ip.c_str());

    //如果服务器没有在线循环等等服务器上线
    while (true) {
        int ret = connect(socket_fd, (struct sockaddr*)&addr, sizeof(addr));
        if (ret < 0) {
            cout<<"connect "<<ip.c_str() <<":"<< port <<"failed,trying to reconnect..."<<endl;
            usleep(2000 * 1000);
        } else
        {
            cout<<"connect ok"<<endl;
            isClientwork = true;
            break;
        }
    }

    //send_thread = new thread(bind(&Client::send_thread_function, this));
    //recv_thread = new thread(bind(&Client::recv_thread_function, this));
    heartbeat_thread = new thread(bind(&Client::heartbeat_send_thread_function, this));

    while (true)
    {
        int recv_size = recv(socket_fd, recv_buf, sizeof(recv_buf), 0);
        if(recv_size <= 0)
        {
            cout<<"close connent"<<endl;
            //断开之后，重新连接服务器
           //send_thread->join();
           //delete send_thread;
           //send_thread = nullptr;
           //heartbeat_thread->join();
           //delete heartbeat_thread;
           //heartbeat_thread = nullptr;
            isClientwork = false;
            close(socket_fd);
            sleep(3);
            goto reconnect;
        }else if(recv_size == 8)//进入心跳打印
        {
            cout<<"recv_size:"<<recv_size<<endl;
            cout<<"recv content:"<<recv_buf<<endl;
        }
        else if (recv_size > 0 && recv_size != 8)  //处理结构体信息
        {
            Msg msg;
            memset(msg.content, 0 ,sizeof(msg.content));
            memcpy(&msg, recv_buf, sizeof(msg));
            handle_msg(msg);
        }
    
    }
     
    on_disconnected();


    return true;
}

void Client::send_msg(char *buf)
{
    memset(send_buf,0,BUF_SIZE);
    memcpy(send_buf, buf, sizeof(buf));
    send(socket_fd, send_buf, strlen(send_buf), 0);
}

void Client::recv_msg()
{   
    int recv_size = recv(socket_fd, recv_buf, sizeof(recv_buf), 0);
    if(recv_size <= 0)
    {
        cout<<"close connent"<<endl;
        //断开之后，重新连接服务器
    }
    if(recv_size == 8)//进入心跳打印
    {
        cout<<"recv_size:"<<recv_size<<endl;
        cout<<"recv content:"<<recv_buf<<endl;
    }
    else  //处理结构体信息
    {
        Msg msg;
        memset(msg.content, 0 ,sizeof(msg.content));
        memcpy(&msg, recv_buf, sizeof(msg));
        handle_msg(msg);
    }
}

void Client::on_disconnected()
{
    //send_thread->join();
    //recv_thread->join();
    //delete send_thread;
    //delete recv_thread;
    //send_thread = nullptr;
    //recv_thread = nullptr;
    close(socket_fd);
}

void Client::send_thread_function()
{
    while (isClientwork)
    {
        memset(key_input_buf,0,BUF_SIZE);
        fgets(key_input_buf,BUF_SIZE, stdin);
        if(strncasecmp(key_input_buf, EXIT, strlen(EXIT)) == 0 )
        {
            isClientwork = false;
        }
        //send_msg(key_input_buf);//发送手动输入信息
        send_server_msg();//发送结构体信息
    }
    
}

void Client::recv_thread_function()
{
    while (true)
    {
        recv_msg();
    }
}

void Client::heartbeat_send_thread_function() //发送心跳
{
    while (isClientwork)
    {
        unsigned char sendbuf[8] = {0};
        sendbuf[0] = 'h';
        sendbuf[1] = 'e';
        sendbuf[2] = 'a';
        sendbuf[3] = 'r';
        sendbuf[4] = 't';
        send(socket_fd, sendbuf, sizeof(sendbuf), 0);
        usleep(500 * 1000);
    }        
}

void Client::send_server_msg()  //制作并发送结构体信息
{
    Msg msg;
    memset(msg.content, 0 ,sizeof(msg.content));
    msg.type = 1111;
    msg.fromID = 2222;
    msg.toID = 3333;
    char send_content[] = "hello this is client send message info";
    memcpy(msg.content, send_content, sizeof(send_content));

    send(socket_fd, (char *)&msg, sizeof(msg), 0);
}

void Client::handle_msg(Msg &msg) //处理打印结构体信息
{
    cout<<"msg.type:"<<msg.type<<endl;
    cout<<"msg.fromID:"<<msg.fromID<<endl;
    cout<<"msg.toID:"<<msg.toID<<endl;
    cout<<"msg.content:"<<msg.content<<endl;
}

client_main.cpp

/*
 * @Author: Li Chao 
 * @Date: 2020-11-03 15:43:07 
 * @Last Modified by: Li Chao
 * @Last Modified time: 2020-11-03 15:44:17
 */

#include "client.h"

int main()
{
    Client client;
    return 0;
}

Makefile文件

CC = g++
CFLAGS = -std=c++11
 
all: server_main.cpp client_main.cpp server.o client.o
	$(CC) $(CFLAGS) server_main.cpp  server.o -o chatroom_server -lpthread
	$(CC) $(CFLAGS) client_main.cpp client.o -o chatroom_client -lpthread

server.o: server.cpp server.h 
	$(CC) $(CFLAGS) -c server.cpp

client.o: client.cpp client.h 
	$(CC) $(CFLAGS) -c client.cpp
 
clean:
	rm -f *.o chatroom_server chatroom_client

 

pd很不专业
关注
专栏目录
TCP socket心跳包示例程序
dbbaq24022的专栏
05-06 3474
在做游戏开发时，经常需要在应用层实现自己的心跳机制，即定时发送一个自定义的结构体（心跳包），让对方知道自己还活着，以确保连接的有效性。 在TCP socket心跳机制中，心跳包可以由服务器发送给客户端，也可以由客户端发送给服务器，不过比较起来，前者开销可能更大。—— 这里实现的是由客户端给服务器发送心跳包，基本思路是： 1） 服务器为每个客户端保存了IP和计数器c...
C/C++ 进程间 心跳检测
04-14
C/C++ 进程间 心跳检测 ，功能实现：可以检测 进程是否 live 或者 僵死，然后根据具体状态，发signal 处理被检测的进程
【C++ TCP服务器类--带心跳检测】
最新发布
a15272186891的博客
08-31 635
TCP服务器类构建
c++ 进程间心跳检测--socket （UDP）
5266的博客
04-09 3772
目录 代码结构如下： 代码解析： check tread: receive tread: send tread: 完整代码工程下载： 编译代码方式： 功能实现：可以检测 进程是否 live 或者 僵死，然后根据具体状态，发signal 处理被检测的进程 demo 有两个进程 一个是 server 另一个是 client (可以有多个)（send && rece...
c++服务端开发心跳机制
荣耀与梦想来日方长
04-26 2628
高并发服务器开发，服务器心跳机制
心跳功能：c++
谁谁谁的的的博客
08-16 549
是计算机系统、网络设备或软件应用程序中的一种监测机制，用于定期检测系统或设备的运行状态以及与其它组件之间的连接是否正常。它模拟人类心跳的概念，定期发送信号来确认系统的活动状态。心跳信号是一个小型的数据包或请求，用于发送给要监测的系统或设备。这个信号可以是一个简单的网络请求、ping 指令、或者自定义的应用层数据包。实际上，心跳功能的实现方式因系统的类型和需求而异。当心跳信号不再收到或连接丢失时，可以根据系统的需求来执行一系列操作。要监测的系统或设备需要实现一个接收机制，来接收并处理来自发送方的心跳信号。
网络编程之发送结构体.zip
03-07
网络编程之发送结构体网络编程之发送结构体网络编程之发送结构体网络编程之发送结构体网络编程之发送结构体网络编程之发送结构体网络编程之发送结构体网络编程之发送结构体网络编程之发送结构体网络编程之发送结构体...
C语言和C++Builder学习笔记.rar_C++笔记_c++学习笔记_c/C++_学习笔记_编程语言
09-20
【C语言和C++Builder学习笔记】 C语言和C++是两种广泛使用的编程语言，它们在软件开发领域占据着重要地位。C语言以其简洁、高效和底层操作能力著称，而C++则在C的基础上引入了面向对象编程，极大地扩展了其应用范围...
c++ socket 编程
01-10
在IT行业中，网络通信是不可或缺的一部分，而C++作为强大的编程语言，经常被用来实现复杂的系统和网络应用。...通过不断实践和学习，你将能够掌握C++ Socket编程的精髓，为构建高效、可靠的网络应用打下坚实的基础。
C语言socket网络UDP编程例子源代码DevC++工程
04-02
此外，标签中提到了"C++"，虽然这个示例是基于C语言的，但C++与C语言兼容，因此你也可以使用C++进行socket编程，只是可以利用C++的面向对象特性来进一步封装和抽象网络通信过程。 总的来说，学习C语言的socket网络...
心率检测程序
03-29
基于51单片机设计一款脉搏实时测量系统，程序完整。可实现心率监测，实时显示心率值；报警模式选择，用户可自行设置心率报警上限或下限值，当心率超过上限或者低于下限时，蜂鸣器报警。
VC下实现的心跳包源码
12-19
VC下 控制台程序 本人正在学习通信编程 实现个简单的心跳包 目的在于理解心跳包的实现原理 谨适合初学者
TCP心跳包-定时连接检测
09-22
代码调试成功，适用于Linux环境，可实现服务器与客户端定时交互，判断网络是否掉线，定时间隔可修改客户端itemval相关参数
QT通过Tcp发送接收自定义结构体
09-18
QT是Qt库的缩写，它是一个跨平台的C++应用程序开发框架，广泛用于图形用户界面和网络编程。本主题将深入探讨如何在QT中利用TCP（传输控制协议）发送和接收自定义结构体，这对于实现高效、可靠的网络通信至关重要。 ...
C++网络编程学习：心跳机制与定时发送数据
这里是河边
05-08 6911
网络编程学习记录 使用的语言为C/C++ 源码支持的平台为：Windows（本文中内容使用windows平台下vs2019开发，故本文项目不完全支持linux平台） C++网络编程学习：项目化 (加入内存池静态库 / 报文动态库)  点我查看之前的代码开发记录 笔记十一网络编程学习记录0：本次增改内容1：更改客户端储存方式2：更改任务队列储存方式3：加入心跳检测机制4：加入定时发送缓存消息机制 0：本次增改内容 更改服务端中，客户端对象储存的方式，由vector改为map。 改变任务队列中任务储存方
C++ 服务器端学习之心跳控制
qq_18297893的博客
06-29 4285
网络游戏服务器的主要作用是模拟整个游戏世界，客户端用过网络连接把一些信息数据发给服务器，在操作合法的情况下，更新服务器上该客户端对应的player实体、所在场景等，并把这些操作及其影响广播出去。让别的客户端能显示这些操作。     在这个模拟过程中，需要解决的一个重要问题是：多长时间处理（更新）一次该服务器上的待处理事件，体现在实际开发中，这就是一个服务器端的心跳设计问题（tick）。
c++socket 心跳机制代码
yang_0103的博客
09-22 3189
server.h: #pragma once #include <WinSock2.h> #include <WS2tcpip.h> #include #pragma comment (lib ,“ws2_32.lib”) class server { public: server(); ~server(); void severStart(int port); voi...
LinuxC/C++编程基础(28) “心跳”信息的处理
linyanwen99的专栏
12-18 3067
写在前面：前面几篇文字已经把服务器端相关的叙述了，这里再把客户端的给加上 一.client.cpp函数的实现，如下： 1.构造函数的实现，如下： Client::Client():writable(true){     if((epfd = epoll_create(MAXEVENTS)) == -1){         exit(-1);     }     if((connf
Socket编程示例：C#服务端、客户端和心跳实现
weixin_48588665的博客
08-05 9310
本示例提供了使用C#编程语言实现Socket通信的完整示例代码。包括服务端和客户端的实现，服务端支持多个连接，并在客户端与服务端之间实现了心跳机制。心跳机制用于维持连接的活跃性和检测连接是否断开。服务端和客户端的代码都做了详细注释，方便阅读和理解。通过该示例，你将学习如何创建基本的服务端和客户端，并了解如何添加心跳功能以确保连接的稳定性。无论是初学者还是有经验的开发者，这个示例都将为你提供一个完整的Socket编程实现的参考。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值