socket网络编程示例C++——即时通信系统

最新推荐文章于 2024-09-20 14:00:56 发布
最新推荐文章于 2024-09-20 14:00:56 发布
阅读量843 收藏 8
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wteruiycbqqvwt/article/details/90404039
版权

一：项目内容

本项目使用C++实现一个具备服务器端和客户端即时通信且具有私聊功能的聊天室。

目的是学习C++网络开发的基本概念，同时也可以熟悉下Linux下的C++程序编译和简单MakeFile编写

二：需求分析

这个聊天室主要有两个程序：

1.服务端：能够接受新的客户连接，并将每个客户端发来的信息，广播给对应的目标客户端。

2.客户端：能够连接服务器，并向服务器发送消息，同时可以接收服务器发来的消息。

即最简单的C/S模型。

三：抽象与细化

服务端类需要支持：

1.支持多个客户端接入，实现聊天室基本功能。

2.启动服务，建立监听端口等待客户端连接。

3.使用epoll机制实现并发，增加效率。

4.客户端连接时，发送欢迎消息，并存储连接记录。

5.客户端发送消息时，根据消息类型，广播给所有用户(群聊)或者指定用户(私聊)。

6.客户端请求退出时，对相应连接信息进行清理。

客户端类需要支持：

1.连接服务器。

2.支持用户输入消息，发送给服务端。

3.接受并显示服务端发来的消息。

4.退出连接。

涉及两个事情，一个写，一个读。所以客户端需要两个进程分别支持以下功能。

子进程：

1.等待用户输入信息。

2.将聊天信息写入管道(pipe),并发送给父进程。

父进程：

1.使用epoll机制接受服务端发来的消息，并显示给用户，使用户看到其他用户的信息。

2.将子进程发送的聊天信息从管道(pipe)中读取出来，并发送给客户端。

四：相关技术介绍

1.socket 阻塞与非阻塞。

阻塞与非阻塞关注的是程序在等待调用结果时(消息，返回值)的状态。

阻塞调用是指在调用结果返回前，当前线程会被挂起，调用线程只有在得到调用结果之后才会返回。

非阻塞调用是指在不能立刻得到结果之前，该调用不会阻塞当前线程。

socket()函数创建套接字时，默认的套接字都是阻塞的，非阻塞设置方式代码：

//将文件描述符设置为非阻塞方式（利用fcntl函数）
fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, 0)| O_NONBLOCK);
2. epoll

当服务端的人数越来越多，会导致资源吃紧，I/O效率越来越低，这时就应该考虑epoll，epoll是Linux内核为处理大量句柄而改进的poll，是linux特有的I/O函数。其特点如下：

1）epoll是Linux下多路复用IO接口select/poll的增强版本，其实现和使用方式与select/poll大有不同，epoll通过一组函数来完成有关任务，而不是一个函数。

2）epoll之所以高效，是因为epoll将用户关心的文件描述符放到内核里的一个事件列表中，而不是像select/poll每次调用都需要重复传入文件描述符集或事件集（大量拷贝开销），比如一个事件发生，epoll无需遍历整个被监听的描述符集，而只需要遍历哪些被内核IO事件异步唤醒而加入就绪队列的描述符集合即可。

3)epoll有两种工作方式，LT(Level triggered) 水平触发 、ET(Edge triggered)边沿触发。LT是select/poll的工作方式，比较低效，而ET是epoll具有的高速工作方式。更多epoll之ET LT

Epoll 用法（三步曲）：

第一步：int epoll_create(int size)系统调用，创建一个epoll句柄，参数size用来告诉内核监听的数目，size为epoll支持的最大句柄数。

第二步:int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)  事件注册函数

参数 epfd为epoll的句柄。参数op 表示动作 三个宏来表示：EPOLL_CTL_ADD注册新fd到epfd 、EPOLL_CTL_MOD 修改已经注册的fd的监听事件、EPOLL_CTL_DEL从epfd句柄中删除fd。参数fd为需要监听的标识符。参数结构体epoll_event告诉内核需要监听的事件。

