1. Toy模板网首页
  2. > Toy博客

C++三剑客之std::any(一) : 使用详解

9月前 作者：流星雨爱编程 分类：Toy博客 阅读(97) 违法举报

这篇具有很好参考价值的文章主要介绍了C++三剑客之std::any(一) : 使用详解。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

std::any,#C++进阶,c++,开发语言

相关系列文章

C++三剑客之std::optional(一) : 使用详解

C++三剑客之std::any(一) : 使用详解

C++之std::tuple(一) : 使用精讲(全)

C++三剑客之std::variant(一) : 使用

C++三剑客之std::variant(二)：深入剖析

目录

1.概述

2.构建方式

2.1.构造函数

2.2.std::make_any

2.3.operator=分配新值

3.访问值std::any_cast

4.修改器

4.1.emplace

4.2.reset

4.3.swap

5.观察器

5.1.has_value

5.2.type

6.总结

1.概述

        C++17的三剑客分别是std::optional, std::any, std::vairant。今天主要讲std::any。std::any类用于任何可拷贝构造类型的单个值的类型安全容器。在头文件<any>中，c++标准库定义了类std::any。

namespace std {
class any;
}

       从上面的定义可以看出std::any不是模版类，而是一种很特殊的容器，它只能容纳一个元素，但这个元素可以是任意的类型，可以是基本数据类型（int，double，char，float...）也可以是复合数据类型（类、结构体）。

        std: any是一种值类型，它能够更改其类型，同时仍然具有类型安全性。也就是说，对象可以保存任意类型的值，但是它们知道当前保存的值是哪种类型。在声明此类型的对象时，不需要指定可能的类型。

2.构建方式

2.1.构造函数

默认情况下，std::any的初始值为空。如：

std::any  a;

也可以赋初值，初始化对象std::any, 如：

std::any a = 32; //type: int
std::any b = "wegrthweg"; type : const chr*

要保存与初始值类型不同的类型，必须使用in_place_type标记：

std::any a{std::in_place_type<int>, 420};
std::any b{std::in_place_type<std::string>, "asdfbsrghtr34"};

即使传递给in_place_type的类型也会退化。下面的声明包含一个const char*:

std::any a{std::in_place_type<const char[6]>, "12345"};

要通过多个参数初始化可选对象，必须创建该对象或将std::in_place_type添加为第一个参数(不能推断包含的类型):

std::any a1{std::complex{6.0, 2.0}};
std::any a2{std::in_place_type<std::complex<double>>, 6.0, 2.0};

甚至可以传递一个初始化器列表，后面跟着附加的参数:

auto func = [] (int x, int y) { return std::abs(x) < std::abs(y);};
 
std::any a{std::in_place_type<std::set<int,decltype(func)>>, {3, 7, -1, -16, 1, 100}, func};

2.2.std::make_any

std::make_any的定义如下：

//[1]
template< class T, class... Args >
std::any make_any( Args&&... args );
//[2]
template< class T, class U, class... Args >
std::any make_any( std::initializer_list<U> il, Args&&... args );

构造含 T 类型对象的 any 对象，传递提供的参数给 T 的构造函数。

1) 等价于 return std::any(std::in_place_type<T>, std::forward<Args>(args)...);

2) 等价于 return std::any(std::in_place_type<T>, il, std::forward<Args>(args)...);

std::make_any必须显式指定初始化的类型(如果只传递一个参数，则不会推导出初始化的类型)，如：

#include <any>
#include <complex>
#include <functional>
#include <iostream>
#include <string>
 
