脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → C 语言 → C++ Promise

基于C++11手撸前端Promise及应用与优势

 更新时间：2025年10月23日 10:39:17   作者：郝学胜-神的一滴  
本文将从一个手写的 C++ Promise实现（基于 C++11）出发,分析其工作原理,并与 std::promise 进行对比,探讨两者的异同点以及适用场景,感兴趣的朋友跟随小编一起看看吧

引言

在前端开发中，Promise 是处理异步操作的重要工具。它通过将异步操作封装在 Promise 实例中，解决了传统回调地狱的问题，提高了代码的可读性和可维护性。Promise 的概念并非前端独有，在 C++11 标准中也引入了 std::promise，用于实现类似的功能。

本文将从一个手写的 C++ Promise 实现（基于 C++11）出发，分析其工作原理，并与 std::promise 进行对比，探讨两者的异同点以及适用场景。

前端Promise的应用与优势

常见应用场景

网络请求
Promise 可以用于处理 AJAX 请求，简化异步数据获取的逻辑。

fetch('https://api.example.com/data')
  .then(response => response.json())
  .then(data => {
    console.log('获取到数据:', data);
  })
  .catch(error => {
    console.error('请求失败:', error);
  });

定时器
Promise 还可以用于处理定时器，使代码更加直观。

function timeout(ms) {
  return new Promise((resolve) => {
    setTimeout(resolve, ms);
  });
}
timeout(1000)
  .then(() => {
    console.log('1秒后执行');
  });

并发请求

使用 Promise.all 可以同时处理多个异步请求。

const promise1 = fetch('https://api.example.com/data1');
const promise2 = fetch('https://api.example.com/data2');
Promise.all([promise1, promise2])
  .then(responses => {
    const [data1, data2] = responses.map(response => response.json());
    return Promise.all([data1, data2]);
  })
  .then(([data1, data2]) => {
    console.log('两个数据都获取成功:', data1, data2);
  })
  .catch(error => {
    console.error('至少一个请求失败:', error);
  });

Promise 解决的问题

  1. 回调地狱：通过链式调用，Promise 解决了传统回调嵌套导致的代码难以阅读和维护的问题【6†source】。
  2. 错误处理：Promise 提供了统一的错误处理机制，通过 catch 方法可以集中处理所有异步操作中的错误【1†source】。
  3. 代码可读性：Promise 使得异步代码的逻辑更加清晰，符合同步代码的书写习惯【6†source】。
  4. 并发控制：通过 Promise.all 和 Promise.race，可以方便地控制多个异步操作的执行顺序和结果【5†source】。

手写 C++ Promise 实现

类结构与成员变量

template<typename Element>
class CProimse 
{
private:
    using Resolve = std::function<void(Element)>;
    using Reject = std::function<void(const std::string&)>;
private:
    Element m_element;      /**< 异步操作的结果 */
    std::string m_reason;   /**< 拒绝的原因 */
    CProimseState m_state;  /**< 当前状态 */
    std::list<Resolve> m_resolves; /**< 成功回调函数列表 */
    std::list<Reject> m_rejects;   /**< 失败回调函数列表 */
public:
    CProimse();
    void reject(const std::string& reason);
    void resolve(Element element); 
    void onCatch(const Reject& rej);
    CProimse* then(const Resolve& res);
};
  • Resolve 和 Reject ：定义了成功和失败回调函数的类型。
  • m_element 和 m_reason ：分别存储 Promise 的结果和拒绝原因。
  • m_state ：表示 Promise 的当前状态，初始状态为 PENDING。
  • m_resolves 和 m_rejects ：存储注册的成功和失败回调函数列表。

构造函数

CProimse()
    : m_state(CProimseState::PENDING)
{
}
  • 作用：初始化 Promise 的状态为 PENDING。

resolve 方法

void resolve(Element element) 
{
    m_element = element;
    if (m_state == CProimseState::PENDING)
    {
        m_state = CProimseState::FULFILLED;
        for (Resolve res : m_resolves)
        {
            res(element);
        }
    }
}
  • 作用：将 Promise 的状态设置为 FULFILLED，并执行所有注册的成功回调函数。

