C++ 使用std::any实现类型安全（c++类型安全的,其转换方法为）

使用std::any实现类型安全

C++17引入的std::any类为任何类型的单个对象提供了一个类型安全的容器。

例如，这是一个默认构造的any对象：

std::any x{};

这个对象没有值。我们可以使用has_value()方法来测试这一点：

if(x.has_value()) cout << "have value\n";  
else cout << "no value\n";

输出：

no value

我们使用赋值运算符给any对象赋值：

x = 42;

现在，any对象有了一个值和类型：

if(x.has_value()) {  
    cout << format("x has type: {}\n", x.type().name());  
    cout << format("x has value: {}\n", std::any_cast<int>(x));  
} else {  
    cout << "no value\n";  
}

输出：

x has type: i  
x has value: 42

type()方法返回一个type_info对象。type_info::name()方法返回一个实现定义的C字符串类型名。在这种情况下，对于GCC，i表示int。

我们使用any_cast<type>()非成员函数来转换值以便使用。

我们可以将any对象重新赋值为不同类型的不同值：

x = "abc"s;  
cout << format("x is type {} with value {}\n",  
    x.type().name(), std::any_cast<std::string>(x));

输出（GCC类型名可能很长，这里进行了缩写）：

x is type NSt7__cxx1112basic_string... with value abc

同一个any对象，之前包含了一个int，现在包含了一个STL字符串对象。

any类的主要用途在于创建多态函数。让我们在本示例中检查如何实现这一点：

如何做……

在本示例中，我们将使用any类构建一个多态函数。多态函数是一个可以接受不同类型对象的参数的函数：

我们的多态函数接受一个any对象，并打印其类型和值：

void p_any(const std::any& a) {  
    if (!a.has_value()) {  
        cout << "None.\n";  
    } else if (a.type() == typeid(int)) {  
        cout << format("int: {}\n", std::any_cast<int>(a));  
    } else if (a.type() == typeid(std::string)) {  
        cout << format("string: \"{}\"\n", std::any_cast<const std::string&>(a));  
    } else if (a.type() == typeid(std::list<int>)) {  
        cout << "list<int>: ";  
        for(auto& i : std::any_cast<const std::list<int>&>(a))  
            cout << format("{} ", i);  
        cout << '\n';  
    } else {  
        cout << format("something else: {}\n", a.type().name());  
    }  
}

p_any()函数首先测试对象是否有值。然后，它将type()方法与各种类型进行比较，并为每种类型采取适当的操作。

在any类之前，我们可能需要为这个函数编写四个不同的特化版本，而且仍然无法轻松处理默认情况。

我们从main()函数中调用这个函数，像这样：

p_any({});  
p_any(47);  
p_any("abc"s);  
p_any(std::any(std::list{ 1, 2, 3 }));  
p_any(std::any(std::vector{ 1, 2, 3 }));

输出：

None.  
int: 47  
string: "abc"  
list<int>: 1 2 3  
something else: St6vectorIiSaIiEE

我们的多态函数以最少的代码处理了各种类型。

它是如何工作的……

std::any的拷贝构造函数和赋值运算符使用直接初始化来制作目标对象的非const拷贝作为包含的对象。包含对象的类型作为typeid对象单独存储。

一旦初始化，any对象具有以下方法：

- emplace()：替换包含的对象，在原地构造新对象。

- reset()：销毁包含的对象。

- has_value()：如果包含对象则返回true。

- type()：返回一个typeid对象，表示包含对象的类型。

- operator=()：通过拷贝或移动操作替换包含的对象。

any类还支持以下非成员函数：

- any_cast<T>()：一个模板函数，提供对包含对象的类型安全访问。请注意，any_cast<T>()函数返回包含对象的拷贝。你可以使用any_cast<T&>()来返回引用。

- std::swap()：对std::swap算法进行了特化。

如果你尝试用错误的类型来转换any对象，它会抛出一个bad_any_cast异常：

try {  
    cout << std::any_cast<int>(x) << '\n';  
} catch(std::bad_any_cast& e) {  
    cout << format("any: {}\n", e.what());  
}

输出：

any: bad any_cast