Todo lo que necesitas saber sobre std :: any

Los basicos

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

¿Cuándo usar?

• En bibliotecas: cuando su biblioteca necesita almacenar o transferir algunos datos, y no sabe de qué tipo pueden ser estos datos
• Al analizar archivos, si realmente no puede determinar qué tipos son compatibles
• Mensajería
• Interacción del lenguaje de scripting
• Crear un intérprete para un lenguaje de script
• Interfaz de usuario: los campos pueden almacenar cualquier cosa

Crear std :: any

• inicialización estándar: el objeto está vacío
• inicialización directa con valor / objeto
• indicando directamente el tipo de objeto - std::in_place_type
• vía 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");

Valor de cambio

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);

Ciclo de vida del objeto

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

MyType::MyType
MyType::~MyType
100

Obtener acceso a un valor

• devolver una copia del valor y salir std::bad_any_castpor error
• devolver un enlace al valor y salir std::bad_any_cast por error
• devolver un puntero a un valor (constante o no) o nullptr en caso de 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();
    }
}

Rendimiento y uso de memoria

Las implementaciones deben evitar el uso de memoria asignada dinámicamente para un pequeño valor contenido. Ejemplo: donde el objeto construido solo contiene un int. Dicha optimización de objetos pequeños solo se aplicará a los tipos T para los que is_nothrow_move_constructible_v es verdadero

Una implementación debe evitar el uso de memoria dinámica para datos almacenados de pequeño tamaño. Por ejemplo, cuando se crea un objeto que almacena solo int. Dicha optimización para objetos pequeños solo debe aplicarse a los tipos T para los que is_nothrow_move_constructible_v es verdadero.

Migración desde boost :: any

Ejemplos de uso de std :: any

Análisis de archivos

Mensajería

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;
    }
}

Propiedades

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

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

typedef std::vector<property> properties;

Pasamos por las fronteras

La conclusión es que std :: any le permite transferir derechos a datos arbitrarios a través de fronteras que no conocen su tipo.

• en la biblioteca para la interfaz: no sabe qué tipos quiere usar el cliente allí
• mensajería: la misma idea: dar flexibilidad al cliente
• análisis de archivos: para admitir cualquier tipo

Total

• std::any no es una clase de plantilla
• std::any utiliza la optimización de objetos pequeños, por lo que no asignará dinámicamente memoria para tipos tan simples como int o double, y para tipos más grandes, se usará memoria adicional
• std::any puede llamarse "pesado", pero ofrece seguridad y mayor flexibilidad
• El acceso a los datos std::anyse puede obtener con la ayuda de any_cast, que ofrece varios "modos". Por ejemplo, en caso de error, puede arrojar una excepción o simplemente devolver nullptr
• úselo cuando no sepa exactamente qué tipos de datos son posibles; de lo contrario, considere usar std::variant