std::any 是 C 17 引入的類型安全的任意類型存儲(chǔ)工具，可用于保存和檢索任意可復(fù)制的類型，適用于配置系統(tǒng)、插件接口等需要異構(gòu)數(shù)據(jù)容器的場(chǎng)景；使用時(shí)需包含 頭文件，并通過(guò) std::any_cast 安全提取值，配合 .type() 與 typeid 檢查類型，避免異常；支持自定義類型存儲(chǔ)，但不支持直接存儲(chǔ) move-only 類型，可通過(guò) std::unique_ptr 包裝解決；存在性能開(kāi)銷且無(wú)隱式類型轉(zhuǎn)換，適合非性能關(guān)鍵路徑的動(dòng)態(tài)類型需求，但不應(yīng)替代模板或多態(tài)機(jī)制，使用時(shí)必須確保類型匹配后才進(jìn)行提取，以保證類型安全，最終實(shí)現(xiàn)靈活而安全的泛型數(shù)據(jù)處理。

Working with std::any in C allows you to store and retrieve values of any type safely, as long as you manage type checks and access properly. It's part of the C 17 standard library and is useful when you need heterogeneous data containers—like when building configuration systems, plugin interfaces, or generic data holders.

Here’s how to use std::any effectively:

1. Including and Basic Usage

To use std::any, include the <any></any> header:

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

int main() {
    std::any value = 42;             // store an int
    value = std::string("hello");    // now store a string
}

You can assign values of any copyable type to a std::any object.

2. Retrieving Values with std::any_cast

To get the stored value, use std::any_cast. This is the only safe way to extract data.

Retrieving with Correct Type (Success)

std::any data = 3.14;
if (auto* ptr = std::any_cast<double>(&data)) {
    std::cout << *ptr << '\n';
}

Or directly (throws std::bad_any_access on type mismatch):

try {
    double d = std::any_cast<double>(data);
    std::cout << d << '\n';
} catch (const std::bad_any_access&) {
    std::cout << "Wrong type!\n";
}

Safe Retrieval with Pointer Cast

Using a pointer version of any_cast avoids exceptions:

if (const auto* str = std::any_cast<std::string>(&data)) {
    std::cout << "String: " << *str << '\n';
} else if (const auto* num = std::any_cast<int>(&data)) {
    std::cout << "Integer: " << *num << '\n';
}

This pattern is useful when handling multiple possible types.

3. Checking and Managing Types

You can check what type is stored using .type() and compare with typeid.

#include <typeinfo>

if (data.type() == typeid(std::string)) {
    std::cout << "It's a string!\n";
} else if (data.type() == typeid(int)) {
    std::cout << "It's an integer!\n";
}

This works well in combination with any_cast for safe dispatch.

4. Clearing or Resetting std::any

To make an std::any empty, assign {} or use .reset():

data.reset();  // now data.has_value() returns false

if (!data.has_value()) {
    std::cout << "No value stored.\n";
}

You can also check emptiness:

if (data.has_value()) {
    // safe to cast
}

5. Storing Custom Types

You can store user-defined types as long as they are copyable.

struct Person {
    std::string name;
    int age;
};

std::any p = Person{"Alice", 30};

if (const auto* person = std::any_cast<Person>(&p)) {
    std::cout << person->name << ", " << person->age << '\n';
}

Note: std::any requires the type to be copy-constructible. Move-only types (like std::unique_ptr) won’t work unless wrapped (see below).

6. Limitations and Workarounds

• No move-only types directly: std::any needs copyability. But you can wrap move-only types in a std::unique_ptr:

std::any wrapper = std::unique_ptr<int>(new int(42));
if (auto* ptr = std::any_cast<std::unique_ptr<int>>(&wrapper)) {
    std::cout << "Value: " << **ptr << '\n';
}

• Performance cost: Type erasure and dynamic allocation (for larger types) can add overhead. Avoid std::any in performance-critical paths if possible.

• No implicit conversions: Even int to double fails. You must extract the exact stored type.

7. Practical Example: Heterogeneous Container

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

int main() {
    std::vector<std::any> values = {1, "text", 3.14, std::string("hello")};

    for (const auto& v : values) {
        if (v.type() == typeid(int)) {
            std::cout << "int: " << std::any_cast<int>(v) << '\n';
        } else if (v.type() == typeid(const char*)) {
            std::cout << "char*: " << std::any_cast<const char*>(v) << '\n';
        } else if (v.type() == typeid(double)) {
            std::cout << "double: " << std::any_cast<double>(v) << '\n';
        } else if (v.type() == typeid(std::string)) {
            std::cout << "string: " << std::any_cast<std::string>(v) << '\n';
        }
    }
}

Note: String literals are const char*, not std::string, so be careful.

Basically, std::any is a type-safe union for when you need flexibility. Use it when you must store different types in the same variable or container, but always check types before casting. It's not a replacement for templates or polymorphism, but a tool for specific dynamic-type scenarios.

以上是如何與std :: c一起工作的詳細(xì)內(nèi)容。更多信息請(qǐng)關(guān)注PHP中文網(wǎng)其他相關(guān)文章！