[Boost.Leaf]C++11轻量级错误框架

已于 2023-03-09 00:31:31 修改
阅读量378 收藏 1
点赞数 1
分类专栏： c++ Boost文档翻译 文章标签： c++ java jvm
于 2023-03-09 00:29:21 首次发布
原文链接：https://www.boost.org/doc/libs/1_81_0/libs/leaf/doc/html/index.html
版权
Boost.Leaf是一个专为C++11设计的轻量级错误处理库，提供单头文件、无依赖、嵌入式开发友好的解决方案。它支持静态错误处理，效率恒定，不依赖堆栈深度，且能与异常机制结合。库中的关键功能包括result类型、错误传播、try_handle_some和try_handle_all等机制，方便开发者编写高效且易于维护的错误处理代码。
摘要由CSDN通过智能技术生成

摘要

Boost.Leaf是一个给C++11搞的轻量级错误处理库。

  • 单头文件，无依赖
  • 嵌入式开发生成代码小
  • 没有动态内存分配，即使错误信息很大
  • 出没出错效率一样
  • 处理错误时间恒定，与调用堆栈深度无关
  • 可选异常机制

支持

获取

许可证：Boost Software License - Version 1.0
包含于：Boost 1.75
源码：GitHub
单个头文件：leaf.hpp

ℹ️LEAF不依赖Boost和其它库

教程

什么是一个失败呢？。。。

报告错误

enum class err1 { e1, e2, e3 };

leaf::result<T> f()
{
  ....
  if( error_detected )
    return leaf::new_error( err1::e1 ); // 传递任何类型的错误对象

  // 返回T
}

检查错误

leaf::result<U> g()
{
  leaf::result<T> r = f();
  if( !r )
    return r.error();

  T const & v = r.value();
  // 使用v产出U
}

💡r.error()兼容任何类型的leaf::result

if语句可以通过BOOST_LEAF_AUTO简写：

leaf::result<U> g()
{
  BOOST_LEAF_AUTO(v, f()); // Bail out on error

  // 使用v产出U
}

BOOST_LEAF_AUTO不能用于void结果，这种情况下我们使用BOOST_LEAF_CHECK：

leaf::result<void> f();

leaf::result<int> g()
{
  BOOST_LEAF_CHECK(f()); // 发出错误
  return 42;
}

在支持__GNUC__的编译器中，BOOST_LEAF_CHECK可以利用Statement Exprs (Using the GNU Compiler Collection (GCC))的特性，使得非void的结果在表达式中使用：

leaf::result<int> f();

float g(int x);

leaf::result<float> t()
{
  return g( BOOST_LEAF_CHECK(f()) );
}

下面含义相同：

leaf::result<float> t()
{
  BOOST_LEAF_AUTO(x, f());
  return g(x);
}

错误处理

我们需要使用特殊语法来定义要访问的错误对象。我们举例若干方法处理err1错误：

leaf::result<U> r = leaf::try_handle_some(

  []() -> leaf::result<U>
  {
    BOOST_LEAF_AUTO(v1, f1());
    BOOST_LEAF_AUTO(v2, f2());

    return g(v1, v2);
  },

  []( err1 e ) -> leaf::result<U>
  {
    if( e == err1::e1 )
      .... // 处理err1::e1错误
    else
      .... // 处理其他err1错误
  } );

try_handle_some第一个lambda参数首先执行，它试图创建结果U，但它可能会失败。

第二个lambda参数是一个错误处理程序：如果第一个lambda执行失败并且产生err1错误，则它被调用。错误对象被存储在栈上，在try_handle_some函数中（LEAF根据错误处理程序的参数分配存储空间）。传给try_handle_some的错误处理程序可重新返回leaf::result<U>，且允许错误。

错误处理程序也可以指定只接受特定值：

leaf::result<U> r = leaf::try_handle_some(

  []() -> leaf::result<U>
  {
    BOOST_LEAF_AUTO(v1, f1());
    BOOST_LEAF_AUTO(v2, f2());

    return g(v1. v2);
  },

  []( leaf::match<err1, err1::e1, err1::e3> ) -> leaf::result<U>
  {
    // 处理err::e1或err1::e3错误
  },

  []( err1 e ) -> leaf::result<U>
  {
    // 处理其它err1错误
  } );