第三步：int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout) 等待事件的产生，通过调用收集在epoll监控中已经发生的事件。参数struct epoll_event 是事件队列 把就绪的事件放进去。

eg. 服务端使用epoll的时候步骤如下：

1.调用epoll_create()在linux内核中创建一个事件表。

2.然后将文件描述符(监听套接字listener)添加到事件表中

3.在主循环中，调用epoll_wait()等待返回就绪的文件描述符集合。

4.分别处理就绪的事件集合，本项目中一共有两类事件：新用户连接事件和用户发来消息事件。

五：代码结构

每个文件的作用：

1.Common.h：公共头文件，包括所有需要的宏以及socket网络编程头文件，以及消息结构体（用来表示消息类别等）

2.Client.h Client.cpp :客户端类的实现

3.Server.h Server.cpp : 服务端类的实现

4.ClientMain.cpp ServerMain.cpp 客户端及服务端的主函数。

六：代码实现

Common.h

定义一些共用的宏定义，包括一些共用的网络编程相关头文件。

1）定义一个函数将文件描述符fd添加到epfd表示的内核事件表中供客户端和服务端两个类使用。

2）定义一个信息数据结构，用来表示传送的信息，结构体包括发送方fd, 接收方fd,用来表示消息类别的type,还有文字信息。

函数recv() send() write() read() 参数传递是字符串，所以在传送前/接受后要把结构体转换为字符串/字符串转换为结构体。
 

//Common.h
#ifndef  CHATROOM_COMMON_H
#define CHATROOM_COMMON_H
 
#include <iostream>
#include <list>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
// 默认服务器端IP地址
#define SERVER_IP "127.0.0.1"
 
// 服务器端口号
#define SERVER_PORT 8888
 
// int epoll_create(int size)中的size
// 为epoll支持的最大句柄数
#define EPOLL_SIZE 5000
 
// 缓冲区大小65535
#define BUF_SIZE 0xFFFF
    
// 新用户登录后的欢迎信息
#define SERVER_WELCOME "Welcome you join to the chat room! Your chat ID is: Client #%d"
 
// 其他用户收到消息的前缀
#define SERVER_MESSAGE "ClientID %d say >> %s"
#define SERVER_PRIVATE_MESSAGE "Client %d say to you privately >> %s"
#define SERVER_PRIVATE_ERROR_MESSAGE "Client %d is not in the chat room yet~"
// 退出系统
#define EXIT "EXIT"
 
// 提醒你是聊天室中唯一的客户
#define CAUTION "There is only one int the char room!"
 
 
// 注册新的fd到epollfd中
// 参数enable_et表示是否启用ET模式，如果为True则启用，否则使用LT模式
static void addfd( int epollfd, int fd, bool enable_et )
{
    struct epoll_event ev;
    ev.data.fd = fd;
    ev.events = EPOLLIN;
    if( enable_et )
        ev.events = EPOLLIN | EPOLLET;
    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev);
    // 设置socket为非阻塞模式
    // 套接字立刻返回，不管I/O是否完成，该函数所在的线程会继续运行
    //eg. 在recv(fd...)时，该函数立刻返回，在返回时，内核数据还没准备好会返回WSAEWOULDBLOCK错误代码
    fcntl(fd, F_SETFL, fcntl(fd, F_GETFD, 0)| O_NONBLOCK);
    printf("fd added to epoll!\n\n");
}
 
//定义信息结构，在服务端和客户端之间传送
struct Msg
{
    int type;
    int fromID;
    int toID;
    char content[BUF_SIZE];
 
};
#endif // CHATROOM_COMMON_H

服务端类 Server.h Server.cpp

服务端需要的接口：

1)init()初始化

2)Start()启动服务

3)Close()关闭服务

4)广播消息给所有客户端函数 SendBroadcastMessage()

