C++11服务器资料：新手入门教程

本文介绍了C++11的新特性和服务器编程的基础知识，涵盖了网络编程、TCP/UDP协议、以及使用C++11实现简单服务器的方法。文章还详细讲解了多线程与并发处理，并提供了聊天室服务器和文件传输服务器的实战案例。文中提供了丰富的代码示例和调试技巧，帮助读者更好地理解和使用C++11服务器资料。

C++11基础回顾

C++11新特性简介

C++11是C++编程语言的一个重要版本，它引入了许多新特性，旨在提高代码的可读性和可维护性。以下是C++11的一些主要新特性：

• 自动类型推断 (auto)
  • auto 关键字用于推断变量的类型。
• 范围循环 (for 循环)
  • 新的 for 循环语法简化了遍历容器的操作。
• Lambda 表达式
  • Lambda 表达式提供了一种简洁的方式来定义匿名函数。
• 右值引用和移动语义
  • 改善了资源管理和对象的高效传递。
• 智能指针
  • std::unique_ptr, std::shared_ptr, 和 std::weak_ptr 提供了自动资源管理。
• 初始化列表
  • 改进了类实例的初始化方式。
• 强类型枚举
  • 提供了更安全的枚举类型。
• constexpr 关键字
  • 允许在编译时计算常量表达式。
• 类型别名（typedef 和 using 关键字）
  • 提供了更简洁的类型定义方式。

常用语法介绍

在C++11中，许多新的语法特性使得编写更简洁和高效的代码变得可能。以下是一些常用的语法示例：

// 自动类型推断
auto value = 42; // value 的类型被推断为 int
auto list = std::vector<int>(); // list 的类型被推断为 std::vector<int>

// 范围循环
for (auto& item : list) {
    // 处理 item
}

// Lambda 表达式
std::vector<int> numbers = {1, 2, 3, 4, 5};
auto result = std::find_if(numbers.begin(), numbers.end(), [](int n) {
    return n % 2 == 0;
});

// 智能指针
std::unique_ptr<int> unique_ptr = std::make_unique<int>(10); // 创建一个 std::unique_ptr
std::shared_ptr<int> shared_ptr(new int(20)); // 创建一个 std::shared_ptr

// 强类型枚举
enum class Color {
    Red,
    Green,
    Blue
};

这些语法特性显著简化了代码的编写过程，使得代码更加清晰和易于维护。

服务器编程基础

网络编程基础

服务器编程通常涉及使用网络编程技术。网络编程允许应用程序通过网络与其他应用程序进行通信。C++提供了多种库来支持网络编程，其中最常用的是基于BSD Socket的编程方法。以下是一个简单的TCP服务器程序的代码示例：

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

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

int main() {
    int sockfd = create_tcp_socket();
    if (sockfd < 0) {
        return 1;
    }

    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(8080);

    if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
        std::cerr << "Bind failed" << std::endl;
        close(sockfd);
        return 1;
    }

    if (listen(sockfd, 5) < 0) {
        std::cerr << "Listen failed" << std::endl;
        close(sockfd);
        return 1;
    }

    std::cout << "Server listening on port 8080" << std::endl;
    return 0;
}

TCP/UDP协议简介

TCP (传输控制协议) 和 UDP (用户数据报协议) 是最常用的网络传输协议。它们都是在传输层工作的协议。

• TCP协议
  • 连接导向，提供数据流的可靠传输。
  • 提供重传机制来保证数据的完整性。
  • 使用三次握手来建立连接。
  • 提供流量控制和拥塞控制。
• UDP协议
  • 无连接协议，不保证数据传输的可靠性和顺序。
  • 一次传输一个数据包。
  • 不提供重传机制，传输效率较高。
  • 不需要建立连接，传输速度较快。
  • 常用于实时应用，如在线游戏或视频流。

C++11实现简单服务器

创建一个Socket