LEAF依序对比错误处理程序，根据错误对象，调用第一个它可以提供参数的错误处理程序，上面的程序中：

  1. 第一个错误处理程序通过leaf::match指定仅当错误包含err1类型且值为err1::e1或err1::e3时执行
  2. 否则，如果错误包含err1类型，则调用第二个错误处理程序，不论其值如何
  3. 否则leaf::try_handle_some执行失败

错误处理程序也可以选择不处理当前错误：

leaf::result<U> r = leaf::try_handle_some(

  []() -> leaf::result<U>
  {
    BOOST_LEAF_AUTO(v1, f1());
    BOOST_LEAF_AUTO(v2, f2());

    return g(v1. v2);
  },

  []( err1 e, leaf::error_info const & ei ) -> leaf::result<U>
  {
    if( <<condition>> )
      return valid_U;
    else
      return ei.error();
  } );

错误处理程序可以使用一个leaf::error_info const &类型的参数来访问正在处理的错误的常规信息；这种情况下，我们可以使用成员函数error获取当前错误的唯一error_id；我们可以用它来初始化leaf::result以快速地将错误传递到try_handle_some之外。

💡如果我们想发出一个新的错误（而不是传递当前错误），我们可以通过leaf::new_error返回新的错误。

如果我们想确保所有错误都被处理，我们可以使用leaf::try_handle_all：

U r = leaf::try_handle_all(

  []() -> leaf::result<U>
  {
    BOOST_LEAF_AUTO(v1, f1());
    BOOST_LEAF_AUTO(v2, f2());

    return g(v1. v2);
  },

  []( leaf::match<err1, err1::e1> ) -> U
  {
    // 处理err::e1错误
  },

  []( err1 e ) -> U
  {
    // 处理其他err1错误
  },

  []() -> U
  {
    // 处理其它任何错误
  } );

leaf::try_handle_all函数在编译期强制要求提供一个不带参数的错误处理程序（以处理任何错误）。而且，所有错误处理程序都被迫返回有效的U而不是leaf::result<U>，因此leaf::try_handle_all保证成功。

处理不同类型的错误

我们自然可以提供不同的错误处理程序处理不同的错误类型：

enum class err1 { e1, e2, e3 };
enum class err2 { e1, e2 };

....

leaf::result<U> r = leaf::try_handle_some(

  []() -> leaf::result<U>
  {
    BOOST_LEAF_AUTO(v1, f1());
    BOOST_LEAF_AUTO(v2, f2());

    return g(v1, v2);
  },

  []( err1 e ) -> leaf::result<U>
  {
    // 处理err1类型错误
  },

  []( err2 e ) -> leaf::result<U>
  {
    // 处理err2类型错误
  } );

我们仍按序对比错误处理程序：

  1. 如果错误包含err1类型，则执行第一个错误处理程序
  2. 否则，如果错误包含err2类型，则执行第二个错误处理程序
  3. 否则，leaf:try_handle_some失败

处理多个错误对象

leaf::new_error函数可以接受多个错误对象，例如绑定一个文件名：

enum class io_error { open_error, read_error, write_error };

struct e_file_name { std::string value; }

leaf::result<File> open_file( char const * name )
{
  ....
  if( open_failed )
    return leaf::new_error(io_error::open_error, e_file_name {name});
  ....
}

类似地，错误处理程序可以接受多个错误对象作为参数：

leaf::result<U> r = leaf::try_handle_some(

  []() -> leaf::result<U>
  {
    BOOST_LEAF_AUTO(f, open_file(fn));
    ....
  },

  []( io_error ec, e_file_name fn ) -> leaf::result<U>
  {
    // 处理IO错误，并且文件名可用
  },

  []( io_error ec ) -> leaf::result<U>
  {
    // 处理IO错误，文件名不可用
  } );

重复一次，错误处理程序被依次考虑：

  1. 当错误包含io_error并且包含e_file_name对象时，第一个错误处理程序被执行
  2. 否则，当错误包含io_error对象时，第二个错误处理程序被执行
  3. 否则，leaf::try_handle_some失败

还有一种方式是提供一个e_file_name指针类型的参数：

leaf::result<U> r = leaf::try_handle_some(

  []() -> leaf::result<U>
  {
    BOOST_LEAF_AUTO(f, open_file(fn));
    ....
  },

  []( io_error ec, e_file_name const * fn ) -> leaf::result<U>
  {
    if( fn )
      .... // 处理IO错误，并且文件名可用
    else
      .... // 处理IO错误，文件名不可用
  } );

