C++学习 boost::apply_visitor说明

最新推荐文章于 2025-06-05 10:28:20 发布
最新推荐文章于 2025-06-05 10:28:20 发布
阅读量9.7k 收藏 1
点赞数
分类专栏： C++学习

函数 apply_visitor

boost::apply_visitor —

将给定的访问者应用到给定的 variant 的内容上，该过程在编译期进行类型安全检查，以确认所有类型均被访问者所处理。

摘要

template<typename Visitor, typename Variant> 
  typename Visitor::result_type 
  apply_visitor(Visitor & visitor, Variant & operand);
template<typename Visitor, typename Variant> 
  typename Visitor::result_type 
  apply_visitor(const Visitor & visitor, Variant & operand);
template<typename BinaryVisitor, typename Variant1, typename Variant2> 
  typename BinaryVisitor::result_type 
  apply_visitor(BinaryVisitor & visitor, Variant1 & operand1, 
                Variant2 & operand2);
template<typename BinaryVisitor, typename Variant1, typename Variant2> 
  typename BinaryVisitor::result_type 
  apply_visitor(const BinaryVisitor & visitor, Variant1 & operand1, 
                Variant2 & operand2);
template<typename Visitor> 
  apply_visitor_delayed_t<Visitor> apply_visitor(Visitor & visitor);

说明

apply_visitor 的行为取决于它所操作的参数的数量(即除访问者以外的其它参数)。该函数的行为如下：

  • 接受一个操作数的重载将以给定的 variant 操作数的内容调用给定的访问者的单参函数调用操作符。
  • 接受两个操作数的重载将以给定的 variant 操作数的内容调用给定的访问者的二元函数调用操作符。
  • 只接受一个访问者的重载将返回一个 泛型函数对象，该对象接受一个或两个参数并以这些参数和 visitor 调用 apply_visitor, 其行为和前面两项相似。(这种行为特别有用，例如当你需要对一个 variant 对象序列中的各个元素使用一个标准库算法时)。

返回：接受操作数的重载将返回将给定访问者应用于给定操作数所得的结果。只接受一个访问者的重载则返回一个函数对象，以延后将访问者应用于任意操作数。
要求：给定的访问者必须符合 StaticVisitor 概念的要求，并处理给定 variant 的各个有界类型。
抛出：接受操作数的重载只会在给定的访问者抛出异常时抛出。只接受一个访问者的重载则不会抛出。(但是请注意，返回的 函数对象 有可能在运行时抛出)
Boost：bind绑定boost::apply的测试程序
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-23 302
Boost：bind绑定boost::apply的测试程序实现功能C++实现代码 实现功能 bind绑定boost::apply的测试程序 C++实现代码 #include <boost/bind/apply.hpp> #include <boost/bind/protect.hpp> #include <boost/bind/bind.hpp> #include <boost/core/lightweight_test.hpp> using namespac
【BOOST C++Data-struct专题04】【04】Boost.Variant
gongdiwudu的专栏
10-18 4495
Boost.Variant 提供了一个类似于 union 的名为 boost::variant 的类。您可以将不同类型的值存储在 boost::variant 变量中。在任何时候只能存储一个值。分配新值时，旧值将被覆盖。但是，新值的类型可能与旧值不同。唯一的要求是这些类型必须作为模板参数传递给 boost::variant，这样它们才能为 boost::variant 变量所知。
boost::apply_visitor
qq_40178082的博客
12-20 606
是 Boost 库中用于访问 Variant 类型对象中存储的值的工具函数。Variant 类型是一种能够容纳多种类型值的类型，类似于联合体（union）或是 C++17 中的 std::variant。类型对象中的值，根据存储的不同类型值自动调用对应的处理函数，这对于处理不同类型的值在一组数据结构中很有用。则允许你使用访问者模式（Visitor Pattern）来处理 Variant 类型对象中的值。在 Boost 中，Variant 类型提供了一种安全、类型化的方式来处理不同类型的值。
std::apply如何使用
最新发布
m0_73610614的博客
06-05 425
std::apply是C++17引入的实用工具，用于将元组元素解包为函数参数。它接收一个可调用对象和元组，将元组元素展开并传递给该对象。主要用途包括：展开元组调用函数、结合lambda处理元组、构造对象以及调用成员函数。与std::invoke不同，std::apply专为元组解包设计。使用时需注意参数数量和类型匹配。该特性简化了元组操作，实现了函数调用与元组的无缝衔接，在参数传递和元组处理场景中非常实用。
boost 库 applyvisitor使用
sinat_42356311的博客
05-07 1239
boost::variant and boost::apply_visitor 2017年11月02日 15:30:52 秋云 阅读数：448  转自：http://www.jb51.net/article/95814.htm Boost.Variant Variant库包含一个不同于union的泛型类，用于在存储和操作来自于不同类型的对象。这个库的一个特点是支持类型安全的访问，减少了不同数据...
boost::variant and boost::apply_visitor
janeqi1987的专栏
11-02 1983
 转自：http://www.jb51.net/article/95814.htm Boost.Variant Variant库包含一个不同于union的泛型类，用于在存储和操作来自于不同类型的对象。这个库的一个特点是支持类型安全的访问，减少了不同数据类型的类型转换代码的共同问题。 Variant 库如何改进你的程序？      •对用户指定的多种类型的进行类型安全的存储和取回