服务端的主循环中每次都会检查并处理EPOLL中的就绪事件，而就绪事件列表主要是两种类型：新连接或新消息。服务器会依次从就绪事件列表里提取事件进行处理，如果是新连接则accept()然后addfd(),如果是新消息则SendBroadcastMessage()实现聊天功能。

//Server.h
#ifndef CHATROOM_SERVER_H
#define CHATROOM_SERVER_H
 
#include <string>
 
#include "Common.h"
 
using namespace std;
 
// 服务端类，用来处理客户端请求
class Server {
 
public:
    // 无参数构造函数
    Server();
 
    // 初始化服务器端设置
    void Init();
 
    // 关闭服务
    void Close();
 
    // 启动服务端
    void Start();
 
private:
    // 广播消息给所有客户端
    int SendBroadcastMessage(int clientfd);
 
    // 服务器端serverAddr信息
    struct sockaddr_in serverAddr;
    
    //创建监听的socket
    int listener;
 
    // epoll_create创建后的返回值
    int epfd;
    
    // 客户端列表
    list<int> clients_list;
};
#endif
//Server.cpp
#include <iostream>
 
#include "Server.h"
 
using namespace std;
 
// 服务端类成员函数
 
// 服务端类构造函数
Server::Server(){
    
    // 初始化服务器地址和端口
    serverAddr.sin_family = PF_INET;
    serverAddr.sin_port = htons(SERVER_PORT);
    serverAddr.sin_addr.s_addr = inet_addr(SERVER_IP);
 
    // 初始化socket
    listener = 0;
    
    // epool fd
    epfd = 0;
}
// 初始化服务端并启动监听
void Server::Init() {
    cout << "Init Server..." << endl;
    
     //创建监听socket
    listener = socket(PF_INET, SOCK_STREAM, 0);
    if(listener < 0) { perror("listener"); exit(-1);}
    
    //绑定地址
    if( bind(listener, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) < 0) {
        perror("bind error");
        exit(-1);
    }
 
    //监听
    int ret = listen(listener, 5);
    if(ret < 0) {
        perror("listen error"); 
        exit(-1);
    }
 
    cout << "Start to listen: " << SERVER_IP << endl;
 
    //在内核中创建事件表 epfd是一个句柄 
    epfd = epoll_create (EPOLL_SIZE);
    
    if(epfd < 0) {
        perror("epfd error");
        exit(-1);
    }
 
    //往事件表里添加监听事件
    addfd(epfd, listener, true);
 
}
 
// 关闭服务，清理并关闭文件描述符
void Server::Close() {
 
    //关闭socket
    close(listener);
    
    //关闭epoll监听
    close(epfd);
}
 
