基于C++怎么编写一个简单的服务器

发布时间：2023-03-14 16:01:09 作者：iii
来源：亿速云阅读：169

基于C++怎么编写一个简单的服务器

引言

在当今互联网时代，服务器是网络应用的核心组件之一。无论是Web服务器、游戏服务器还是即时通讯服务器，它们都承担着处理客户端请求、管理数据交换的重要任务。C++作为一种高效、灵活的编程语言，广泛应用于服务器开发领域。本文将详细介绍如何使用C++编写一个简单的服务器，涵盖从基础概念到实际代码实现的各个方面。

C++网络编程基础

2.1 套接字(Socket)

套接字（Socket）是网络编程的基础，它允许不同主机之间的进程进行通信。套接字可以看作是网络通信的端点，通过它，服务器和客户端可以发送和接收数据。

在C++中，套接字编程通常使用<sys/socket.h>头文件中定义的函数和结构体。常见的套接字类型包括：

流套接字（SOCK_STREAM）：提供面向连接的、可靠的数据传输服务，通常用于TCP协议。
数据报套接字（SOCK_DGRAM）：提供无连接的、不可靠的数据传输服务，通常用于UDP协议。

2.2 TCP/IP协议

TCP/IP协议是互联网通信的基础协议栈，它由多个协议层组成，包括：

应用层：负责处理特定的应用程序细节，如HTTP、FTP等。
传输层：提供端到端的通信服务，如TCP和UDP。
网络层：负责数据包的路由和转发，如IP协议。
链路层：负责物理网络的数据传输，如以太网。

在本文中，我们将主要关注传输层的TCP协议，因为它提供了可靠的、面向连接的数据传输服务。

2.3 网络字节序

在网络通信中，数据通常以字节流的形式传输。由于不同计算机的字节序（大端序或小端序）可能不同，因此在发送和接收数据时需要进行字节序的转换。

C++提供了以下函数来处理字节序转换：

htonl()：将32位整数从主机字节序转换为网络字节序。
htons()：将16位整数从主机字节序转换为网络字节序。
ntohl()：将32位整数从网络字节序转换为主机字节序。
ntohs()：将16位整数从网络字节序转换为主机字节序。

编写一个简单的C++服务器

3.1 创建套接字

在C++中，创建套接字使用socket()函数。该函数的原型如下：

int socket(int domain, int type, int protocol);

domain：指定通信域，如AF_INET表示IPv4协议。
type：指定套接字类型，如SOCK_STREAM表示流套接字。
protocol：指定协议类型，通常为0，表示使用默认协议。

示例代码：

int server_socket = socket(AF_INET, SOCK_STREAM, 0);
if (server_socket == -1) {
    std::cerr << "Failed to create socket" << std::endl;
    return -1;
}

3.2 绑定套接字

创建套接字后，需要将其绑定到一个本地地址和端口上。这通过bind()函数实现。该函数的原型如下：

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

sockfd：套接字描述符。
addr：指向sockaddr结构的指针，包含地址和端口信息。
addrlen：sockaddr结构的大小。

示例代码：

struct sockaddr_in server_addr;
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(8080); // 绑定到8080端口
server_addr.sin_addr.s_addr = INADDR_ANY; // 绑定到所有可用接口

if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
    std::cerr << "Failed to bind socket" << std::endl;
    close(server_socket);
    return -1;
}

3.3 监听连接

绑定套接字后，服务器需要开始监听来自客户端的连接请求。这通过listen()函数实现。该函数的原型如下：

int listen(int sockfd, int backlog);

sockfd：套接字描述符。
backlog：等待连接队列的最大长度。

示例代码：

if (listen(server_socket, 5) == -1) {
    std::cerr << "Failed to listen on socket" << std::endl;
    close(server_socket);
    return -1;
}

3.4 接受连接

当客户端发起连接请求时，服务器需要接受连接并创建一个新的套接字来处理该连接。这通过accept()函数实现。该函数的原型如下：

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

sockfd：监听套接字描述符。
addr：指向sockaddr结构的指针，用于存储客户端地址信息。
addrlen：指向sockaddr结构大小的指针。

示例代码：

struct sockaddr_in client_addr;
socklen_t client_addrlen = sizeof(client_addr);
int client_socket = accept(server_socket, (struct sockaddr*)&client_addr, &client_addrlen);
if (client_socket == -1) {
    std::cerr << "Failed to accept connection" << std::endl;
    close(server_socket);
    return -1;
}