错误处理程序不会因不包含指针类型指向的错误类型的对象而被跳过；此时，LEAF直接传递nullptr。

💡错误处理程序可以接受值、（const）引用或（const）指针类型参数；使用引用或指针时，如果修改错误对象并且不处理错误，则该状态会被保留并向上传播。

增加错误

假如我们有函数parse_line可能出现io_error或parse_error：

enum class io_error { open_error, read_error, write_error };

enum class parse_error { bad_syntax, bad_range };

leaf::result<int> parse_line( FILE * f );

leaf::on_error函数可以自动关联额外的错误对象到当前正在发生的错误：

struct e_line { int value; };

leaf::result<void> process_file( FILE * f )
{
  for( int current_line = 1; current_line != 10; ++current_line )
  {
    auto load = leaf::on_error( e_line {current_line} );

    BOOST_LEAF_AUTO(v, parse_line(f));

    // 使用v
  }
}

process_file不处理错误，除非出现问题时附加current_line， on_error返回的对象包含一份e_line{current_line}的副本，如果parse_line成功，则e_line对象被忽略，如果失败，则e_line对象会被自动附加到错误中。

上面的错误可以这样处理：

leaf::result<void> r = leaf::try_handle_some(

  [&]() -> leaf::result<void>
  {
    BOOST_LEAF_CHECK( process_file(f) );
  },

  []( parse_error e, e_line current_line  )
  {
    std::cerr << "Parse error at line " << current_line.value << std::endl;
  },

  []( io_error e, e_line current_line )
  {
    std::cerr << "I/O error at line " << current_line.value << std::endl;
  },

  []( io_error e )
  {
    std::cerr << "I/O error" << std::endl;
  } );

下面是一样的，不过可能简单些：

leaf::result<void> r = leaf::try_handle_some(

  []() -> leaf::result<void>
  {
    BOOST_LEAF_CHECK( process_file(f) );
  },

  []( parse_error e, e_line current_line )
  {
    std::cerr << "Parse error at line " << current_line.value << std::endl;
  },

  []( io_error e, e_line const * current_line )
  {
    std::cerr << "Parse error";
    if( current_line )
      std::cerr << " at line " << current_line->value;
    std::cerr << std::endl;
  } );

异常处理

抛异常咋办？莫担心try_handle_some和try_handle_all都会捕获异常，并且能够将它们传递给任何兼容的错误处理程序：

leaf::result<void> r = leaf::try_handle_some(

  []() -> leaf::result<void>
  {
    BOOST_LEAF_CHECK( process_file(f) );
  },

  []( std::bad_alloc const & )
  {
    std::cerr << "Out of memory!" << std::endl;
  },

  []( parse_error e, e_line l )
  {
    std::cerr << "Parse error at line " << l.value << std::endl;
  },

  []( io_error e, e_line const * l )
  {
    std::cerr << "Parse error";
    if( l )
      std::cerr << " at line " << l.value;
    std::cerr << std::endl;
  } );

上面的程序中，我们仅仅是添加了一个接受std::bad_alloc参数的错误处理程序，事情好像就如预期那般工作：LEAF会正确分发错误，不论错误来自于leaf::result还是来自于异常。

当然，如果我们显示使用异常处理，我们就不需要leaf::result了，此时我们用leaf::try_catch：

leaf::try_catch(

  []
  {
    process_file(f);
  },

  []( std::bad_alloc const & )
  {
    std::cerr << "Out of memory!" << std::endl;
  },

  []( parse_error e, e_line l )
  {
    std::cerr << "Parse error at line " << l.value << std::endl;
  },

  []( io_error e, e_line const * l )
  {
    std::cerr << "Parse error";
    if( l )
      std::cerr << " at line " << l.value;
    std::cerr << std::endl;
  } );

注意，我们不需要修改错误处理程序！但这是咋工作的呢？process_file抛出了啥？

LEAF使用了一个新的异常处理技术，它不使用异常类型继承关系来对错误进行分类，也不在异常中携带数据。回想一下，我们通过leaf::result传递错误时，我们会调用leaf::new_error函数返回结果，直接传递若干错误对象到当前错误处理范围：

enum class err1 { e1, e2, e3 };
enum class err2 { e1, e2 };

....

leaf::result<T> f()
{
  ....
  if( error_detected )
    return leaf::new_error(err1::e1, err2::e2);

  // 创建并返回T
}

使用异常处理时，我们这样：