// 发送广播消息给所有客户端
int Server::SendBroadcastMessage(int clientfd)
{
    // buf[BUF_SIZE] 接收新消息
    // message[BUF_SIZE] 保存格式化的消息
    char recv_buf[BUF_SIZE];
    char send_buf[BUF_SIZE];
    Msg msg;
    bzero(recv_buf, BUF_SIZE);
    // 接收新消息
    cout << "read from client(clientID = " << clientfd << ")" << endl;
    int len = recv(clientfd, recv_buf, BUF_SIZE, 0);
    //清空结构体，把接受到的字符串转换为结构体
    memset(&msg,0,sizeof(msg));
    memcpy(&msg,recv_buf,sizeof(msg));
    //判断接受到的信息是私聊还是群聊
    msg.fromID=clientfd;
    if(msg.content[0]=='\\'&&isdigit(msg.content[1])){
        msg.type=1;
        msg.toID=msg.content[1]-'0';
        memcpy(msg.content,msg.content+2,sizeof(msg.content));
    }
    else
        msg.type=0;
    // 如果客户端关闭了连接
    if(len == 0) 
    {
        close(clientfd);
        
        // 在客户端列表中删除该客户端
        clients_list.remove(clientfd);
        cout << "ClientID = " << clientfd 
             << " closed.\n now there are " 
             << clients_list.size()
             << " client in the char room"
             << endl;
 
    }
    // 发送广播消息给所有客户端
    else 
    {
        // 判断是否聊天室还有其他客户端
        if(clients_list.size() == 1){ 
            // 发送提示消息
            memcpy(&msg.content,CAUTION,sizeof(msg.content));
            bzero(send_buf, BUF_SIZE);
            memcpy(send_buf,&msg,sizeof(msg));
            send(clientfd, send_buf, sizeof(send_buf), 0);
            return len;
        }
        //存放格式化后的信息
        char format_message[BUF_SIZE];
        //群聊
        if(msg.type==0){
            // 格式化发送的消息内容 #define SERVER_MESSAGE "ClientID %d say >> %s"
            sprintf(format_message, SERVER_MESSAGE, clientfd, msg.content);
            memcpy(msg.content,format_message,BUF_SIZE);
            // 遍历客户端列表依次发送消息，需要判断不要给来源客户端发
            list<int>::iterator it;
            for(it = clients_list.begin(); it != clients_list.end(); ++it) {
               if(*it != clientfd){
                    //把发送的结构体转换为字符串
                    bzero(send_buf, BUF_SIZE);
                    memcpy(send_buf,&msg,sizeof(msg));
                    if( send(*it,send_buf, sizeof(send_buf), 0) < 0 ) {
                        return -1;
                    }
               }
            }
        }
        //私聊
        if(msg.type==1){
            bool private_offline=true;
            sprintf(format_message, SERVER_PRIVATE_MESSAGE, clientfd, msg.content);
            memcpy(msg.content,format_message,BUF_SIZE);
            // 遍历客户端列表依次发送消息，需要判断不要给来源客户端发
            list<int>::iterator it;
            for(it = clients_list.begin(); it != clients_list.end(); ++it) {
               if(*it == msg.toID){
                    private_offline=false;
                    //把发送的结构体转换为字符串
                    bzero(send_buf, BUF_SIZE);
                    memcpy(send_buf,&msg,sizeof(msg));
                    if( send(*it,send_buf, sizeof(send_buf), 0) < 0 ) {
                        return -1;
                    }
               }
            }
            //如果私聊对象不在线
            if(private_offline){
                sprintf(format_message,SERVER_PRIVATE_ERROR_MESSAGE,msg.toID);
                memcpy(msg.content,format_message,BUF_SIZE);
                bzero(send_buf,BUF_SIZE);
                memcpy(send_buf,&msg,sizeof(msg));
                if(send(msg.fromID,send_buf,sizeof(send_buf),0)<0)
                    return -1;
            }
        }
    }
    return len;
}
 
// 启动服务端
void Server::Start() {
 
    // epoll 事件队列
    static struct epoll_event events[EPOLL_SIZE]; 
 
    // 初始化服务端
    Init();
 
    //主循环
    while(1)
    {
        //epoll_events_count表示就绪事件的数目
        int epoll_events_count = epoll_wait(epfd, events, EPOLL_SIZE, -1);
 
        if(epoll_events_count < 0) {
            perror("epoll failure");
            break;
        }
 
        cout << "epoll_events_count =\n" << epoll_events_count << endl;
 
        //处理这epoll_events_count个就绪事件
        for(int i = 0; i < epoll_events_count; ++i)
        {
            int sockfd = events[i].data.fd;
            //新用户连接
            if(sockfd == listener)
            {
                struct sockaddr_in client_address;
                socklen_t client_addrLength = sizeof(struct sockaddr_in);
                int clientfd = accept( listener, ( struct sockaddr* )&client_address, &client_addrLength );
 
                cout << "client connection from: "
                     << inet_ntoa(client_address.sin_addr) << ":"
                     << ntohs(client_address.sin_port) << ", clientfd = "
                     << clientfd << endl;
 
                addfd(epfd, clientfd, true);
 
                // 服务端用list保存用户连接
                clients_list.push_back(clientfd);
                cout << "Add new clientfd = " << clientfd << " to epoll" << endl;
                cout << "Now there are " << clients_list.size() << " clients int the chat room" << endl;
 
                // 服务端发送欢迎信息  
                cout << "welcome message" << endl;                
                char message[BUF_SIZE];
                bzero(message, BUF_SIZE);
                sprintf(message, SERVER_WELCOME, clientfd);
                int ret = send(clientfd, message, BUF_SIZE, 0);
                if(ret < 0) {
                    perror("send error");
                    Close();
                    exit(-1);
                }
            }
            //处理用户发来的消息，并广播，使其他用户收到信息
            else {   
                int ret = SendBroadcastMessage(sockfd);
                if(ret < 0) {
                    perror("error");
                    Close();
                    exit(-1);
                }
            }
        }
    }
 
    // 关闭服务
    Close();
}

