Tudo o que você precisa saber sobre std :: any

O básico

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

Quando usar?

• Nas bibliotecas - quando sua biblioteca precisa armazenar ou transferir alguns dados e você não sabe de que tipo esses dados podem ser
• Ao analisar arquivos - se você realmente não pode determinar quais tipos são suportados
• Mensagens
• Interação com a linguagem de script
• Criando um intérprete para uma linguagem de script
• Interface do usuário - os campos podem armazenar qualquer coisa

Criar std :: any

• inicialização padrão - o objeto está vazio
• inicialização direta com valor / objeto
• indicando diretamente o tipo de objeto - std::in_place_type
• através da 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");

Alterar valor

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 do objeto

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

MyType::MyType
MyType::~MyType
100

Obtendo acesso a um valor

• retornar uma cópia do valor e sair std::bad_any_castpor erro
• retornar um link para o valor e sair std::bad_any_cast por erro
• retornar um ponteiro para um valor (constante ou não) ou nullptr no caso de um erro

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

Desempenho e uso de memória

As implementações devem evitar o uso de memória alocada dinamicamente para um pequeno valor contido. Exemplo: onde o objeto construído está mantendo apenas um int. Essa otimização de objetos pequenos deve ser aplicada apenas aos tipos T para os quais is_nothrow_move_constructible_v é verdadeiro

Uma implementação deve evitar o uso de memória dinâmica para dados armazenados de tamanho pequeno. Por exemplo, quando um objeto é criado, armazenando apenas int. Essa otimização para objetos pequenos deve ser aplicada apenas aos tipos T para os quais is_nothrow_move_constructible_v é verdadeiro.

Migrando do impulso :: any

Exemplos de uso de std :: any

Análise de arquivo

Mensagens

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

Propriedades

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

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

typedef std::vector<property> properties;

Nós atravessamos as fronteiras

A conclusão é que std :: any permite transferir direitos a dados arbitrários através de fronteiras que não sabem sobre seu tipo.

• na biblioteca da interface: você não sabe quais tipos o cliente deseja usar lá
• mensagens: a mesma idéia - dê flexibilidade ao cliente
• análise de arquivo: para suportar qualquer tipo

Total

• std::any não é uma classe de modelo
• std::any usa otimização de objetos pequenos, para que não aloque dinamicamente memória para tipos simples como int ou double, e para tipos maiores, será usada memória adicional
• std::any pode ser chamado de "pesado", mas oferece segurança e maior flexibilidade
• O acesso aos dados std::anypode ser obtido com a ajuda de any_cast, que oferece vários "modos". Por exemplo, em caso de erro, ele pode gerar uma exceção ou simplesmente retornar nullptr
• use-o quando não souber exatamente quais tipos de dados são possíveis; caso contrário, considere usar std::variant