int main()
{
    auto a0 = std::make_any<std::string>("Hello, std::any!\n");
    auto a1 = std::make_any<std::complex<double>>(0.1, 2.3);
 
    std::cout << std::any_cast<std::string&>(a0);
    std::cout << std::any_cast<std::complex<double>&>(a1) << '\n';
 
    using lambda = std::function<void(void)>;
 
    // 把 lambda 放入 std::any。尝试 #1 （失败）。
    std::any a2 = [] { std::cout << "Lambda #1.\n"; };
    std::cout << "a2.type() = \"" << a2.type().name() << "\"\n";
 
    // any_cast 转型到 <void(void)> 但实际类型不是
    // std::function ……，而是 ~ main::{lambda()#1} ，且它对
    // 每个 lambda 唯一。所以这会抛出……
    try {
        std::any_cast<lambda>(a2)();
    }
    catch (std::bad_any_cast const& ex) {
        std::cout << ex.what() << '\n';
    }
 
    // 将 lambda 放入 std::any 中。尝试 #2 （成功）
    auto a3 = std::make_any<lambda>([] { std::cout << "Lambda #2.\n"; });
    std::cout << "a3.type() = \"" << a3.type().name() << "\"\n";
    std::any_cast<lambda>(a3)();
}

输出：

Hello, std::any!
(0.1,2.3)
a2.type() = "Z4mainEUlvE_"
bad any_cast
a3.type() = "St8functionIFvvEE"
Lambda #2.

2.3.operator=分配新值

operator=的定义如下：

//[1]
any& operator=( const any& rhs );
//[2]
any& operator=( any&& rhs ) noexcept;
//[3]
template<typename ValueType>
any& operator=( ValueType&& rhs );

1) 通过复制 rhs 的状态赋值，如同用 any(rhs).swap(*this)。

2) 通过移动 rhs 的状态赋值，如同用 any(std::move(rhs)).swap(*this)。赋值后 rhs 留在有效但未指定的状态。

3) 以 rhs 的类型和值赋值，如同用 any(std::forward<ValueType>(rhs)).swap(*this)。此重载只有在 std::decay_t<ValueType> 与 any 不是同一类型且 std::is_copy_constructible_v<std::decay_t<ValueType>> 为 true 时才会参与重载决议。std::decay_t<ValueType> 必须满足可复制构造条件。示例如下：

std::any a = 1223;
std::any b = "2222222";
a = b; //[1]
b = 6.34655; //[3]
a = std::make_any<std::complex>(6.0, 2.0); //[2]

上面代码执行a = b调用的是第1个赋值函数，b=6.34655调用的是第3个赋值函数，a = std::make_any<std::complex>(6.0, 2.0) 是调用的第2个赋值函数。

3.访问值std::any_cast

std::any_cast的定义：

//[1]
template< class T >
T any_cast( const any& operand );
//[2]
template< class T >
T any_cast( any& operand );
//[3]
template< class T >
T any_cast( any&& operand );
//[4]
template< class T >
const T* any_cast( const any* operand ) noexcept;
//[5]
template< class T >
T* any_cast( any* operand ) noexcept;

要访问包含的值，必须使用std::any_cast<>将其转换为其类型。将该值转换为一个字符串，有几个选项: 

std::any_cast<std::string>(a) // yield copy of the value
std::any_cast<std::string&>(a); // write value by reference
std::any_cast<const std::string&>(a); // read-access by reference

在这里，如果转换失败，将抛出std::bad_any_cast异常。因此，在不检查或不知道类型的情况下，最好实现以下功能: 

try {
    auto s = std::any_cast<std::string>(a);
    ...
}
catch (std::bad_any_cast& e) {
    std::cerr << "EXCEPTION: " << e.what() << '\n';
}

注意，std::any_cast<>创建了一个传递类型的对象。如果将std::string作为模板参数传递给std::any_cast<>，它将创建一个临时string(一个prvalue)，然后用它初始化新对象。如果没有这样的初始化，通常最好转换为引用类型，以避免创建临时对象:

std::cout << std::any_cast<const std::string&>(a);

要修改该值，需要转换为对应的引用类型:

std::any_cast<std::string&>(a) = "2134y56";

根据上面的第4或5个转换函数定义还可以为std::any对象的地址调用std::any_cast。在这种情况下，如果类型匹配，则强制转换返回相应的地址指针;如果不匹配，则返回nullptr:

auto p = std::any_cast<std::string>(&a);
if (p) {
    ...
}

下面再看一个例子：

#include <any>
#include <iostream>
#include <string>
#include <type_traits>
#include <utility>
 