客户端类实现

需要的接口：

1)连接服务端connect()

2)退出连接close()

3)启动客户端Start()

//Client.h
#ifndef CHATROOM_CLIENT_H
#define CHATROOM_CLIENT_H
 
#include <string>
#include "Common.h"
 
using namespace std;
 
// 客户端类，用来连接服务器发送和接收消息
class Client {
 
public:
    // 无参数构造函数
    Client();
 
    // 连接服务器
    void Connect();
 
    // 断开连接
    void Close();
 
    // 启动客户端
    void Start();
 
private:
 
    // 当前连接服务器端创建的socket
    int sock;
 
    // 当前进程ID
    int pid;
    
    // epoll_create创建后的返回值
    int epfd;
 
    // 创建管道，其中fd[0]用于父进程读，fd[1]用于子进程写
    int pipe_fd[2];
 
    // 表示客户端是否正常工作
    bool isClientwork;
 
    // 聊天信息
    Msg msg;
    //结构体要转换为字符串
    char send_buf[BUF_SIZE];
    char recv_buf[BUF_SIZE];
    //用户连接的服务器 IP + port
    struct sockaddr_in serverAddr;
};
#endif
//Client.cpp
#include <iostream>
 
#include "Client.h"
 
using namespace std;
 
// 客户端类成员函数
 
// 客户端类构造函数
Client::Client(){
    
    // 初始化要连接的服务器地址和端口
    serverAddr.sin_family = PF_INET;
    serverAddr.sin_port = htons(SERVER_PORT);
    serverAddr.sin_addr.s_addr = inet_addr(SERVER_IP);
    
    // 初始化socket
    sock = 0;
    
    // 初始化进程号
    pid = 0;
    
    // 客户端状态
    isClientwork = true;
    
    // epool fd
    epfd = 0;
}
 
// 连接服务器
void Client::Connect() {
    cout << "Connect Server: " << SERVER_IP << " : " << SERVER_PORT << endl;
    
    // 创建socket
    sock = socket(PF_INET, SOCK_STREAM, 0);
    if(sock < 0) {
        perror("sock error");
        exit(-1); 
    }
 
    // 连接服务端
    if(connect(sock, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) < 0) {
        perror("connect error");
        exit(-1);
    }
 
    // 创建管道，其中fd[0]用于父进程读，fd[1]用于子进程写
    if(pipe(pipe_fd) < 0) {
        perror("pipe error");
        exit(-1);
    }
 
    // 创建epoll
    epfd = epoll_create(EPOLL_SIZE);
    
    if(epfd < 0) {
        perror("epfd error");
        exit(-1); 
    }
 
    //将sock和管道读端描述符都添加到内核事件表中
    addfd(epfd, sock, true);
    addfd(epfd, pipe_fd[0], true);
 
}
 
// 断开连接，清理并关闭文件描述符
void Client::Close() {
 
    if(pid){
       //关闭父进程的管道和sock
        close(pipe_fd[0]);
        close(sock);
    }else{
        //关闭子进程的管道
        close(pipe_fd[1]);
    }
}
 