enum class err1 { e1, e2, e3 };
enum class err2 { e1, e2 };

T f()
{
  if( error_detected )
    leaf::throw_exception(err1::e1, err2::e2);

  // 创建并返回T
}

leaf::throw_exception函数传递错误就像leaf::new_error一样，然后抛出一个继承自std::exception类型的对象。在这种方式中，错误类型不重要了：leaf::try_catch捕获所有异常，然后使用常规的LEAF错误处理程序选择过程。

如果我们想要使用传统方式抛出一个继承自std::exception的异常，我们可以简单地传递其作为第一个参数到leaf::throw_exception函数：

leaf::throw_exception(std::runtime_error("Error!"), err1::e1, err2::e2);

这种情况下，返回地对象将继承自std::runtime_error而不是std::exception。

并且，leaf::on_error仍旧可以工作。我们使用异常重写了process_file函数：

int parse_line( FILE * f ); // 抛出

struct e_line { int value; };

void process_file( FILE * f )
{
  for( int current_line = 1; current_line != 10; ++current_line )
  {
    auto load = leaf::on_error( e_line {current_line} );
    int v = parse_line(f);

    // 使用v
  }
}

使用外部结果类型

TODO

Binding Error Handlers in a std::tuple

Transporting Error Objects Between Threads

Classification of Failures

Converting Exceptions to result

Using error_monitor to Report Arbitrary Errors from C-callbacks

Diagnostic Information

Working with std::error_code, std::error_condition

…