服务器程序的核心是创建一个Socket，用于监听和接收客户端的连接请求。以下是如何在C++11中创建一个TCP Socket的例子：

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

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

int main() {
    int sockfd = create_tcp_socket();
    if (sockfd < 0) {
        return 1;
    }

    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(8080);

    if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
        std::cerr << "Bind failed" << std::endl;
        close(sockfd);
        return 1;
    }

    if (listen(sockfd, 5) < 0) {
        std::cerr << "Listen failed" << std::endl;
        close(sockfd);
        return 1;
    }

    std::cout << "Server listening on port 8080" << std::endl;
    return 0;
}

接收和发送数据

在创建Socket并监听连接请求后，服务器需要能够接收客户端的数据，并向客户端发送数据。以下是如何在C++11中实现接收和发送数据的示例：

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

void handle_client(int client_sockfd) {
    char buffer[1024];
    while (1) {
        int bytes_received = recv(client_sockfd, buffer, sizeof(buffer), 0);
        if (bytes_received <= 0) {
            break;
        }
        printf("Received: %s\n", buffer);
        send(client_sockfd, buffer, bytes_received, 0);
    }
    close(client_sockfd);
}

int main() {
    int sockfd = create_tcp_socket();
    if (sockfd < 0) {
        return 1;
    }

    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(8080);

    if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
        std::cerr << "Bind failed" << std::endl;
        close(sockfd);
        return 1;
    }

    if (listen(sockfd, 5) < 0) {
        std::cerr << "Listen failed" << std::endl;
        close(sockfd);
        return 1;
    }

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

    while (1) {
        struct sockaddr_in client_addr;
        socklen_t client_addr_len = sizeof(client_addr);
        int client_sockfd = accept(sockfd, (struct sockaddr*)&client_addr, &client_addr_len);
        if (client_sockfd < 0) {
            std::cerr << "Accept failed" << std::endl;
            continue;
        }
        handle_client(client_sockfd);
    }
    close(sockfd);
    return 0;
}

多线程与并发处理

在处理并发请求时，多线程编程是一个常见的解决方案。C++11提供了强大的多线程支持，可以方便地实现并发处理。

使用C++11的线程库

C++11的线程库使用<thread>头文件，提供了std::thread类来创建和管理线程。以下是如何创建和使用线程的示例：

#include <iostream>
#include <thread>
#include <chrono>

void print_message(const std::string& message) {
    std::cout << "Message from thread: " << message << std::endl;
}

int main() {
    std::thread t1(print_message, "Hello from thread 1");
    std::thread t2(print_message, "Hello from thread 2");

    t1.join();
    t2.join();

    return 0;
}

上述代码创建了两个线程，每个线程执行print_message函数，打印不同的消息。

实现简单的线程池

线程池是一种常见的并发处理模式，它预先创建一组线程，并在需要时分配这些线程来处理任务。以下是一个简单的线程池实现：

#include <iostream>
#include <thread>
#include <vector>
#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>

class SimpleThreadPool {
public:
    SimpleThreadPool(int num_threads) : stop(false) {
        for (int i = 0; i < num_threads; ++i) {
            threads.emplace_back(&SimpleThreadPool::work, this);
        }
    }

    ~SimpleThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread& thread : threads) {
            thread.join();
        }
    }

    void submit(std::function<void()> task) {
        {
            std::lock_guard<std::mutex> lock(queue_mutex);
            tasks.push(task);
        }
        condition.notify_one();
    }

private:
    void work() {
        while (true) {
            std::function<void()> task;
            {
                std::unique_lock<std::mutex> lock(queue_mutex);
                condition.wait(lock, [this] { return stop || !tasks.empty(); });
                if (stop && tasks.empty()) {
                    return;
                }
                task = std::move(tasks.front());
                tasks.pop();
            }
            task();
        }
    }

    std::vector<std::thread> threads;
    std::queue<std::function<void()>> tasks;
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
};

void example_task() {
    std::cout << "Executing example task" << std::endl;
}