// 启动客户端
void Client::Start() {
 
    // epoll 事件队列
    static struct epoll_event events[2];
    
    // 连接服务器
    Connect();
    
    // 创建子进程
    pid = fork();
    
    // 如果创建子进程失败则退出
    if(pid < 0) {
        perror("fork error");
        close(sock);
        exit(-1);
    } else if(pid == 0) {
        // 进入子进程执行流程
        //子进程负责写入管道，因此先关闭读端
        close(pipe_fd[0]); 
 
        // 输入exit可以退出聊天室
        cout << "Please input 'exit' to exit the chat room" << endl;
        cout<<"\\ + ClientID to private chat "<<endl;
        // 如果客户端运行正常则不断读取输入发送给服务端
        while(isClientwork){
            //清空结构体
            memset(msg.content,0,sizeof(msg.content));
            fgets(msg.content, BUF_SIZE, stdin);
            // 客户输出exit,退出
            if(strncasecmp(msg.content, EXIT, strlen(EXIT)) == 0){
                isClientwork = 0;
            }
            // 子进程将信息写入管道
            else {
                //清空发送缓存
                memset(send_buf,0,BUF_SIZE);
                //结构体转换为字符串
                memcpy(send_buf,&msg,sizeof(msg));
                if( write(pipe_fd[1], send_buf, sizeof(send_buf)) < 0 ) { 
                    perror("fork error");
                    exit(-1);
                }
            }
        }
    } else { 
        //pid > 0 父进程
        //父进程负责读管道数据，因此先关闭写端
        close(pipe_fd[1]); 
 
        // 主循环(epoll_wait)
        while(isClientwork) {
            int epoll_events_count = epoll_wait( epfd, events, 2, -1 );
 
            //处理就绪事件
            for(int i = 0; i < epoll_events_count ; ++i)
            {
                memset(recv_buf,0,sizeof(recv_buf));
                //服务端发来消息
                if(events[i].data.fd == sock)
                {
                    //接受服务端广播消息
                    int ret = recv(sock, recv_buf, BUF_SIZE, 0);
                    //清空结构体
                    memset(&msg,0,sizeof(msg));
                    //将发来的消息转换为结构体
                    memcpy(&msg,recv_buf,sizeof(msg));
 
                    // ret= 0 服务端关闭
                    if(ret == 0) {
                        cout << "Server closed connection: " << sock << endl;
                        close(sock);
                        isClientwork = 0;
                    } else {
                        cout << msg.content << endl;
                    }
                }
                //子进程写入事件发生，父进程处理并发送服务端
                else { 
                    //父进程从管道中读取数据
                    int ret = read(events[i].data.fd, recv_buf, BUF_SIZE);
                    // ret = 0
                    if(ret == 0)
                        isClientwork = 0;
                    else {
                        // 将从管道中读取的字符串信息发送给服务端
                        send(sock, recv_buf, sizeof(recv_buf), 0);
                    }
                }
            }//for
        }//while
    }
    
    // 退出进程
    Close();
}

七、自测效果