int main()
{
    // 简单示例
    auto a1 = std::any(12);
    std::cout << "1) a1 是 int：" << std::any_cast<int>(a1) << '\n';
 
    try
    {
        auto s = std::any_cast<std::string>(a1); // 抛出
    }
    catch (const std::bad_any_cast& e)
    {
        std::cout << "2) " << e.what() << '\n';
    }
 
    // 指针示例
    if (int* i = std::any_cast<int>(&a1))
        std::cout << "3) a1 是 int：" << *i << '\n';
    else if (std::string* s = std::any_cast<std::string>(&a1))
        std::cout << "3) a1 是 std::string：" << *s << '\n';
    else
        std::cout << "3) a1 是另一类型，或者没有设置\n";
 
    // 进阶示例
    a1 = std::string("hello");
    auto& ra = std::any_cast<std::string&>(a1); //< 引用
    ra[1] = 'o';
 
    std::cout << "4) a1 是字符串："
              << std::any_cast<std::string const&>(a1) << '\n'; //< const 引用
 
    auto s1 = std::any_cast<std::string&&>(std::move(a1)); //< 右值引用
    // 注意：“s1” 是移动构造的 std::string：
    static_assert(std::is_same_v<decltype(s1), std::string>);
 
    // 注意：“a1” 中的 std::string 被置于合法但未指定的状态
    std::cout << "5) a1.size()："
              << std::any_cast<std::string>(&a1)->size() //< 指针
              << '\n'
              << "6) s1：" << s1 << '\n';
}

输出：

1) a1 是 int：12
2) bad any_cast
3) a1 是 int：12
4) a1 是 string：hollo
5) a1.size()：0
6) s1：hollo

4.修改器

4.1.emplace

更改所含对象，直接构造新对象，示例如下：

#include <algorithm>
#include <any>
#include <iostream>
#include <string>
#include <vector>
 
class Star
{
    std::string name;
    int id;
 
public:
    Star(std::string name, int id) : name { name }, id { id }
    {
        std::cout << "Star::Star(string, int)\n";
    }
 
    void print() const
    {
        std::cout << "Star{ \"" << name << "\" : " << id << " };\n";
    }
};
 
auto main() -> int
{
    std::any celestial;
    // (1) emplace( Args&&... args );
    celestial.emplace<Star>("Procyon", 2943);
    const auto* star = std::any_cast<Star>(&celestial);
    star->print();
 
    std::any av;
    // (2) emplace( std::initializer_list<U> il, Args&&... args );
    av.emplace<std::vector<char>>({ 'C', '+', '+', '1', '7' } /* 无参数 */ );
    std::cout << av.type().name() << '\n';
    const auto* va = std::any_cast<std::vector<char>>(&av);
    std::for_each(va->cbegin(), va->cend(), [](char const& c) { std::cout << c; });
    std::cout << '\n';
}

输出：

Star::Star(string, int)
Star{ "Procyon" : 2943 };
St6vectorIcSaIcEE
C++17

4.2.reset

销毁所含对象。

4.3.swap

交换两个std::any。

5.观察器

5.1.has_value

检查对象是否含有值，若实例含值则为 true ，否则为 false 。示例如下：

#include <any>
#include <iostream>
#include <string>
 
int main()
{
    std::boolalpha(std::cout);
 
    std::any a0;
    std::cout << "a0.has_value(): " << a0.has_value() << "\n";
 
    std::any a1 = 42;
    std::cout << "a1.has_value(): " << a1.has_value() << '\n';
    std::cout << "a1 = " << std::any_cast<int>(a1) << '\n';
    a1.reset();
    std::cout << "a1.has_value(): " << a1.has_value() << '\n';
 
    auto a2 = std::make_any<std::string>("Milky Way");
    std::cout << "a2.has_value(): " << a2.has_value() << '\n';
    std::cout << "a2 = \"" << std::any_cast<std::string&>(a2) << "\"\n";
    a2.reset();
    std::cout << "a2.has_value(): " << a2.has_value() << '\n';
}

输出：

a0.has_value(): false
a1.has_value(): true
a1 = 42
a1.has_value(): false
a2.has_value(): true
a2 = "Milky Way"
a2.has_value(): false

