@TOC

前言

std::any 是 C++17 引入的一个标准库类，它提供了一种安全的方式来存储和操作类型不确定的值。它允许在程序运行时动态地存储任意类型的对象，而无需在编译时确定类型。这种特性使得 std::any 在需要灵活处理不同数据类型的场景中非常有用，如插件系统、配置管理等。

为什么使用 std::any

• 动态类型处理：当需要存储和操作不同类型的对象时，std::any 提供了一种方式来处理这些对象，而无需在编译时确定具体的类型。
• 类型安全：与 void* 等其他类型擦除技术不同，std::any 通过 std::any_cast 提供了安全的类型转换，避免了类型不匹配的问题。
• 接口和存储：std::any 可以作为通用的容器，用于在需要传递不同类型数据的接口中，或者在动态类型的存储和处理场景中使用。

std::any 与 auto 的区别

• std::any：用于在运行时存储和处理任意类型的数据，支持类型安全的查询和转换。适用于类型在运行时确定的情况。
• auto：用于在编译时自动推断变量的类型，适用于类型在编译时已知的情况。auto 不涉及运行时类型处理。

std::any 的构造函数和操作函数

构造函数

• 默认构造函数

  std::any();
  

  std::any a;  // 创建一个空的 std::any
  

• 值构造函数

  template <class T>
  std::any(T&& value);
  

  std::any a = 42;  // 存储整数 42
  std::any b = std::string("hello");  // 存储字符串 "hello"
  

• 复制构造函数

  std::any(const std::any& other);
  

  std::any a = 42;
  std::any b(a);  // 复制构造
  

• 移动构造函数

  std::any(std::any&& other) noexcept;
  

  std::any a = std::string("hello");
  std::any b(std::move(a));  // 移动构造
  

赋值操作

• 赋值操作符

  std::any& operator=(const std::any& other);
  std::any& operator=(std::any&& other) noexcept;
  

  std::any a = 42;
  std::any b;
  b = a;  // 赋值
  b = std::string("world");  // 赋值新的类型
  

类型查询和访问

• has_value()

  bool has_value() const noexcept;
  

  std::any a = 42;
  if (a.has_value()) {
      std::cout << "a has a value" << std::endl;
  }
  

• type()

  std::type_info const& type() const noexcept;
  

  std::any a = 42;
  std::cout << "Type: " << a.type().name() << std::endl;
  

• operator T& 和 operator T const&

  template <class T>
  T& any_cast();
  template <class T>
  const T& any_cast() const;
  

  std::any a = 42;
  int value = std::any_cast<int>(a);  // 获取存储的整数值
  std::cout << "Value: " << value << std::endl;
  

• any_cast (非成员函数)

  template <class T>
  T any_cast(const std::any& operand);
  template <class T>
  T any_cast(std::any&& operand);
  

  std::any a = 42;
  int value = std::any_cast<int>(a);  // 获取存储的整数值
  std::cout << "Value: " << value << std::endl;
  

• reset()

  void reset() noexcept;
  

  std::any a = 42;
  a.reset();  // 清空 std::any 中的内容
  

any_cast 的所有用法

• any_cast (模板函数)

  • 用法1：将 std::any 转换为指定类型

    template <class T>
    T any_cast(const std::any& operand);
    

    std::any a = 42;
    int value = std::any_cast<int>(a);  // 获取存储的整数值
    std::cout << "Value: " << value << std::endl;
    

  • 用法2：将 std::any 转换为指定类型（右值）

    template <class T>
    T any_cast(std::any&& operand);
    

    std::any a = std::string("hello");
    std::string value = std::any_cast<std::string>(std::move(a));  // 获取存储的字符串
    std::cout << "Value: " << value << std::endl;
    

  • 用法3：将 std::any 转换为指定类型（引用）

    template <class T>
    T& any_cast(std::any& operand);
    template <class T>
    const T& any_cast(const std::any& operand);
    

    std::any a = 42;
    int& value = std::any_cast<int&>(a);  // 获取存储的整数引用
    std::cout << "Value: " << value << std::endl;
    

示例代码

下面的示例展示了 std::any 的各种构造函数、操作函数和 any_cast 的用法：

#include <iostream>
#include <any>
#include <string>

void printAny(const std::any& a) {
    try {
        if (a.type() == typeid(int)) {
            std::cout << "Integer: " << std::any_cast<int>(a) << std::endl;
        } else if (a.type() == typeid(std::string)) {
            std::cout << "String: " << std::any_cast<std::string>(a) << std::endl;
        }
    } catch (const std::bad_any_cast& e) {
        std::cerr << "Bad any_cast: " << e.what() << std::endl;
    }
}

int main() {
    // 使用值构造函数
    std::any a = 42;
    std::any b = std::string("hello");

    // 打印类型
    std::cout << "Type of a: " << a.type().name() << std::endl;
    std::cout << "Type of b: " << b.type().name() << std::endl;

    // 使用any_cast访问值
    printAny(a);
    printAny(b);

    // 清空std::any内容
    a.reset();
    if (!a.has_value()) {
        std::cout << "a is empty" << std::endl;
    }

    // 使用移动构造函数
    std::any c = std::move(b);
    if (c.has_value()) {
        std::cout << "c has value: " << std::any_cast<std::string>(c) << std::endl;
    }

    // 使用any_cast
    std::any d = 3.14;
    double valueD = std::any_cast<double>(d);  // 获取存储的双精度浮点数
    std::cout << "Value of d: " << valueD << std::endl;

    return 0;
}

总结

std::any 提供了一种灵活且类型安全的方式来存储和操作类型不确定的值。它适用于需要动态处理不同类型数据的场景，例如配置管理和插件系统。与 auto 不同，std::any 在运行时处理类型，并提供安全的类型查询和转换，而 auto 仅用于简化静态类型声明。理解 std::any 的使用和 any_cast 的功能，有助于在处理复杂数据类型和动态类型时编写更安全和灵活的代码。