int main() {
    SimpleThreadPool pool(4);
    for (int i = 0; i < 10; ++i) {
        pool.submit([] {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            std::cout << "Task completed" << std::endl;
        });
    }
    return 0;
}

上述代码实现了简单的线程池，每次提交任务时，线程池会从任务队列中取出一个任务并执行。线程池中的线程数量在创建时指定，线程池在销毁时会等待所有任务完成并退出所有线程。

错误处理与调试

常见错误及解决方法

在网络编程和多线程编程中，常见的错误包括网络连接错误、线程同步错误等。以下是一些常见的错误及解决方法：

• 网络连接错误

  • 确保网络连接正确配置。
  • 检查IP地址和端口号是否正确。
  • 使用errno或WSAGetLastError()函数获取错误代码。
  • 例如，当创建Socket失败时，可以检查errno来获取具体的错误信息。

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

• 线程同步错误

  • 使用互斥锁 (std::mutex) 和条件变量 (std::condition_variable) 来确保线程之间的同步。
  • 避免死锁，确保锁的顺序一致。
  • 例如，确保在锁的范围内执行所有可能影响共享资源的操作。

  • std::unique_lock<std::mutex> lock(mutex);
    // 执行需要同步的操作
    lock.unlock();

• 资源泄漏
  • 确保在程序退出前释放所有资源。
  • 使用智能指针 (std::unique_ptr, std::shared_ptr) 来自动管理资源。
  • 例如，使用智能指针管理文件描述符。

  • std::unique_ptr<FILE, decltype(&fclose)> file(fopen("example.txt", "r"), fclose);

调试技巧

调试是查找和修复代码中错误的过程，以下是一些调试技巧：

• 使用断点
  • 在代码中设置断点，并逐步执行代码，检查变量的值。
• 日志记录
  • 在关键位置记录调试信息，检查程序的运行状态。

  • std::cout << "Value of x: " << x << std::endl;

• 单元测试
  • 使用单元测试框架（如Google Test）编写测试用例，确保代码的正确性。
• 使用调试工具
  • 使用gdb等调试工具进行深度调试，分析程序的执行流程。

实战案例分析

简单聊天室服务器

聊天室服务器是一个简单的多客户端聊天系统，客户端之间可以互相发送消息。以下是实现简单聊天室服务器的示例代码：

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <vector>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string>

void handle_client(int client_sockfd, std::mutex& mutex, std::condition_variable& cv, std::vector<std::string>& clients) {
    char buffer[1024];
    std::unique_lock<std::mutex> lock(mutex);
    clients.push_back("New client connected");
    cv.notify_all();
    lock.unlock();

    while (1) {
        int bytes_received = recv(client_sockfd, buffer, sizeof(buffer), 0);
        if (bytes_received <= 0) {
            std::unique_lock<std::mutex> lock(mutex);
            clients.erase(std::remove(clients.begin(), clients.end(), "New client connected"), clients.end());
            cv.notify_all();
            lock.unlock();
            break;
        }
        buffer[bytes_received] = '\0';
        printf("Received: %s\n", buffer);
        lock.lock();
        for (const std::string& client : clients) {
            send(client_sockfd, client.c_str(), client.size() + 1, 0);
        }
        lock.unlock();
    }
    close(client_sockfd);
}

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

    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(8080);

    if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
        std::cerr << "Bind failed" << std::endl;
        close(sockfd);
        return 1;
    }

    if (listen(sockfd, 5) < 0) {
        std::cerr << "Listen failed" << std::endl;
        close(sockfd);
        return 1;
    }

    std::vector<std::string> clients;
    std::mutex mutex;
    std::condition_variable cv;
    std::cout << "Server listening on port 8080" << std::endl;

    while (1) {
        struct sockaddr_in client_addr;
        socklen_t client_addr_len = sizeof(client_addr);
        int client_sockfd = accept(sockfd, (struct sockaddr*)&client_addr, &client_addr_len);
        if (client_sockfd < 0) {
            std::cerr << "Accept failed" << std::endl;
            continue;
        }
        std::thread t(handle_client, client_sockfd, std::ref(mutex), std::ref(cv), std::ref(clients));
        t.detach();
    }
    close(sockfd);
    return 0;
}