chudonghao
关注
专栏目录
boost::leaf::capture用法的测试程序
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-08 305
boost::leaf::capture用法的测试程序实现功能C++实现代码 实现功能 boost::leaf::capture用法的测试程序 C++实现代码 #include <boost/leaf.hpp> #include <vector> #include <string> #include <future> #include <iterator> #include <iostream> #include <algorit
boost::leaf::result用法的测试程序
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-08 355
boost::leaf::result用法的测试程序实现功能C++实现代码 实现功能 boost::leaf::result用法的测试程序 C++实现代码 #include <boost/leaf.hpp> #include <iostream> #include <memory> #include <stdio.h> namespace leaf = boost::leaf; enum error_code { bad_command_line =
[C++][Error Code]如何定义Error Code框架 2
08-13
NULL 博文链接：https://jacky-dai.iteye.com/blog/2310318
[C++][Error Code]如何定义Error Code框架
Jacky_Dai的专栏
12-12 1599
对于不同的项目而言，error code返回机制是不一样的，但是能够很好的管理好不同模块间的Error Code并不是一件简单的事情，下面有一种比较简便的方法如下： [code="c++"] /**************************************************************************************************/...
使用boost::leaf模块读取缓冲区中的文件并将其打印到std::cout
CyberByte的博客
08-22 75
对于这个例子，在处理错误时，我们只是把它重新封装到leaf::result中，这样我们就可以在主函数中处理它。本篇文章将讨论如何使用Boost::leaf模块来读取缓冲区中的文件，并将其打印到标准输出stdout。总之，使用Boost::leaf模块读取缓冲区中的文件并将其打印到stdout非常简单。通过使用try_handle_all函数，我们可以更安全地处理可能出现的错误，并实现更好的代码复用和可读性。最后，我们检查返回的leaf::result对象，如果存在错误，则输出错误信息并退出程序。
boost::leaf模块读取缓冲区中的文本文件并将其打印到 std::cout
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-08 308
boost::leaf模块读取缓冲区中的文本文件并将其打印到 std::cout实现功能C++实现代码 实现功能 boost::leaf模块读取缓冲区中的文本文件并将其打印到 std::cout C++实现代码 #include <boost/leaf.hpp> #include <iostream> #include <memory> #include <stdio.h> namespace leaf = boost::leaf; struct bad_co
Boost.Asio C++ Network Programming（高清，带书签，可复制）
01-29
此外，本书可能还会讨论Boost.Asio与C++11及更高版本标准库的融合，如使用std::future和std::async进行异步编程，以及如何利用C++的智能指针来管理资源，提高代码的健壮性和可维护性。 书中的实例代码清晰易懂，有...
Boost.Asio C++ Network Programming.pdf
08-30
Boost.Asio的抽象层次使得程序设计者可以不必直接与底层的套接字编程打交道，从而减少工作量并降低错误发生的机会。 电子书的内容包括了对Boost.Asio的详细介绍、实际编程示例和技巧。这些内容旨在帮助读者掌握...
Boost.Asio C++ Network Programming Cookbook.pdf
09-15
Boost.Asio C++ Network Programming Cookbook.pdf Boost.Asio C++ Network Programming Cookbook.pdf
基于C++11语言的轻量级boost库设计源码
10-09
本项目是一款采用C++11语言编写的轻量级boost库源码，共计227个文件，涵盖C、C++、Lua、Shell等多种编程语言。文件类型丰富，包括98个C/C++源文件、69个头文件、10个shell脚本、8个YAML配置文件等。该库旨在提供简洁...
boost::leaf::try_handle_some的使用示例
持续更新
08-24 51
如果某个函数返回了非零的错误码，我们就抛出这个错误，并在主函数中通过try_handle_some函数捕获这个错误，然后使用一个lambda表达式的形式处理这个异常。在C++编程中，处理异常情况是非常重要的。其中，try_handle_some函数就是一个非常实用的工具，它可以帮助我们在不同的异常处理块中传递错误信息。通过这个示例程序，我们可以看到try_handle_some函数的强大之处。它不仅可以让我们处理异常信息，还可以让我们在不同的异常处理块中传递这些信息，从而让我们更好地调试和优化我们的程序。
boost::leaf::function_traits用法的测试程序
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-08 302
boost::leaf::function_traits用法的测试程序实现功能C++实现代码 实现功能 boost::leaf::function_traits用法的测试程序 C++实现代码 #ifdef BOOST_LEAF_TEST_SINGLE_HEADER # include "leaf.hpp" #else # include <boost/leaf/detail/function_traits.hpp> #endif #include <functional> n
boost::leaf::try_handle_some用法的测试程序
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-08 338
boost::leaf::try_handle_some用法的测试程序实现功能C++实现代码 实现功能 boost::leaf::try_handle_some用法的测试程序 C++实现代码 #include <boost/leaf.hpp> #include <algorithm> #include <ctype.h> #include <string> #include <iostream> namespace leaf = boost::le
C++异常处理库boost::leaf的使用示例
techDM的博客
08-14 173
boost::leaf是一个C++异常处理库，它提供了更加灵活和可定制化的异常处理方式，包含了诊断信息的收集、构建和输出等功能。在这个程序中，我们使用了boost::leaf::error类来捕获异常。这个宏与std::throw_with_nested类似，它可以抛出嵌套异常，并且还能收集和输出诊断信息。在这个程序中，我们调用my_function函数，并捕获可能抛出的异常。boost::leaf提供了更加灵活和可定制化的异常处理方式，适用于复杂的应用场景。接下来，我们定义一个函数，该函数抛出一个异常。
boost::leaf::exception用法的测试程序
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-08 332
boost::leaf::exception用法的测试程序实现功能C++实现代码 实现功能 boost::leaf::exception用法的测试程序 C++实现代码 #include <boost/leaf.hpp> #include <vector> #include <string> #include <future> #include <iterator> #include <iostream> #include <alg
使用boost::leaf::capture的示例程序
2301_79331421的博客
09-08 50
接受一系列的异常处理器，每个处理器对应一种异常类型。函数接受一个可调用对象，并在该对象被调用时捕获可能抛出的异常。在我们的示例中，我们定义了一个。是一对强大的异常处理工具，它们可以帮助我们更好地管理和处理异常，提高代码的健壮性和可维护性。通过定义不同类型的处理器，我们可以对不同类型的异常进行不同的处理操作。是一个用于异常处理的库，它提供了一种简洁的方式来处理和传播异常。函数，它模拟了一个可能会抛出异常的操作。类型的异常时，第一个处理器会被触发，打印出相应的错误信息。的可调用对象中抛出了异常，
Type-C PD诱骗取电快充协议芯片 支持PD 5V、9V、12V、15V、20V电压
最新发布
xcx003的博客
11-02 624
XSP01A是一款专为Type-C接口设计的取电诱骗协议芯片，它它集成了先进的电源管理和协议控制功能，旨在为用户提供高效、安全、稳定的充电体验。该芯片集成USB Power Delivery (PD) 3.0/2.0快充协议，支持从手机充电器/车充等电源上取电给产品供电。支持最大功率100W给设备安全快速供电。综上所述，XSP01A诱骗取电协议芯片以其高效、安全、稳定的充电性能以及广泛的设备兼容性和应用场景，正在逐步改变着我们的充电体验和设备电源管理方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值