C++ 学习网络编程 2025年6月17日19:56:47

最新推荐文章于 2025-08-05 08:41:01 发布

梦境虽美，却不长

最新推荐文章于 2025-08-05 08:41:01 发布

阅读量447

点赞数 4

CC 4.0 BY-SA版权

分类专栏： C++ 学习文章标签：学习网络 C++网络编程库

本文链接：https://blog.youkuaiyun.com/qq_43422073/article/details/148722768

C++ 学习专栏收录该内容

5 篇文章

订阅专栏

网络编程

C++网络编程允许开发者创建能够通过网络进行通信的应用程序。以下是C++网络编程的主要方面和常用技术：

基础概念

套接字(Socket)编程：网络通信的基础

协议：TCP(可靠连接)和UDP(无连接)

IP地址和端口：标识网络中的主机和服务

常用API

Berkeley套接字(BSD套接字)

实现了一个 基础的TCP服务器，它会监听本地的8080端口，接受客户端连接，并进行简单的数据收发。

#include <sys/socket.h>   // 提供socket相关函数和数据结构
#include <netinet/in.h>   // 包含IP地址和端口号的定义
#include <arpa/inet.h>    // 提供IP地址转换函数

// 创建TCP套接字
// AF_INET表示IPv4协议，SOCK_STREAM表示面向连接的TCP套接字
// 返回值：成功返回套接字描述符，失败返回-1
int sockfd = socket(AF_INET, SOCK_STREAM, 0);

// 配置服务器地址结构体
struct sockaddr_in serv_addr;
serv_addr.sin_family = AF_INET;          // 使用IPv4地址族
serv_addr.sin_port = htons(8080);        // 设置端口号为8080（htons将主机字节序转为网络字节序）
serv_addr.sin_addr.s_addr = INADDR_ANY;  // 允许接收任意网卡（所有IP地址）的连接

// 将套接字绑定到指定地址和端口
// 成功返回0，失败返回-1
bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));

// 开始监听连接请求
// 参数5表示等待连接队列的最大长度（即允许的未完成连接数）
listen(sockfd, 5);

// 接受客户端连接（阻塞调用，直到有客户端连接）
struct sockaddr_in cli_addr;            // 用于存储客户端地址信息
socklen_t clilen = sizeof(cli_addr);    // 客户端地址结构体长度
// 返回值newsockfd是专门与这个客户端通信的新套接字描述符
int newsockfd = accept(sockfd, (struct sockaddr*)&cli_addr, &clilen);

// 发送数据到客户端
// buffer：要发送的数据缓冲区
// strlen(buffer)：实际发送的数据长度
// 返回值：成功返回发送的字节数，失败返回-1
send(newsockfd, buffer, strlen(buffer), 0);

// 从客户端接收数据
// buffer：接收数据的缓冲区
// sizeof(buffer)：缓冲区最大容量
// 返回值：成功返回接收的字节数（0表示连接关闭），失败返回-1
recv(newsockfd, buffer, sizeof(buffer), 0);

创建socket >创建一个用于TCP通信的套接字（类似"电话机"）
绑定bind>将套接字与指定的IP和端口绑定（类似"插电话线到插座"）
监听listen>启动监听模式，等待客户端连接（类似"电话待机状态"）
接受accept>接受客户端的连接请求（类似"接听电话"）
通信send/recv>数据收recv / 发send

典型应用场景

简单聊天程序：服务器接收客户端消息并回复。
远程控制：客户端发送指令，服务器执行操作。
文件传输：通过TCP可靠传输文件。

Windows套接字(Winsock)

#include <winsock2.h>    // Windows Socket API头文件
#include <ws2tcpip.h>    // 用于IP地址转换等扩展功能
#include <iostream>
#pragma comment(lib, "ws2_32.lib")  // 自动链接Winsock库