3.5 处理客户端请求

接受连接后，服务器可以通过recv()和send()函数与客户端进行数据交换。recv()函数用于接收数据，send()函数用于发送数据。

示例代码：

char buffer[1024];
int bytes_received = recv(client_socket, buffer, sizeof(buffer), 0);
if (bytes_received == -1) {
    std::cerr << "Failed to receive data" << std::endl;
    close(client_socket);
    close(server_socket);
    return -1;
}

std::string response = "Hello, client!";
if (send(client_socket, response.c_str(), response.size(), 0) == -1) {
    std::cerr << "Failed to send data" << std::endl;
    close(client_socket);
    close(server_socket);
    return -1;
}

3.6 关闭连接

处理完客户端请求后，服务器需要关闭连接以释放资源。这通过close()函数实现。

示例代码：

close(client_socket);
close(server_socket);

完整代码示例

以下是一个完整的C++服务器示例代码：

#include <iostream>
#include <cstring>
#include <unistd.h>
#include <arpa/inet.h>

int main() {
    // 创建套接字
    int server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket == -1) {
        std::cerr << "Failed to create socket" << std::endl;
        return -1;
    }

    // 绑定套接字
    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080);
    server_addr.sin_addr.s_addr = INADDR_ANY;

    if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        std::cerr << "Failed to bind socket" << std::endl;
        close(server_socket);
        return -1;
    }

    // 监听连接
    if (listen(server_socket, 5) == -1) {
        std::cerr << "Failed to listen on socket" << std::endl;
        close(server_socket);
        return -1;
    }

    std::cout << "Server is listening on port 8080..." << std::endl;

    // 接受连接
    struct sockaddr_in client_addr;
    socklen_t client_addrlen = sizeof(client_addr);
    int client_socket = accept(server_socket, (struct sockaddr*)&client_addr, &client_addrlen);
    if (client_socket == -1) {
        std::cerr << "Failed to accept connection" << std::endl;
        close(server_socket);
        return -1;
    }

    std::cout << "Client connected" << std::endl;

    // 处理客户端请求
    char buffer[1024];
    int bytes_received = recv(client_socket, buffer, sizeof(buffer), 0);
    if (bytes_received == -1) {
        std::cerr << "Failed to receive data" << std::endl;
        close(client_socket);
        close(server_socket);
        return -1;
    }

    std::string response = "Hello, client!";
    if (send(client_socket, response.c_str(), response.size(), 0) == -1) {
        std::cerr << "Failed to send data" << std::endl;
        close(client_socket);
        close(server_socket);
        return -1;
    }

    // 关闭连接
    close(client_socket);
    close(server_socket);

    return 0;
}

服务器优化与扩展

5.1 多线程处理

在实际应用中，服务器通常需要同时处理多个客户端连接。为此，可以使用多线程技术，为每个客户端连接创建一个独立的线程。

示例代码：

#include <thread>

void handle_client(int client_socket) {
    char buffer[1024];
    int bytes_received = recv(client_socket, buffer, sizeof(buffer), 0);
    if (bytes_received == -1) {
        std::cerr << "Failed to receive data" << std::endl;
        close(client_socket);
        return;
    }

    std::string response = "Hello, client!";
    if (send(client_socket, response.c_str(), response.size(), 0) == -1) {
        std::cerr << "Failed to send data" << std::endl;
        close(client_socket);
        return;
    }

    close(client_socket);
}

int main() {
    // 创建套接字
    int server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket == -1) {
        std::cerr << "Failed to create socket" << std::endl;
        return -1;
    }

    // 绑定套接字
    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080);
    server_addr.sin_addr.s_addr = INADDR_ANY;

    if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        std::cerr << "Failed to bind socket" << std::endl;
        close(server_socket);
        return -1;
    }

    // 监听连接
    if (listen(server_socket, 5) == -1) {
        std::cerr << "Failed to listen on socket" << std::endl;
        close(server_socket);
        return -1;
    }

    std::cout << "Server is listening on port 8080..." << std::endl;

    while (true) {
        // 接受连接
        struct sockaddr_in client_addr;
        socklen_t client_addrlen = sizeof(client_addr);
        int client_socket = accept(server_socket, (struct sockaddr*)&client_addr, &client_addrlen);
        if (client_socket == -1) {
            std::cerr << "Failed to accept connection" << std::endl;
            continue;
        }

        std::cout << "Client connected" << std::endl;

        // 创建线程处理客户端请求
        std::thread client_thread(handle_client, client_socket);
        client_thread.detach();
    }

    close(server_socket);

    return 0;
}