5.2.type

查询所含类型，若实例非空则为所含值的 typeid ，否则为 typeid(void) 。示例如下：

#include <type_traits>
#include <any>
#include <functional>
#include <iomanip>
#include <iostream>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <vector>
 
template<class T, class F>
inline std::pair<const std::type_index, std::function<void(std::any const&)>>
    to_any_visitor(F const &f)
{
    return {
        std::type_index(typeid(T)),
        [g = f](std::any const &a)
        {
            if constexpr (std::is_void_v<T>)
                g();
            else
                g(std::any_cast<T const&>(a));
        }
    };
}
 
static std::unordered_map<
    std::type_index, std::function<void(std::any const&)>>
    any_visitor {
        to_any_visitor<void>([]{ std::cout << "{}"; }),
        to_any_visitor<int>([](int x){ std::cout << x; }),
        to_any_visitor<unsigned>([](unsigned x){ std::cout << x; }),
        to_any_visitor<float>([](float x){ std::cout << x; }),
        to_any_visitor<double>([](double x){ std::cout << x; }),
        to_any_visitor<char const*>([](char const *s)
            { std::cout << std::quoted(s); }),
        // ……添加更多你的类型的特化……
    };
 
inline void process(const std::any& a)
{
    if (const auto it = any_visitor.find(std::type_index(a.type()));
        it != any_visitor.cend()) {
        it->second(a);
    } else {
        std::cout << "Unregistered type "<< std::quoted(a.type().name());
    }
}
 
template<class T, class F>
    inline void register_any_visitor(F const& f)
{
    std::cout << "Register visitor for type "
              << std::quoted(typeid(T).name()) << '\n';
    any_visitor.insert(to_any_visitor<T>(f));
}
 
auto main() -> int
{
    std::vector<std::any> va { {}, 42, 123u, 3.14159f, 2.71828, "C++17", };
 
    std::cout << "{ ";
    for (const std::any& a : va) {
        process(a);
        std::cout << ", ";
    }
    std::cout << "}\n";
 
    process(std::any(0xFULL)); //< 反注册 "y" 的类型（ unsigned long long ）
    std::cout << '\n';
 
    register_any_visitor<unsigned long long>([](auto x) {
        std::cout << std::hex << std::showbase << x; 
    });
 
    process(std::any(0xFULL)); //< OK ： 0xf
    std::cout << '\n';
}

输出: 

{ {}, 42, 123, 3.14159, 2.71828, "C++17", }
Unregistered type "y"
Register visitor for type "y"
0xf

6.总结

        std::any是一个动态类型变量，可以存储任何类型的值。它是由C++17引入的一个新特性。std::any的设计目标是提供一种类型安全且易于使用的方式来在运行时处理各种类型的数据，因为任何错误的类型转换都会在运行时抛出异常。然而，std::any也有一些缺点。首先，因为std::any在运行时并不知道它存储的数据的具体类型，所以我们需要显式地进行类型转换。这可能会使代码变得复杂和难以理解。其次，std::any的性能可能不如其他类型，因为它需要在运行时进行类型检查和类型转换。

        总之，只要掌握了这些std::any的特性，明白了它的使用场景，才能灵活的使用std::any。

参考：std::any - cppreference.com

 文章来源地址https://www.toymoban.com/news/detail-832706.html

