如何将C/C++套接字发送和接收函数封装在一个类中？

将C/C++套接字发送和接收函数封装在一个类中，可以提高代码的可维护性和复用性。下面是一个简单的示例，展示了如何实现这样的封装。

基础概念

套接字（Socket）是网络通信的基本构建块，允许不同计算机之间的进程进行通信。C/C++中的套接字编程主要涉及以下几个函数：

socket()：创建一个套接字。
bind()：将套接字绑定到一个地址。
listen()：监听传入连接。
accept()：接受一个传入连接。
connect()：连接到远程套接字。
send()：发送数据。
recv()：接收数据。
close()：关闭套接字。

封装类的设计

我们可以设计一个类来封装这些函数，使其更易于使用和管理。

示例代码

#include <iostream>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

class Socket {
public:
    Socket() : sockfd(-1) {}

    ~Socket() {
        if (sockfd != -1) {
            close(sockfd);
        }
    }

    bool create() {
        sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (sockfd < 0) {
            std::cerr << "Error creating socket" << std::endl;
            return false;
        }
        return true;
    }

    bool bind(const std::string& ip, int port) {
        struct sockaddr_in serv_addr;
        memset(&serv_addr, 0, sizeof(serv_addr));
        serv_addr.sin_family = AF_INET;
        serv_addr.sin_port = htons(port);
        if (inet_pton(AF_INET, ip.c_str(), &serv_addr.sin_addr) <= 0) {
            std::cerr << "Invalid address/ Address not supported" << std::endl;
            return false;
        }
        if (::bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
            std::cerr << "Bind failed" << std::endl;
            return false;
        }
        return true;
    }

    bool listen(int backlog = 5) {
        if (::listen(sockfd, backlog) < 0) {
            std::cerr << "Listen failed" << std::endl;
            return false;
        }
        return true;
    }

    int accept(struct sockaddr_in *client_addr, socklen_t *addrlen) {
        int new_socket = ::accept(sockfd, (struct sockaddr *)client_addr, addrlen);
        if (new_socket < 0) {
            std::cerr << "Accept failed" << std::endl;
        }
        return new_socket;
    }

    bool connect(const std::string& ip, int port) {
        struct sockaddr_in serv_addr;
        memset(&serv_addr, 0, sizeof(serv_addr));
        serv_addr.sin_family = AF_INET;
        serv_addr.sin_port = htons(port);
        if (inet_pton(AF_INET, ip.c_str(), &serv_addr.sin_addr) <= 0) {
            std::cerr << "Invalid address/ Address not supported" << std::endl;
            return false;
        }
        if (::connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
            std::cerr << "Connection failed" << std::endl;
            return false;
        }
        return true;
    }

    bool send_data(const void* data, size_t length) {
        int bytes_sent = ::send(sockfd, data, length, 0);
        if (bytes_sent < 0) {
            std::cerr << "Send failed" << std::endl;
            return false;
        }
        return true;
    }

    bool recv_data(void* buffer, size_t length) {
        int bytes_received = ::recv(sockfd, buffer, length, 0);
        if (bytes_received < 0) {
            std::cerr << "Receive failed" << std::endl;
            return false;
        }
        return true;
    }

private:
    int sockfd;
};

int main() {
    Socket server_socket;
    if (!server_socket.create()) return -1;
    if (!server_socket.bind("127.0.0.1", 8080)) return -1;
    if (!server_socket.listen()) return -1;

    struct sockaddr_in client_addr;
    socklen_t addrlen = sizeof(client_addr);
    int client_socket = server_socket.accept(&client_addr, &addrlen);
    if (client_socket < 0) return -1;

    const char* message = "Hello, client!";
    if (!server_socket.send_data(message, strlen(message))) return -1;

    char buffer[1024] = {0};
    if (!server_socket.recv_data(buffer, sizeof(buffer))) return -1;
    std::cout << "Received: " << buffer << std::endl;

    close(client_socket);
    return 0;
}