reject 方法

void reject(const std::string& reason)
{
    m_reason = reason;
    if (m_state == CProimseState::PENDING)
    {
        m_state = CProimseState::REJECTED;
        for (Reject rej : m_rejects)
        {
            rej(reason);
        }
    }
}
  • 作用：将 Promise 的状态设置为 REJECTED，并执行所有注册的失败回调函数。

then 方法

CProimse* then(const Resolve& res)
{
    if (m_state == CProimseState::FULFILLED)
    {
        res(m_element);
    }
    else if (m_state == CProimseState::PENDING)
    {
        m_resolves.push_back(res);
    }
    return this;
}
  • 作用：注册一个成功回调函数。如果 Promise 已经完成，则立即执行回调；否则，将回调添加到成功回调列表中。

onCatch 方法

void onCatch(const Reject& rej)
{
    if (m_state == CProimseState::REJECTED)
    {
        rej(m_reason);
    }
    else if (m_state == CProimseState::PENDING)
    {
        m_rejects.push_back(rej);
    }
}
  • 作用：注册一个失败回调函数。如果 Promise 已经被拒绝，则立即执行回调；否则，将回调添加到失败回调列表中。

链式调用

通过 then 和 onCatch 方法，可以实现链式调用，使得异步操作的处理更加简洁和直观。

proimse->then([](int ele) -> void { 
    std::cout << ele << std::endl; 
})->onCatch([](const std::string& reason) -> void {
    std::cout << reason << std::endl;
});

使用示例

CProimse<int>* proimse = new CProimse<int>();
proimse->then([](int ele) -> void { 
    std::cout << ele << std::endl; 
})->onCatch([](const std::string& reason) -> void {
    std::cout << reason << std::endl;
});
proimse->reject("网络异常!!!");

std::promise与CProimse对比

1. 基础功能对比

功能CProimse 实现std::promise
状态管理手动实现标准库实现
回调注册与执行手动实现标准库实现
异步支持需结合线程内置支持
链式调用支持不支持

2. 实现细节对比

(1) 状态管理

  • CProimse ：通过自定义枚举 CProimseState 管理状态。
  • std::promise ：状态管理由标准库实现，用户无需关注底层细节。

(2) 回调注册与执行

  • CProimse ：手动维护回调队列，通过 then 和 onCatch 方法注册回调。
  • std::promise ：通过 std::future 与 std::promise 配合，回调通过 future 的 get 方法触发。

(3) 异步支持

  • CProimse ：需要结合 std::thread 或其他异步框架实现异步操作。
  • std::promise ：内置支持异步操作，通常与 std::async 或 std::thread 结合使用。

(4) 链式调用

  • CProimse ：支持链式调用，通过返回 this 实现。
  • std::promise ：不支持链式调用，无法直接链式注册回调。

3. 代码示例对比

(1)CProimse示例

CProimse<int>* proimse = new CProimse<int>();
proimse->then([](int ele) -> void { 
    std::cout << ele << std::endl; 
})->onCatch([](const std::string& reason) -> void {
    std::cout << reason << std::endl;
});
proimse->reject("网络异常!!!");

(2)std::promise示例

#include <future>
#include <thread>
#include <iostream>
int main()
{
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();
    // 异步操作
    std::thread([&prom]() {
        // 模拟网络请求
        std::this_thread::sleep_for(std::chrono::seconds(1));
        prom.set_value(42);
    }).detach();
    // 注册回调
    fut.then([](std::future<int> fut) {
        try {
            int result = fut.get();
            std::cout << "结果: " << result << std::endl;
        } catch (const std::exception& e) {
            std::cout << "错误: " << e.what() << std::endl;
        }
    });
    // 主线程阻塞等待
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return 0;
}

4. 优缺点分析

