Use Modern C++ std::any in your projects

std::any is a feature of the C++ standard library that was introduced in C++17.

This component belongs to the set of type-safe container classes, providing a safe means to store and manipulate values of any type.

It is especially useful when you need to deal with situations where the type of the variable can vary! 😃

Then you say:

- Oh man! Good. For these cases I use void *.

Yes, you’re really right, but have you seen how the new generation is in relation to memory safety???

Not to mention that void* is really dangerous!

If you do this, it works:

void * some_data; // Bad idea std::string str = "Hi"; int x = 3; decltype(x) y = 6; some_data = &str; std::cout << *(std::string*)some_data << '\n'; some_data = &x; std::cout << *(int*)some_data << '\n'; some_data = &y; std::cout << "Type of y: " << typeid(y).name() << '\n'; // include typeinfo

But, the chance of this giving s%1t is great! At the end of using these variables, some_data will continue to exist, that is, an indefinite lifetime!

And it is to replace void* that std::any was created in Modern C++ which, of course, is totally Safe!

In other words, it is a wrapper that encapsulates your variable to a shared_ptr(smart pointers) of life! Yes, and there is even a std::make_any!!!

How to use `std::any`

First you need to include its header:

Logically, it only works from C++17 as was said at the beginning!

#include <any>

And now the same code that was presented above, but using std::any:

#include <iostream> #include <any>  int main(){ std::any some_data; std::string str = "Hi"; int x = 3; auto y = std::make_any<decltype(x)>(6); some_data = str; std::cout << std::any_cast<std::string>(some_data) << '\n'; some_data = x; std::cout << std::any_cast<int>(some_data) << '\n'; some_data = y; std::cout << "Type of y: " << some_data.type().name() << '\n'; }

In the code above we saw that:

std::any some_data; - Declares the variable;
std::any_cast<T>(some_data) - Converts to the desired type;
std::make_any<T> - Another way to create objects;
some_data.type().name() - Gets the data type without needing typeinfo.

And you can use it for absolutely everything: std::vector, Lambda and all existing data types!

And the guy asks something else:

- OK! What if I want to end the lifetime of std::any manually?

Just use the reset union structure or even the initialization operator:

some_data.reset(); // Or some_data = {};

— And to check if std::any is empty?

Use has_value():

std::cout << (some_data.has_value() ? "Full!" : "Empty.") << '\n';

The unionless type() with name() can be used to compare types:

std::cout << (some_data.type() == typeid(void)) << '\n'; // 0 to false std::cout << (some_data.type() == typeid(int)) << '\n'; // 1 to true

To use Boolean names use: std::cout << std::boolalpha << (some_data.type() == typeid(int)) << '\n';.

To throw exceptions you must use std::bad_any_cast:

try { std::any any_str("Hiii"); auto my_any{ std::make_any<std::string>(any_str.type().name()) }; std::cout << std::any_cast<std::string>(my_any) << '\n'; }catch (const std::bad_any_cast& e) { std::cerr << "Error: " << e.what() << std::endl; }

To check whether everything really complies, never forget to use the flags for your compiler: -Wall -Wextra -pedantic -g -fsanitize=address.

Real life example

Imagine you have code that needs to concatenate several types and return a string. However, one of the types can be: int, double or std::string.

If you use std::any_cast<T> in the return like this:

Example:

#include <iostream> #include <any> #include <sstream>  enum class Message { SUCCESS, WARNING, ERROR, UNKNOW }; std::string add_info(Message, const std::string&, std::any, int); int main(){ std::any obj; obj = std::string("Start"); std::cout << add_info(Message::SUCCESS, " of type string: ", obj, 3) << '\n'; obj = 6; std::cout << add_info(Message::WARNING, " of type int: ", obj, 9) << '\n'; obj = 3.14; std::cout << add_info(Message::ERROR, " of type double: ", obj, 0) << '\n'; obj.reset(); std::cout << add_info(Message::UNKNOW, " no type: ", obj, 9) << '\n'; obj = "CONST_CHAR"; std::cout << add_info(Message::SUCCESS, " no type: ", nullptr, 9) << '\n'; return 0; } std::string add_info(Message msg, const std::string& out, std::any object, int num){ return std::any_cast<std::string>(msg) + out + "'" + std::any_cast<std::string>(object) + "' " + std::to_string(num); }

Compile: g++ -Wall -Wextra -pedantic -g -fsanitize=address main.cpp.

There will be a std::bad_any_cast in the output:

terminate called after throwing an instance of 'std::bad_any_cast' what(): bad any_cast Aborted

Both conversions (from msg and object) are incorrect:

std::any_cast<std::string>(msg) + ... // How much std::any_cast<std::string>(object)

You need to make a switch case for the enumerator and in the case of the object parameter: You will need to use has_value(), store the type() in std::type_info& and use a std:: stringstream to assign return types with union to: str(), like this:

#include <iostream> #include <any> #include <sstream>  enum class Message { SUCCESS, WARNING, ERROR, UNKNOW }; std::string add_info(Message, const std::string&, std::any, int); int main(){ std::any obj; obj = std::string("Start"); std::cout << add_info(Message::SUCCESS, " of type string: ", obj, 3) << '\n'; obj = 6; std::cout << add_info(Message::WARNING, " of type int: ", obj, 9) << '\n'; obj = 3.14; std::cout << add_info(Message::ERROR, " of type double: ", obj, 0) << '\n'; obj.reset(); std::cout << add_info(Message::UNKNOW, " no type: ", obj, 9) << '\n'; obj = "CONST_CHAR"; std::cout << add_info(Message::SUCCESS, " no type: ", nullptr, 9) << '\n'; return 0; } std::string add_info(Message msg, const std::string& out, std::any object, int num){ std::string local_msg {"NOTHING"}; std::stringstream ss; switch (msg){ case Message::SUCCESS: local_msg = "SUCCESS"; break; case Message::WARNING: local_msg = "WARNING"; break; case Message::ERROR: local_msg = "ERROR"; break; case Message::UNKNOW: local_msg = "UNKNOW"; break; } if (object.has_value()) { const std::type_info& type = object.type(); if (type == typeid(std::string)) { ss << std::any_cast<std::string>(object); } else if (type == typeid(int)) { ss << std::any_cast<int>(object); } else if (type == typeid(double)) { ss << std::any_cast<double>(object); } else { ss << "null"; } } else { ss << "[no object]"; } return local_msg + out + "'" + ss.str() + "' " + std::to_string(num); }

Compile: g++ -Wall -Wextra -pedantic -g -fsanitize=address main.cpp and after running ./a.out, the output will be:

SUCCESS of type string: 'Start' 3 WARNING of type int: '6' 9 ERROR of type double: '3.14' 0 UNKNOW without type: '[no object]' 9 SUCCESS without type: 'null' 9

It seems laborious, but this is the correct way to end the lifespan of any type!

In addition to being completely SAFE, std::any is very practical and a great help!

For more information visit: https://en.cppreference.com/w/cpp/utility/any

cpp cppdaily