panamera12
关注
C/C++ Socket简单实例
马基客的博客
06-29 544
前言 该代码是拷贝网上的案例代码，但是笔者在运行时发现，在accept接收一次连接之后，无法堵塞，不断进入死循环，且接收不到任何客户端发送的socket连接。 后查阅资料，在accept()后面加入以下代码发现错误信息：10093 printf("%d",WSAGetLastError()); 10093的错误，应用程序没有调用 WSAStartup，或者 WSAStartup 失败。 问题描述：Failed to create UDP socket:10093!Close and restart app
【Socket】WSL下Socket编程示例及理解
大熊的笔记
07-11 1760
文章目录问题描述Linux Socket 编程理解示例代码一 服务端向客户端发送数据示例代码二 客户端向服务端发送数据示例代码三 迭代回声参考链接 问题描述 平台：WSL 代码功能：server 向 client 发送消息，client 读取消息并显示。 示例代码一：server 只接受一次 client 请求，当 server 向 client 传回数据后，程序就运行结束了。如果想再次接收到服务器的数据，必须再次运行 server，所以这是一个非常简陋的 socket 程序，不能够一直接受客户端的请求。
C++ socket网络编程——即时通信系统
热门推荐
斯斯的博客
06-07 5万+
一：项目内容本项目使用C++实现一个具备服务器端和客户端即时通信且具有私聊功能的聊天室。目的是学习C++网络开发的基本概念，同时也可以熟悉下Linux下的C++程序编译和简单MakeFile编写二：需求分析这个聊天室主要有两个程序：1.服务端：能够接受新的客户连接，并将每个客户端发来的信息，广播给对应的目标客户端。2.客户端：能够连接服务器，并向服务器发送消息，同时可以接收服务器发来的消息。即最简...
C++网络编程入门学习（二）-- socket通信
最新发布
小L的博客
09-20 1388
本博客将介绍C++网络编程中的socket通信，通过socket通信可以实现不同主机之间的数据传输。首先，我们将介绍socket的概念和基本原理，包括服务器和客户端的创建和连接过程。然后，我们将讨论socket通信的常用函数和方法，例如发送和接收数据，以及处理连接错误和异常情况。最后，我们将给出一个简单的示例代码，演示如何使用socket进行基本的聊天应用程序。通过本文的学习，读者将能够掌握C++网络编程中的socket通信基础知识，为进一步深入学习和应用打下坚实的基础。
C++ Socket编程实例解析
LiTong
10-21 3万+
Socket socket本质是编程接口(API)，对TCP/IP的封装，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口；HTTP是轿车，提供了封装或者显示数据的具体形式;Socket是发动机，提供了网络通信的能力。 在Internet上的主机一般运行了多个服务软件，同时提供几种服务。每种服务都打开一个Socket，并绑定到一个端口上，不同的端口对应于不同的
C++ 简易Socket实例
maizaozao的专栏
06-20 557
C++ 简易Socket实例   |举报|字号 订阅 首先是两个程序，分别是socket的客户端和服务端。（在windows系统vc6.0编译） 服务器端： #include #include #pragma comment(lib,"WS2_32.lib") void main() {     WSADATA wsd;     SOCK
C++ Socket 实例
weixin_34320724的博客
08-08 121
服务端：#include "stdafx.h" #include <Winsock2.h> #include <cstdio> #include <iostream> #pragma comment(lib,"ws2_32.lib") int main() { WSADATA wsdata = {0}; WSASta...
_linux下C++ socket网络编程——即时通信系统（含源码）
05-29
以下是一个简单的即时通信系统的C++网络编程示例，基于Linux平台使用socket库进行开发。 客户端代码： ```c++ #include #include #include <sys/socket.h> #include #include using namespace std; int main...
C++实现模拟即时通信系统的关键技术解析
资源摘要信息:"模拟即时通信系统——基于C++的实现与解析" 即时通信系统的构建涉及到计算机网络、操作系统、数据结构、设计模式等多个计算机科学领域的知识。本文以C++为工具，模拟即时通信系统的核心功能，具体...
Linux tcp客户端断开重连,Linux网络编程——TCP和UDP通信
weixin_36228334的博客
05-12 1561
TCP协议流程图、TCP建立即时聊天TCP即时聊天升级：服务器在客户端断开后不断开，客户端可以多次重连服务器进行即时聊天UDP协议流程图、UDP建立即时连接如果在已经处于 ESTABLISHED状态下的socket(一般由端口号和标志符区分)需调用closesocket(一般不会立即关闭而经历TIME_WAIT的过程)后想继续重用该socket，但也可以直接用setsockopt和reuse。SO...
C++ 实现即时通信软件（直接运行）
mitongxue的博客
04-26 6896
题目 由于本学期上了网络编程课程，老师要求写使用Socke实现网络编程。于是参考 C++多线程实现即时通信软件 写出了简单版本的没有界面的即时通信软件。 软件：VS 直接上代码，需要讲解原理的，可以参考 C++多线程实现即时通信软件 服务器端 //TcpServer_plus.exe #include<stdio.h> #include <Winsock2.h> #include<WS2tcpip.h> #pragma comment(lib,"ws2_32.lib")
C++网络编程
bsegebr的博客
08-14 488
accept等待到客户端的连接后，创建一个新的socket，函数返回值就是这个新的socket，服务端用于这个新的socket和客户端进行报文的收发。UDP不是一个可靠的协议，对数据的长度有限制，但是它的速度比较高。计算机是通过TCP/IP协议进行互联从而进行通信的，为了把复杂的TCP/IP协议隐藏起来，更方便的实现计算机中两个程序进行通信，引出了socket这个概念。函数功能：服务端把用于通信的地址和端口绑定到socket上，当bind函数返回0时，为正确绑定，返回-1，则为绑定失败。...
基于c++的即时通讯
05-16
该程序实现了绑定MAC地址实现局域网通讯。或者可以绑定IP进行网络通讯聊天。
c++ socket编程实例（服务端及客户端）
05-23
本代码是c++ socket编程实例。包含客户端和服务端，可以实现客户端发送消息，服务端接收消息并写入日志。 server.cpp为服务端。 client.cpp为客户端。
Linux C++ socket编程实例
qq_22613757的博客
03-24 7402
文章目录socket基本过程基本的局域网聊天局域网TCP服务器端局域网TCP客户端客户端服务端双向异步聊天异步聊天服务器端代码异步聊天客户端代码局域网内服务端和有限个客户端聊天局域网TCP 2人聊天服务器端代码局域网TCP 2人聊天客户端代码完美异步聊天服务端和客户端无限个客户聊天的服务器端代码无限个客户端连接的客户端代码 服务端: 服务器端初始化socket，然后与端口绑定，对端口进行监听，调...
C++ socket 网络编程 即时通信系统
Shanks
02-07 1215
以下内容转载自https://www.toutiao.com/i6852978925627245060/ lee哥的服务器开发2020-07-24 17:38:14 一：项目内容 本项目使用C++实现一个具备服务器端和客户端即时通信且具有私聊功能的聊天室。 目的是学习C++网络开发的基本概念，同时也可以熟悉下Linux下的C++程序编译和简单MakeFile编写 分享一个即时通讯的实战项目给大家：即时通讯实战项目 需要Linux服务器开发高阶学习资料的朋友可以后台私信【架构】获取 包括Lin.
VisualC++开发的即时通讯系统（类似QQ）
12-24
VisualC++开发的即时通讯系统（类似QQ）
C++实现即时通信软件
e31006的博客
04-11 1万+
1.1 实验内容 本实验使用 C++ 实现一个具备服务器端和客户端的即时通信聊天室。 这个项目会学习C++网络开发的基本概念，同时可以熟悉Linux下的C++程序编译方法及简单的Makefile编写。 1.2 实验知识点 C++语言基本语法 基本的Makefile C++面向对象程序设计 epoll 网络编程 1.3 实验环境 g++ Xfce 终端 2.1 需求分析 在这个聊天室软件中我...
Linux C/C++ TCP Socket通信实例
zhangzx36的博客
10-20 214
分别打开两个终端窗口，一个执行./server命令，一个执行./client 127.0.0.1命令，表示连上本机的6666端口，执行./server命令的要先执行。执行./client 127.0.0.1命令后，会提示说要发给server的内容，输入“hello”后，client客户端执行完毕，这时可以看到server的那个终端窗口输出“recv msg from client: hello”。下面用TCP协议编写一个简单的服务器、客户端，其中服务器端一直监听本机的6666号端口。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值