到了这里，关于C++三剑客之std::any(一) : 使用详解的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • linux的三剑客

    1、grep命令 grep全称是Global Regular Expression Print，表示全局正则表达式版本，它的使用权限是所有用户。它是Linux系统中一种强大的文本搜索工具，它能使用正则表达式搜索文本，并把匹配的行打印出来。 shell脚本中也经常使用grep，因为grep通过返回一个状态值来说明搜索的结果

    2024年02月07日
    浏览(56)
  • linux文本三剑客

    linux文本三剑客

    过滤/查找 参数 用法 作用 -i grep -i STRING xxx.txt 从xxx.txt文件查找不区分大小写STRING -w grep -w STRING xxx.txt 精确匹配STRING -e grep -e STRING1 -e STRING2 xxx.txt 查找多个STRING行 -n grep -n STRING xxx.txt 查看STRING 在第几行 -v grep -v STRING xxx.txt 输出不包含STRING的行 -r grep -r STRING DIR/ 查找DIR目录下哪

    2024年02月11日
    浏览(42)
  • Linux 三剑客

    Linux 三剑客

            grep主打的就是查找功能 ，它能够在一个或者多个文件中搜索某一特定的字符模式。         grep [选项] 模式 文件名 先说选项： 1.选项         要么是正则要么是字符串 -c       列出共出现多少次 -i        忽略大小写 -n       在前面列出行号 -v       列出没

    2024年02月11日
    浏览(44)
  • 前端三剑客简介

    前端三剑客简介

    W3C标准：网页主要由三部分组成 结构：html 表现：css，层叠样式表 行为：JavaScript div标签称为选择器，在div中各种属性来进行选择 css导入html有三种方式： 1，内联样式：在div标签中使用style 属性 2，内部样式：定义《style》标签，在标签内部定义css样式 3，外部样式：定义《

    2024年02月11日
    浏览(41)
  • 网页三剑客之 HTML

    网页三剑客之 HTML

    本章开始我们来介绍一下网页前端部分，我们只是简单的介绍一些常用的各种标签，其目的在于为我们后面的项目做准备。 我们并不要求能完全掌握前端的语法，但是在见到以后能够认识这些代码就可以了。 想走后端开发的，前端不需要多么熟悉，毕竟在各个企业中前后端

    2024年02月02日
    浏览(41)
  • 文本三剑客之 awk

    文本三剑客之 awk

    Linux/UNIX 系统中，awk 是一个功能强大的编辑工具。逐行读取输入文本 以空格作为分割符，多个空格他会自动压缩成一个空格 AWK信息的读入也是逐行指定的匹配模式进行查找，对符合条件的内容进行格式化输出或者过滤处理. 1按照命令找指定的行  2.找到的行 打印，操作 awk

    2024年02月08日
    浏览(42)
  • 『 前端三剑客 』：CSS常用属性

    『 前端三剑客 』：CSS常用属性

    一 . CSS常用元素属性 1.1 字体家族和 字体大小 设置的字体需要是 windows 上自带的字体 , 要求是系统中已经安装了的字体 使用 css 设置字体为微软雅黑 和 宋体 , 字体大小为 30 px 和 40 px font - size 设置的是字体的字符框的高度的大小 . 设置效果如下所示 1.2 设置字体粗细 font-we

    2024年02月15日
    浏览(47)
  • 『 前端三剑客 』：HTML常用标签

    『 前端三剑客 』：HTML常用标签

    在HTML中标签是以成对的结构出现的,在HTML当中代码是通过标签来组织的 , 下面通过见得的Hello World的展现来显示歘HTML 标签的结构 如上述代码块所示,形如 用尖括号进行组织的,成对出现的这个东西就叫做标签 (tag) , 也可以叫做元素(element); 通常情况下一个标签是成对出现的, 开

    2024年02月09日
    浏览(47)
  • 『 前端三剑客 』：CSS选择器

    『 前端三剑客 』：CSS选择器

    上一篇文章我们介绍了 html 的常用标签及用法 , 这次我们来介绍 css 来对页面进行美化处理 css 全称 : 层叠样式表 (Cascading Style Sheets). 主要作用 : 能够对网页中元素位置的排版进行像素级精确控制, 实现美化页面 的效果. 能够做到 页面的样式和结构分离 . 一 . 基本语法 基本语

    2024年02月09日
    浏览(44)
  • Linux文本三剑客---awk

    Linux文本三剑客---awk

    Linux文本三剑客之一（grep,sed,awk），功能最强大的文本工具。 逐行读取输入的文本内容，默认以空格和tab键作为分隔符。但是多个空格或者tab键的空格，会自动压缩成一个，然后按照指定的模式和条件执行编辑命令 可以在免交互的情况下，实现复杂的文本操作。完成自动化配

    2024年02月07日
    浏览(48)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包