c++网络编程（一）

#c++网络编程（一）
server端代码（把c++网络编程封装）

/***
 * 这是一个tcpserver的客户端
 * 1. 构造函数，传入服务器IP和端口号，初始化socket
 * 2. 析构函数，关闭socket
 * 3. connectToServer函数，连接服务器
 * 4. sendMessage函数，发送消息
 * 5. receiveMessage函数，接收消息
 * 6. main函数，创建TCPClient对象，调用connectToServer函数，发送消息并接收回复
***/
#include <iostream>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>

class TCPServer {
public:
    TCPServer(int port);
    ~TCPServer();
    bool start();
    std::string receiveMessage();
    void sendMessage(const std::string& message);

private:
    int server_fd, new_socket; //文件描述符，Linux用于管理文件的整数（每一个socket会返回一个文件描述符）
    struct sockaddr_in address;
    int addrlen = sizeof(address);
    char buffer[1024] = {0};
};

TCPServer::TCPServer(int port) {
    server_fd = socket(AF_INET, SOCK_STREAM, 0);//AF_INET:IPV4;SOCK_STREAM:TCP
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;//监听所有端口
    address.sin_port = htons(port);//将主机字节序转换为网络字节序（大端法）
}

TCPServer::~TCPServer() {
    close(new_socket);
    close(server_fd);
}

bool TCPServer::start() {
    if (bind(server_fd, (struct sockaddr*)&address, sizeof(address)) < 0) {
        return false;
    }
    if (listen(server_fd, 8) < 0) {
        return false;
    }
    // new_socket = accept(server_fd, (struct sockaddr*)&address, (socklen_t*)&addrlen);
    return true;
}

std::string TCPServer::receiveMessage() {

    new_socket = accept(server_fd,(struct sockaddr*)&address,(socklen_t*)&addrlen);
    if (new_socket < 0) {
        std::cerr << "Accept failed: " << strerror(errno) << std::endl;  // 使用 strerror(errno) 打印具体的错误信息
        return "";
    }
    ssize_t bytesRead = read(new_socket, buffer, 1024);
    if (bytesRead < 0) {
        std::cerr << "Read error: " << strerror(errno) << std::endl;
        return "";
    } else if (bytesRead == 0) {
        //std::cerr << "Client disconnected" << std::endl;
        return "";
    }
    buffer[bytesRead] = '\0';  // 确保字符串以 null 结尾
    return std::string(buffer);
}

void TCPServer::sendMessage(const std::string& message) {
    send(new_socket, message.c_str(), message.size(), 0);
}



int main() {
    TCPServer server(8080);
    if (!server.start()) {
        std::cerr << "Server start failed" << std::endl;
        return -1;
    }
    int cnt = 0;
    while(true){
        std::string message = server.receiveMessage();
        if (message.empty()) {
            //std::cerr << "Waiting for a new client..." << std::endl;
            continue;  // 或者使用 break 跳出循环
        }

        std::cout << "Message received: " << message <<"count:"<<cnt<<std::endl;
        cnt++;
        server.sendMessage("Hello from server");
        std::cout << "Hello message sent" << std::endl;
    }

    return 0;
}

2.client代码

/***
 * 这是一个tcpserver的客户端
 * 1. 构造函数，传入服务器IP和端口号，初始化socket
 * 2. 析构函数，关闭socket
 * 3. connectToServer函数，连接服务器
 * 4. sendMessage函数，发送消息
 * 5. receiveMessage函数，接收消息
 * 6. main函数，创建TCPClient对象，调用connectToServer函数，发送消息并接收回复
***/
#include <iostream>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>

class TCPClient {
public:
    TCPClient(const std::string& serverIP, int serverPort);
    ~TCPClient();
    bool connectToServer();
    void sendMessage(const std::string& message);
    std::string receiveMessage();

private:
    int sock;
    struct sockaddr_in serv_addr;
    char buffer[1024] = {0};
};

TCPClient::TCPClient(const std::string& serverIP, int serverPort) {
    sock = socket(AF_INET, SOCK_STREAM, 0);
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(serverPort);
    inet_pton(AF_INET, serverIP.c_str(), &serv_addr.sin_addr);
}

TCPClient::~TCPClient() {
    close(sock);
}

bool TCPClient::connectToServer() {
    return connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) >= 0;
}

void TCPClient::sendMessage(const std::string& message) {
    send(sock, message.c_str(), message.size(), 0);
}

std::string TCPClient::receiveMessage() {
    read(sock, buffer, 1024);
    return std::string(buffer);
}

int main() {
    TCPClient client("127.0.0.1", 8080);
    if (!client.connectToServer()) {
        std::cerr << "Connection failed" << std::endl;
        return -1;
    }

    client.sendMessage("Hello from client");
    std::cout << "Hello message sent" << std::endl;

    std::string message = client.receiveMessage();
    std::cout << "Message received: " << message << std::endl;

    return 0;
}

3. 实验结果，服务器循环等待顺利接收来自客户端的消息，并计数。
   

#Linux环境下编译，客户端类似
g++ -o server Server.cpp -pthread
./server
g++ -o client Client.cpp -pthread
./client