C++ boost::apply_visitor使用详解
大隐隐于野
09-27 435
boost::apply_visitor —将给定的访问者应用到给定的 variant 的内容上，该过程在编译期进行类型安全检查，以确认所有类型均被访问者所处理。 template<typename Visitor, typename Variant> typename Visitor::result_type apply_visitor(Visitor & visitor, Variant & operand); template<typename Visit
C++11 boost::spirit::qi简单的XML解析器示例
zhuge19870104的博客
05-09 1014
boost::spirit::qi是一个简单的解释器开发库。可以用来解析文本，构建解释器等。 笔者花了两天时间看完了README文档，并且照着Demo代码写了一遍。感觉语法很复杂。特别是最后的一个XML解析器，很容易就写错了。好在错误信息还是很好理解的。 现在把代码贴出来和大家共享一下。 代码结构如下， test/CMakeLists.txt cmake_minimum_required(VERSION 2.6) if(APPLE) message(STATUS "This is Apple,
浅析C++中boost.variant的几种访问方法
09-01
在C++编程中，`boost.variant` 是Boost库提供的一种类型安全的数据结构，它允许存储一组预先定义的类型中的任意一种。在C++17之前，如果需要在代码中使用类似`variant`的功能，Boost库提供了很好的解决方案。本文将...
【BOOST C++字串专题11】Boost.Spirit（三）
gongdiwudu的专栏
10-14 4708
本章介绍库 Boost.Spirit。 Boost.Spirit 用于开发文本格式的解析器。例如，您可以使用 Boost.Spirit 开发解析器来加载配置文件。 Boost.Spirit 也可以用于二进制格式，尽管它在这方面的用处有限。
Boost库使用总结
hjwsm1989的专栏
09-29 5387
auto_ptr、shared_ptr、weak_ptr、scoped_ptr用法小结 智能指针，与引用计数相关 auto_ptr: 主要为异常安全设计的，在程序正常退出或者异常终止，会调用类的析构函数，释放资源。 复制\赋值是损坏性的操作，所以不能绑定到数组或者变量指针，也不能将auto_ptr对象存储在容器中。  auto_ptr a(new int(10)); auto_ptr b;
c++的boost库学习
06-22
c++ 下的boost 被称为准标准库，里面好些东西值得去了解学习。 本资源包括如下： boost_1_64_0.tar Boost程序库完全开发指南——深入C++“准”标准库高清版 The Boost C++ Libraries -- 英文文档
boost::hana::apply用法的测试程序
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-05 295
boost::hana::apply用法的测试程序实现功能C++实现代码 实现功能 boost::hana::apply用法的测试程序 C++实现代码 #include <boost/hana/functional/apply.hpp> #include <boost/hana/plus.hpp> namespace hana = boost::hana; static_assert(hana::apply(hana::plus, 1, 2) == 3, ""); int main(
关于boost中lambda表达式的学习
longyongchun01的专栏
04-03 1057
一些简单的例子： 使容器中的元素都减去5 std::for_each(vec.begin(), vec.end(), _1 -= 5); 计算容器中元素所有和 int nSum = 0; std::for_each(vec.begin(), vec.end(), nSum += _1); 基础： 1. 创建一个无参的lambda表达式：  boost::function func
boost 数据结构
是我
11-24 503
#include #include //tuple(元组),他和std::pair类似,只是他不仅仅存储一对数据,可以存储无限多个数据 //tuple使其支持流的输出,需要包含 #include typedef boost::tuple person; std::stringstream strstream; person per("hello","hi",32);
C++“准”标准库Boost学习指南-variant的使用
a418382926的专栏
08-10 8559
Variant库包含一个不同于union的泛型类，用于在存储和操作来自于不同类型的对象。这个库的一个特点是支持类型安全的访问，减少了不同数据类型的类型转换代码的共同问题。 Variant 库如何改进你的程序？ 对用户指定的多种类型的进行类型安全的存储和取回在标准库容器中存储不同类型的方法变量访问的编译期检查高效的、基于栈的变量存储 Variant 库关注的是对一组限定类型
boost学习之-Variant
07-09 1983
用法： 1 他与c语言中的union相对应 2 通过模板参数定义可以支持的类型 3 通过boost::get()进行访问 4 可通过boost::static_visitor与boost::apply_visitor(visitor, variant).的组合来访问 总结，目前还没想到这个有什么很好的用处； 看例子体会用法： class print_visitor : pub
boost I 容器与数据结构（四）
该用户还没想到好的昵称的博客
11-19 1575
目录 八、Variant 1.union 2.variant （1）初始化 （2）访问元素 （3）元素比较 （4）访问器 3.variant与any比较 4.boost::variant与std::variant比较 九、multi_array 1.初始化 2.遍历元素 3.访问某个元素 4.改变形状和大小 5.创建子视图 6.适配普通数组 7.设置、修改索引基数 8.禁用全局对象 八、Variant variant与 any 有些类似，它是一种可变类...
boost::tie()和boost::variant()讲解
mojolang
05-04 5155
boost::tie()和boost::variant()讲解
std::variant在C++11有类似的吗
03-15
<think>好的，用户现在问的是在C++11中是否有类似`std::variant`的东西。我需要先回想一下C++的标准发布时间和相关特性。记得`std::variant`是在C++17引入的，所以C++11本身并没有这个库。但用户可能想知道在C++11中如何实现类似功能，或者有没有替代方案。 首先，应该明确回答用户的问题，指出C++11没有`std::variant`，但可能有其他方法模拟。可能需要提到Boost库，因为Boost.Variant可能在C++11之前就有，但需要确认兼容性。另外，union是C++11中的原生类型，但它是受限的，只能用于POD类型，无法处理非平凡类型。 接下来，用户可能想知道如果不使用Boost，如何在C++11中手动实现类似的功能。这时候可以讨论使用联合体和类型标签的组合，或者继承层次结构，但这两种方法都有各自的缺点，比如类型不安全或代码复杂。 然后，需要比较不同的替代方案，比如Boost.Variant和C++11的union，指出各自的优缺点。例如，Boost.Variant提供了类型安全，但可能有性能开销，而union则轻量但限制多。 还要考虑用户可能的深层需求，比如他们是否在维护旧代码，或者需要在不支持C++17的环境中工作。这时候提供具体的实现示例会有帮助，比如展示一个简单类型安全的联合体实现。 另外，需要注意用户是否了解C++17的新特性，可能需要简要提及C++17的`std::variant`作为对比，强调其改进之处，比如类型安全和易用性。 最后，总结建议，根据用户的情况推荐使用Boost库（如果允许的话）或者手动实现，同时指出各自的限制，并建议升级到C++17或更高版本以获得更好的支持。</think>### 分步解析：C++11中如何实现类似`std::variant`的功能 `std::variant`是C++17引入的类型安全联合体，而C++11标准中没有直接等价物。但通过以下方法可以实现类似功能： --- #### 第一步：理解核心需求 `std::variant`的核心特性： 1. 存储多个不同类型的值 2. 类型安全访问 3. 自动管理生命周期 --- #### 第二步：C++11原生替代方案 ##### 方案1：`union`（受限实现） ```cpp union SimpleVariant { int i; double d; char c; }; // 需要额外存储类型标签 struct TaggedVariant { enum Type { INT, DOUBLE, CHAR } tag; union { int i; double d; char c; }; }; ``` **缺陷**： - 只能处理POD类型（无构造函数/析构函数的类型） - 需要手动管理类型标签 - 没有类型安全检查 ##### 方案2：继承层次结构 ```cpp class VariantBase { public: virtual ~VariantBase() {} }; template<typename T> class VariantHolder : public VariantBase { public: T value; VariantHolder(T v) : value(v) {} }; // 使用示例 VariantBase* var = new VariantHolder<int>(42); ``` **缺陷**： - 类型信息在运行时丢失 - 需要手动类型转换 - 内存管理复杂 --- #### 第三步：使用Boost库（推荐方案） C++11可通过[Boost.Variant](https://www.boost.org/doc/libs/1_83_0/doc/html/variant.html)实现： ```cpp #include <boost/variant.hpp> boost::variant<int, double, std::string> v; v = 3.14; // 存储double v = "hello"; // 存储string // 安全访问 struct Visitor : boost::static_visitor<> { void operator()(int i) const { /* 处理int */ } void operator()(double d) const { /* 处理double */ } void operator()(const std::string& s) const { /* 处理string */ } }; boost::apply_visitor(Visitor(), v); ``` **优势**： - 完全类型安全 - 支持非POD类型 - 提供访问者模式 --- #### 第四步：手动实现类型安全联合体 以下是一个简化实现示例： ```cpp #include <type_traits> #include <stdexcept> template<typename... Types> class Variant { alignas(std::aligned_union<0, Types...>::type) char storage[sizeof(std::aligned_union<0, Types...>)]; size_t type_index; template<typename T> static constexpr size_t get_index() { size_t index = 0; using dummy = bool[]; (void)dummy{ true, (std::is_same<T, Types>::value ? false : (++index, true))... }; return index; } public: template<typename T> Variant(T value) { static_assert((std::is_same<T, Types>::value || ...), "Invalid type"); new(storage) T(value); type_index = get_index<T>(); } template<typename T> T& get() { if (type_index != get_index<T>()) throw std::bad_cast(); return *reinterpret_cast<T*>(storage); } ~Variant() { using dummy = void[]; (void)dummy{ (destroy<Types>(), 0)... }; } private: template<typename T> void destroy() { if (type_index == get_index<T>()) reinterpret_cast<T*>(storage)->~T(); } }; // 使用示例 Variant<int, double, std::string> var(std::string("test")); std::cout << var.get<std::string>(); // 输出"test" ``` --- ### 对比分析 | 特性 | C++11 union | Boost.Variant | 手动实现 | C++17 std::variant | |--------------------|-------------|---------------|----------|--------------------| | 类型安全 | ❌ | ✅ | ✅ | ✅ | | 支持非POD类型 | ❌ | ✅ | ✅ | ✅ | | 异常安全 | ❌ | ✅ | 部分 | ✅ | | 标准库支持 | ✅ | ❌ | ❌ | ✅ | | 内存开销 | 最小 | 中等 | 中等 | 中等 | | 访问便利性 | 低 | 高（访问者） | 低 | 高（std::visit） | --- ### 演进路线建议 1. **短期方案**： - 使用`union`处理简单POD类型 - 引入Boost.Variant（需权衡依赖项） 2. **长期方案**： - 升级到C++17+直接使用`std::variant` - 配合`std::visit`实现模式匹配 --- 通过这种分阶段方案，可以在C++11环境中实现类型安全联合体的核心功能，同时为未来升级保留可能性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值