int main() {
    // 1. 初始化Winsock（Windows特有）
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {  // 请求2.2版本
        std::cerr << "WSAStartup failed: " << WSAGetLastError() << std::endl;
        return 1;
    }
    std::cout << "Winsock初始化成功！" << std::endl;

    // 2. 创建TCP套接字
    SOCKET serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (serverSocket == INVALID_SOCKET) {
        std::cerr << "socket创建失败: " << WSAGetLastError() << std::endl;
        WSACleanup();
        return 1;
    }
    std::cout << "TCP套接字创建成功！" << std::endl;

    // 3. 配置服务器地址
    sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;              // IPv4地址族
    serverAddr.sin_port = htons(8080);            // 监听8080端口
    serverAddr.sin_addr.s_addr = INADDR_ANY;      // 监听所有本地IP地址
    // inet_pton(AF_INET, "127.0.0.1", &serverAddr.sin_addr); // 也可指定IP

    // 4. 绑定套接字到地址
    if (bind(serverSocket, (sockaddr*)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR) {
        std::cerr << "绑定失败: " << WSAGetLastError() << std::endl;
        closesocket(serverSocket);
        WSACleanup();
        return 1;
    }
    std::cout << "套接字绑定到0.0.0.0:8080成功！" << std::endl;

    // 5. 开始监听
    if (listen(serverSocket, SOMAXCONN) == SOCKET_ERROR) {  // SOMAXCONN是最大队列长度
        std::cerr << "监听失败: " << WSAGetLastError() << std::endl;
        closesocket(serverSocket);
        WSACleanup();
        return 1;
    }
    std::cout << "正在监听端口8080..." << std::endl;

    // 6. 接受客户端连接
    sockaddr_in clientAddr;
    int clientAddrLen = sizeof(clientAddr);
    SOCKET clientSocket = accept(serverSocket, (sockaddr*)&clientAddr, &clientAddrLen);
    if (clientSocket == INVALID_SOCKET) {
        std::cerr << "接受连接失败: " << WSAGetLastError() << std::endl;
        closesocket(serverSocket);
        WSACleanup();
        return 1;
    }

    // 打印客户端信息
    char clientIP[INET_ADDRSTRLEN];
    inet_ntop(AF_INET, &clientAddr.sin_addr, clientIP, INET_ADDRSTRLEN);
    std::cout << "客户端连接来自: " << clientIP << ":" << ntohs(clientAddr.sin_port) << std::endl;

    // 7. 收发数据
    const char* welcomeMsg = "欢迎连接到TCP服务器！";
    if (send(clientSocket, welcomeMsg, strlen(welcomeMsg), 0) == SOCKET_ERROR) {
        std::cerr << "发送失败: " << WSAGetLastError() << std::endl;
    }

    char recvBuf[1024];
    int bytesReceived = recv(clientSocket, recvBuf, sizeof(recvBuf), 0);
    if (bytesReceived > 0) {
        recvBuf[bytesReceived] = '\0';  // 添加字符串结束符
        std::cout << "收到客户端消息: " << recvBuf << std::endl;
    }

    // 8. 清理资源
    closesocket(clientSocket);
    closesocket(serverSocket);
    WSACleanup();
    std::cout << "服务器已关闭。" << std::endl;

    return 0;
}

现代C++网络库

Boost.Asio

服务器端代码示例

#include <boost/asio.hpp>
#include <iostream>

// 使用Boost.Asio命名空间
using namespace boost::asio;
using ip::tcp;

int main() {
    try {
        // 1. 创建I/O执行上下文（事件循环核心）
        io_service io_service;

        // 2. 创建TCP接收器（监听8080端口）
        //    tcp::v4()表示IPv4，tcp::endpoint指定监听所有地址的8080端口
        tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v4(), 8080));
        std::cout << "服务器启动，监听端口8080..." << std::endl;

        // 3. 等待客户端连接（同步阻塞方式）
        tcp::socket socket(io_service);  // 创建套接字对象
        acceptor.accept(socket);         // 阻塞直到有客户端连接

        // 获取客户端端点信息
        std::string client_ip = socket.remote_endpoint().address().to_string();
        unsigned short client_port = socket.remote_endpoint().port();
        std::cout << "客户端连接来自: " << client_ip << ":" << client_port << std::endl;

        // 4. 向客户端发送欢迎消息
        std::string message = "Hello from Boost.Asio server!";
        boost::system::error_code error;
        write(socket, buffer(message), error);  // 同步写入数据

        // 检查发送是否成功
        if (error) {
            std::cerr << "发送失败: " << error.message() << std::endl;
        } else {
            std::cout << "消息已发送至客户端" << std::endl;
        }

        // 5. 接收客户端数据（可选）
        boost::asio::streambuf receive_buffer;
        read_until(socket, receive_buffer, "\n", error);  // 读取直到换行符
        if (!error) {
            std::istream is(&receive_buffer);
            std::string client_message;
            std::getline(is, client_message);
            std::cout << "收到客户端消息: " << client_message << std::endl;
        } else {
            std::cerr << "接收错误: " << error.message() << std::endl;
        }

        // 6. 关闭连接（RAII机制会自动关闭）
    } catch (std::exception& e) {
        std::cerr << "异常: " << e.what() << std::endl;
        return 1;
    }

    return 0;
}

客户端测试代码示例

#include <boost/asio.hpp>
#include <iostream>

using namespace boost::asio;
using ip::tcp;

int main() {
    try {
        io_service io_service;

        // 1. 解析服务器地址和端口
        tcp::resolver resolver(io_service);
        tcp::resolver::query query("127.0.0.1", "8080");
        tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);

        // 2. 创建并连接套接字
        tcp::socket socket(io_service);
        boost::asio::connect(socket, endpoint_iterator);

        // 3. 接收服务器消息
        boost::asio::streambuf receive_buffer;
        read_until(socket, receive_buffer, "\n");
        std::istream is(&receive_buffer);
        std::string server_message;
        std::getline(is, server_message);
        std::cout << "服务器说: " << server_message << std::endl;

        // 4. 发送响应消息
        std::string message = "Hello from client!\n";
        write(socket, buffer(message));

    } catch (std::exception& e) {
        std::cerr << "异常: " << e.what() << std::endl;
    }
    return 0;
}

# 编译服务器（假设保存为server.cpp）
g++ -std=c++11 server.cpp -o server -lboost_system

# 编译客户端
g++ -std=c++11 client.cpp -o client -lboost_system

# 运行（两个终端分别执行）
./server
./client

POCO网络库

#include <Poco/Net/TCPServer.h>
#include <Poco/Net/TCPServerConnection.h>
#include <Poco/Net/TCPServerConnectionFactory.h>

class MyConnection: public Poco::Net::TCPServerConnection {
public:
    MyConnection(const StreamSocket& s): TCPServerConnection(s) {}
    
    void run() {
        StreamSocket& ss = socket();
        ss.sendBytes("Hello from POCO server!", 22);
    }
};

// 创建服务器
TCPServer srv(new TCPServerConnectionFactoryImpl<MyConnection>(), 8080);
srv.start();

HTTP客户端/服务器

使用cpp-httplib库

#include <httplib.h>

// 服务器
httplib::Server svr;
svr.Get("/hi", [](const httplib::Request&, httplib::Response& res) {
    res.set_content("Hello World!", "text/plain");
});
svr.listen("localhost", 8080);

// 客户端
httplib::Client cli("localhost", 8080);
auto res = cli.Get("/hi");
if (res && res->status == 200) {
    std::cout << res->body << std::endl;
}