C++解決回調地獄問題的方法小結

更新時間：2024年07月04日 11:06:15 作者：**K

“地獄回調”（Callback Hell）是指在編程中使用過多嵌套回調函數(shù),導致代碼難以閱讀和維護,本文給大家介紹了C++解決回調地獄問題的方法小結,文中有相關的代碼示例供大家參考,需要的朋友可以參考下

1. 使用 Lambda 表達式和標準庫 std::function

Lambda 表達式可用于簡化回調函數(shù)，使代碼更清晰。

#include <iostream>
#include <functional>
 
void fetchData(const std::function<void(std::string)>& callback) {
    std::string data = "data from fetch";
    callback(data);
}
 
void processData(const std::string& data, const std::function<void(std::string)>& callback) {
    std::string processedData = data + " processed";
    callback(processedData);
}
 
int main() {
    fetchData([](std::string data) {
        std::cout << "Fetched: " << data << std::endl;
        processData(data, [](std::string processedData) {
            std::cout << "Processed: " << processedData << std::endl;
        });
    });
 
    return 0;
}

2. 使用 std::future 和 std::promise

通過使用 std::future 和 std::promise 實現(xiàn)更可讀的異步代碼。

#include <iostream>
#include <future>
#include <thread>
 
std::string fetchData() {
    return "data from fetch";
}
 
std::string processData(const std::string& data) {
    return data + " processed";
}
 
int main() {
    std::promise<std::string> fetchPromise;
    std::future<std::string> fetchFuture = fetchPromise.get_future();
 
    std::thread fetchThread([&fetchPromise]() {
        fetchPromise.set_value(fetchData());
    });
 
    std::thread processThread([](std::future<std::string> fetchFuture) {
        auto fetchedData = fetchFuture.get();
        std::string processedData = processData(fetchedData);
        std::cout << "Processed: " << processedData << std::endl;
    }, std::move(fetchFuture));
 
    fetchThread.join();
    processThread.join();
 
    return 0;
}

3. 使用協(xié)程 (C++20)

C++20 引入了協(xié)程，使得異步操作更加流暢和自然。

#include <iostream>
#include <coroutine>
#include <future>
 
struct Task {
    struct promise_type {
        std::promise<void> promise;
        Task get_return_object() {
            return Task{ promise.get_future() };
        }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() { promise.set_value(); }
        void unhandled_exception() { promise.set_exception(std::current_exception()); }
    };
 
    std::future<void> future;
};
 
Task fetchData(std::string& result) {
    result = "data from fetch";
    co_return;
}
 
Task processData(std::string& result) {
    result += " processed";
    co_return;
}
 
int main() {
    std::string data;
    auto t1 = fetchData(data);
    t1.future.get();
    
    auto t2 = processData(data);
    t2.future.get();
 
    std::cout << "Processed: " << data << std::endl;
    return 0;
}

4. 使用異步框架

異步框架如 Boost.Asio 或 libuv 可以幫助管理異步操作，避免回調地獄。

#include <iostream>
#include <boost/asio.hpp>
 
boost::asio::io_context io;
 
void fetchData(const std::function<void(std::string)>& callback) {
    std::string data = "data from fetch";
    io.post([callback, data]() {
        callback(data);
    });
}
 
void processData(const std::string& data, const std::function<void(std::string)>& callback) {
    std::string processedData = data + " processed";
    io.post([callback, processedData]() {
        callback(processedData);
    });
}
 
int main() {
    fetchData([](std::string data) {
        std::cout << "Fetched: " << data << std::endl;
        processData(data, [](std::string processedData) {
            std::cout << "Processed: " << processedData << std::endl;
        });
    });
 
    io.run();
 
    return 0;
}