Everything you need to know about std :: any

The basics

class MyAny
{
    void* _value;
    TypeInfo _typeInfo;
};

std::any a(12);

//    :
a = std::string("Hello!");
a = 16;
//   :

//    a  
std::cout << std::any_cast<int>(a) << '\n'; 

//    :
try 
{
    std::cout << std::any_cast<std::string>(a) << '\n';
}
catch(const std::bad_any_cast& e) 
{
    std::cout << e.what() << '\n';
}

//        - :
a.reset();
if (!a.has_value())
{
    std::cout << "a is empty!" << "\n";
}

//    any  :
std::map<std::string, std::any> m;
m["integer"] = 10;
m["string"] = std::string("Hello World");
m["float"] = 1.0f;

for (auto &[key, val] : m)
{
    if (val.type() == typeid(int))
        std::cout << "int: " << std::any_cast<int>(val) << "\n";
    else if (val.type() == typeid(std::string))
        std::cout << "string: " << std::any_cast<std::string>(val) << "\n";
    else if (val.type() == typeid(float))
        std::cout << "float: " << std::any_cast<float>(val) << "\n";
}

16
bad any_cast
a is empty!
float: 1
int: 10
string: Hello World

• std::any — std::optional std::variant
• , .has_value()
• .reset()
• std::decay
• ,
• std::any_cast, bad_any_cast, «T»
• .type(), std::type_info

When to use?

• In libraries - when your library needs to store or transfer some data, and you do not know what type this data can be
• When parsing files - if you really can’t determine what types are supported
• Messaging
• Scripting Language Interaction
• Creating an interpreter for a scripting language
• User Interface - Fields Can Store Anything

Create std :: any

• standard initialization - object is empty
• direct initialization with value / object
• directly indicating the type of object - std::in_place_type
• via std::make_any

//  :
std::any a;
assert(!a.has_value());

//   :
std::any a2(10); // int
std::any a3(MyType(10, 11));

// in_place:
std::any a4(std::in_place_type<MyType>, 10, 11);
std::any a5{std::in_place_type<std::string>, "Hello World"};

// make_any
std::any a6 = std::make_any<std::string>("Hello World");

Change value

std::any a;

a = MyType(10, 11);
a = std::string("Hello");

a.emplace<float>(100.5f);
a.emplace<std::vector<int>>({10, 11, 12, 13});
a.emplace<MyType>(10, 11);

Object Life Cycle

std::any var = std::make_any<MyType>();
var = 100.0f;
std::cout << std::any_cast<float>(var) << "\n";

MyType::MyType
MyType::~MyType
100

Gaining access to a value

• return a copy of the value and quit std::bad_any_caston error
• return a link to the value and quit std::bad_any_cast on error
• return a pointer to a value (constant or not) or nullptr in case of an error

struct MyType
{
    int a, b;

    MyType(int x, int y) : a(x), b(y) { }

    void Print() { std::cout << a << ", " << b << "\n"; }
};

int main()
{
    std::any var = std::make_any<MyType>(10, 10);
    try
    {
        std::any_cast<MyType&>(var).Print();
        std::any_cast<MyType&>(var).a = 11; // /
        std::any_cast<MyType&>(var).Print();
        std::any_cast<int>(var); // throw!
    }
    catch(const std::bad_any_cast& e) 
    {
        std::cout << e.what() << '\n';
    }

    int* p = std::any_cast<int>(&var);
    std::cout << (p ? "contains int... \n" : "doesn't contain an int...\n");

    MyType* pt = std::any_cast<MyType>(&var);
    if (pt)
    {
        pt->a = 12;
        std::any_cast<MyType&>(var).Print();
    }
}

Performance and memory usage

Implementations should avoid the use of dynamically allocated memory for a small contained value. Example: where the object constructed is holding only an int. Such small-object optimization shall only be applied to types T for which is_nothrow_move_constructible_v is true

An implementation should avoid using dynamic memory for small-sized stored data. For example, when an object is created storing only int. Such optimization for small objects should only be applied to types T for which is_nothrow_move_constructible_v is true.

Migrating from boost :: any

Examples of using std :: any

File parsing

Messaging

LRESULT CALLBACK WindowProc(
  _In_ HWND   hwnd,
  _In_ UINT   uMsg,
  _In_ WPARAM wParam,
  _In_ LPARAM lParam
);

class Message
{
public:
    enum class Type 
    {
        Init,
        Closing,
        ShowWindow,        
        DrawWindow
    };

public:
    explicit Message(Type type, std::any param) :
        mType(type),
        mParam(param)
    {   }
    explicit Message(Type type) :
        mType(type)
    {   }

    Type mType;
    std::any mParam;
};

class Window
{
public:
    virtual void HandleMessage(const Message& msg) = 0;
};

Message m(Message::Type::ShowWindow, std::make_pair(10, 11));
yourWindow.HandleMessage(m);

switch (msg.mType) {
// ...
case Message::Type::ShowWindow:
    {
    auto pos = std::any_cast<std::pair<int, int>>(msg.mParam);
    std::cout << "ShowWidow: "
              << pos.first << ", " 
              << pos.second << "\n";
    break;
    }
}

Properties

struct property
{
    property();
    property(const std::string &, const std::any &);

    std::string name;
    std::any value;
};

typedef std::vector<property> properties;

We pass through the borders

The bottom line is that std :: any allows you to transfer rights to arbitrary data across borders that do not know about its type.

• in the library for the interface: you do not know what types the client wants to use there
• messaging: the same idea - give the customer flexibility
• file parsing: to support any type

Total

• std::any not a template class
• std::any uses optimization of small objects, so it will not dynamically allocate memory for simple types such as int or double, and for larger types, additional memory will be used
• std::any can be called "heavy", but it offers safety and greater flexibility
• Access to the data std::anycan be obtained with the help of any_castwhich offers several "modes". For example, in case of an error, it may throw an exception or just return nullptr
• use it when you don’t know exactly what data types are possible, otherwise consider using std::variant