5.2 非阻塞I/O

在某些情况下，服务器需要处理大量的并发连接，此时使用多线程可能会导致资源消耗过大。非阻塞I/O是一种解决方案，它允许服务器在单个线程中处理多个连接。

示例代码：

#include <fcntl.h>

void set_nonblocking(int sockfd) {
    int flags = fcntl(sockfd, F_GETFL, 0);
    fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);
}

int main() {
    // 创建套接字
    int server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket == -1) {
        std::cerr << "Failed to create socket" << std::endl;
        return -1;
    }

    // 绑定套接字
    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080);
    server_addr.sin_addr.s_addr = INADDR_ANY;

    if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        std::cerr << "Failed to bind socket" << std::endl;
        close(server_socket);
        return -1;
    }

    // 监听连接
    if (listen(server_socket, 5) == -1) {
        std::cerr << "Failed to listen on socket" << std::endl;
        close(server_socket);
        return -1;
    }

    std::cout << "Server is listening on port 8080..." << std::endl;

    // 设置服务器套接字为非阻塞模式
    set_nonblocking(server_socket);

    while (true) {
        // 接受连接
        struct sockaddr_in client_addr;
        socklen_t client_addrlen = sizeof(client_addr);
        int client_socket = accept(server_socket, (struct sockaddr*)&client_addr, &client_addrlen);
        if (client_socket == -1) {
            if (errno == EWOULDBLOCK || errno == EAGN) {
                // 没有新的连接，继续循环
                continue;
            } else {
                std::cerr << "Failed to accept connection" << std::endl;
                continue;
            }
        }

        std::cout << "Client connected" << std::endl;

        // 设置客户端套接字为非阻塞模式
        set_nonblocking(client_socket);

        // 处理客户端请求
        char buffer[1024];
        while (true) {
            int bytes_received = recv(client_socket, buffer, sizeof(buffer), 0);
            if (bytes_received == -1) {
                if (errno == EWOULDBLOCK || errno == EAGN) {
                    // 没有数据可读，继续循环
                    continue;
                } else {
                    std::cerr << "Failed to receive data" << std::endl;
                    break;
                }
            } else if (bytes_received == 0) {
                // 客户端关闭连接
                break;
            }

            std::string response = "Hello, client!";
            if (send(client_socket, response.c_str(), response.size(), 0) == -1) {
                std::cerr << "Failed to send data" << std::endl;
                break;
            }
        }

        close(client_socket);
    }

    close(server_socket);

    return 0;
}

5.3 使用第三方库

为了简化服务器开发，可以使用一些成熟的第三方库，如Boost.Asio、libevent等。这些库提供了更高层次的抽象，使得开发者可以更专注于业务逻辑的实现。

以Boost.Asio为例，以下是一个简单的服务器实现：

”`cpp #include #include

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

void handle_client(tcp::socket& socket) { char buffer[1024]; boost::system::error_code error; size_t length = socket.read_some(boost::asio::buffer(buffer), error); if (error) { std::cerr << “Failed to receive data: ” << error.message() << std::endl; return; }

std::string response = "Hello, client!";
boost::asio::write(socket, boost::asio::buffer(response), error);
if (error) {
    std::cerr << "Failed to send data: " << error.message() << std::endl;
    return;
}

}

int main() { try { boost::asio::io_context io_context;

    tcp::acceptor acceptor(io_context, tcp::endpoint(tcp::v4(), 8080));
    std::cout << "Server is listening on port 8080..." << std::endl;

    while (true) {
        tcp::socket socket(io_context);
        acceptor.accept(socket);

        std::cout << "Client connected" << std::endl;

        handle_client(socket);
    }
} catch (std::exception& e) {
    std::cerr << "Exception: " << e

基于C++怎么编写一个简单的服务器

基于C++怎么编写一个简单的服务器

目录

引言

C++网络编程基础

2.1 套接字(Socket)

2.2 TCP/IP协议

2.3 网络字节序

编写一个简单的C++服务器

3.1 创建套接字

3.2 绑定套接字

3.3 监听连接

3.4 接受连接

3.5 处理客户端请求

3.6 关闭连接

完整代码示例

服务器优化与扩展

5.1 多线程处理

5.2 非阻塞I/O

5.3 使用第三方库

相关阅读