(1)CProimse

  • 优点：
    • 代码简洁，易于理解。
    • 支持链式调用，使用方式类似前端 Promise。
    • 可以作为学习 Promise 实现原理的示例。
  • 缺点：
    • 不支持内置异步操作，需要结合线程实现。
    • 功能较为基础，缺乏 std::promise 的高级特性（如 then 的链式返回）。

(2)std::promise

  • 优点：
    • 内置异步支持，与 std::future 配合使用，功能强大。
    • 标准库实现，性能优化和稳定性有保障。
    • 支持 C++11 及以上标准，兼容性好。
  • 缺点：
    • 使用方式较为复杂，缺乏链式调用的支持。
    • 回调机制不够灵活，无法像前端 Promise 那样优雅地处理异步流程。

总结与展望

通过手写 CProimse，我们可以深入理解 Promise 的实现原理，包括状态管理、回调注册与执行等核心机制。然而，在实际开发中，std::promise 仍然是更好的选择，因为它提供了更强大的功能和更好的性能保障。

对于开发者来说，理解 std::promise 的工作原理以及其与手写实现的异同点，有助于更好地选择合适的工具来处理异步操作。同时，手写实现虽然功能有限，但作为学习和探索的工具，仍然具有重要的价值。

希望本文能够帮助读者更好地理解 Promise 的实现原理，并在实际开发中做出更明智的选择。

到此这篇关于基于C++11手撸前端Promise及应用与优势的文章就介绍到这了,更多相关C++ Promise内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • C++动态规划之最长公子序列实例

    C++动态规划之最长公子序列实例

    这篇文章主要介绍了C++动态规划之最长公子序列,实例分析了C++求最长公子序列的相关技巧,是C++字符串操作的一个典型应用,需要的朋友可以参考下
    2015-04-04
  • 简易Dota改键程序制作

    简易Dota改键程序制作

    利用全局钩子制作一个个性化的dota游戏改键功能，大家可以参考使用
    2013-11-11
  • C++中vector类的一些简单实现

    C++中vector类的一些简单实现

    C++中的std::vector是一个动态数组（也被称为可变大小数组）的容器类,它是C++标准库提供的其中一种容器类,提供了方便的操作和管理动态数组的功能,本文就给大家介绍了C++中vector类的简单实现代码,需要的朋友可以参考下
    2023-08-08
  • OpenGL实现边缘填充算法

    OpenGL实现边缘填充算法

    这篇文章主要为大家详细介绍了OpenGL实现边缘填充算法，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2020-02-02
  • 详解dll动态库的开发与调用及文件的读写小程序

    详解dll动态库的开发与调用及文件的读写小程序

    这篇文章主要介绍了详解dll动态库的开发与调用及文件的读写小程序的相关资料,希望通过本文能帮助到大家，需要的朋友可以参考下
    2017-09-09
  • C++利用链表实现图书信息管理系统

    C++利用链表实现图书信息管理系统

    这篇文章主要为大家详细介绍了C++利用链表实现图书信息管理系统，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2021-11-11
  • C++类与对象深入之静态成员与友元及内部类详解

    C++类与对象深入之静态成员与友元及内部类详解

    朋友们好,这篇播客我们继续C++的初阶学习，现在对我们对C++的静态成员，友元，内部类知识点做出总结，整理出来一篇博客供我们一起复习和学习,如果文章中有理解不当的地方,还希望朋友们在评论区指出,我们相互学习,共同进步
    2022-06-06
  • C++实现递归函数的方法

    C++实现递归函数的方法

    在本篇内容里小编给大家分享了关于C++实现递归函数的教学步骤，需要的朋友跟着参考下。
    2018-12-12
  • VSCode保存代码自动格式化无效的解决方法

    VSCode保存代码自动格式化无效的解决方法

    最近一直使用vscode,VSCode中各种配置后,自动保存格式化仍然无效,本文就来介绍一下解决方法,感兴趣的可以了解一下
    2023-08-08
  • c语言链表操作示例分享

    c语言链表操作示例分享

    这篇文章主要介绍了c语言链表操作示例，代码中有注释,需要的朋友可以参考下
    2014-03-03

最新评论