上述代码实现了一个简单的聊天室服务器，它可以接收多个客户端的连接，并将客户端发送的消息广播给所有连接的客户端。

文件传输服务器

文件传输服务器允许客户端上传和下载文件。以下是如何实现文件传输服务器的示例：

#include <iostream>
#include <fstream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <vector>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string>

void handle_client(int client_sockfd, std::mutex& mutex, std::condition_variable& cv) {
    char buffer[1024];
    while (1) {
        int bytes_received = recv(client_sockfd, buffer, sizeof(buffer), 0);
        if (bytes_received <= 0) {
            break;
        }
        buffer[bytes_received] = '\0';
        std::string filename(buffer);
        std::ofstream file(filename);
        if (file.is_open()) {
            while (bytes_received > 0) {
                bytes_received = recv(client_sockfd, buffer, sizeof(buffer), 0);
                if (bytes_received > 0) {
                    file.write(buffer, bytes_received);
                }
            }
            file.close();
            std::cout << "File received: " << filename << std::endl;
        } else {
            std::cerr << "Failed to open file: " << filename << std::endl;
        }
    }
    close(client_sockfd);
}

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

    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(8080);

    if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
        std::cerr << "Bind failed" << std::endl;
        close(sockfd);
        return 1;
    }

    if (listen(sockfd, 5) < 0) {
        std::cerr << "Listen failed" << std::endl;
        close(sockfd);
        return 1;
    }

    std::mutex mutex;
    std::condition_variable cv;
    std::cout << "Server listening on port 8080" << std::endl;

    while (1) {
        struct sockaddr_in client_addr;
        socklen_t client_addr_len = sizeof(client_addr);
        int client_sockfd = accept(sockfd, (struct sockaddr*)&client_addr, &client_addr_len);
        if (client_sockfd < 0) {
            std::cerr << "Accept failed" << std::endl;
            continue;
        }
        std::thread t(handle_client, client_sockfd, std::ref(mutex), std::ref(cv));
        t.detach();
    }
    close(sockfd);
    return 0;
}

客户端上传文件的代码示例：

#include <iostream>
#include <fstream>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string>

void upload_file(const std::string& filename, const std::string& server_ip, int server_port) {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        std::cerr << "Failed to create socket" << std::endl;
        return;
    }

    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = inet_addr(server_ip.c_str());
    serv_addr.sin_port = htons(server_port);

    if (connect(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
        std::cerr << "Failed to connect to server" << std::endl;
        close(sockfd);
        return;
    }

    std::ifstream file(filename, std::ios::binary);
    if (!file.is_open()) {
        std::cerr << "Failed to open file: " << filename << std::endl;
        close(sockfd);
        return;
    }

    file.seekg(0, std::ios::end);
    std::streampos file_size = file.tellg();
    file.seekg(0, std::ios::beg);

    std::cout << "Uploading file: " << filename << std::endl;

    std::string filename_buffer = filename;
    send(sockfd, filename_buffer.c_str(), filename_buffer.size() + 1, 0);

    char buffer[1024];
    while (file.read(buffer, sizeof(buffer))) {
        send(sockfd, buffer, sizeof(buffer), 0);
    }
    send(sockfd, buffer, file.gcount(), 0);

    file.close();
    close(sockfd);
    std::cout << "File uploaded successfully" << std::endl;
}

int main() {
    upload_file("example.txt", "127.0.0.1", 8080);
    return 0;
}

上述代码实现了一个简单的文件传输服务器，它可以接收客户端发送的文件，并将其保存到服务器端。客户端可以上传文件，服务器端接收到文件后会将其保存到指定的目录。