¿Cuándo debo usar std::any?

Desde C++17 std::any es presentado. Ahora se puede escribir código como este

#include <iostream>
#include <any>
#include <string>

int main () {
    const double d = 1.2;
    std::any var = d;
    const std::string str = "Hello World";
    var = str;
}

Se asigna un doble a la variable. var y que un std::string le fue asignado.

¿Por qué tiene std::any sido introducido?

Creo que esto está violando la least astonishment ruleporque me resulta difícil pensar en una situación, donde esto se puede utilizar para expresar más claramente, lo que me gusta expresar.

¿Puede alguien darme un buen ejemplo, cuando std::any es beneficioso

https://gcc.godbolt.org/z/-kepOD

Cuándo usar

void* como un patrón extremadamente inseguro con algunos casos de uso limitados, std::any agrega seguridad de tipo, y es por eso que tiene algunos casos de uso reales.

Algunas posibilidades:

• En bibliotecas: cuando un tipo de biblioteca tiene que contener o pasar algo sin conocer el conjunto de tipos disponibles.
• Análisis de archivos: si realmente no puede especificar cuáles son los tipos admitidos.
• Paso de mensajes.
• Enlaces con un lenguaje de scripting.
• Implementación de un intérprete para un lenguaje de secuencias de comandos
• Interfaz de usuario: los controles pueden contener cualquier cosa
• Entidades en un editor
  (árbitro)

Lo resumiría como el clásico “úsalo cuando no puedas evitarlo”.

Solo puedo pensar en implementaciones no críticas para el rendimiento de lenguajes de secuencias de comandos tipificados dinámicamente para representar variables del mundo de las secuencias de comandos, pero incluso eso con un tramo (Boost.Spirit/ejemplo/qi/compiler_tutorial lo hace sin, tanto para el analizador como para el tiempo de ejecución).

Para todo lo demás de los analizadores (por ejemplo, Impulsar.Espíritu.X3) a las API de la biblioteca (p. ej. ASIO) normalmente habría una alternativa más rápida/mejor/más específica, ya que muy pocas cosas son realmente “cualquier cosa”, la mayoría son más específicas que eso.

• std::variant y/o std::optional por “casi cualquier valor”
• std::packaged_task / std::function + lambdas para “devolución de llamada con argumentos”, que sería un caso de void* en las API de C.
• etc.

Específicamente, no lo conectaría a ciegas como reemplazo de un void*ya que puede asignar memoria en el montón, lo que puede ser mortal para el código de alto rendimiento.

std::any es un vocabulario tipo. Cuando necesite almacenar, bueno, un poco de cualquier cosa, como valor, puede usarlo.

Hay una serie de usos de “primer nivel”:

1. Al interactuar con lenguajes de secuencias de comandos que tienen tales tipos, es un ajuste natural.

2. Cuando tienes un árbol de propiedades con un contenido altamente polimórfico, y la estructura del árbol está desvinculada del productor y el consumidor del árbol.

3. Al reemplazar el equivalente de un void* fragmento de datos que pasa a través de una capa intermedia a la que realmente no le importa lo que transporta.

También se puede utilizar como bloque de construcción en otros casos. Por ejemplo, std::function podría optar por almacenar su valor en el std::any:

template<class R, class...Args>
struct func<R(Args...)> {
  mutable std::any state;
  R(*f)(std::any& state, Args&&...) = nullptr;
  template<class T>
  void bind(T&& t) {
    state = std::forward<T>
    f = [](std::any& state, Args&&...args)->R {
      return std::any_cast<T&>(state)(std::forward<Args>(args)...);
    };
  }
  R operator()(Args...args)const {
    return f(state, std::forward<Args>(args)...);
  }
};

esa es una implementación bastante pequeña de (la mayoría de) std::function. Básicamente he usado any para escribir borrar copiar/mover/destruir.

Puede usar esto en otros lugares para problemas similares (donde está escribiendo borrando alguna operación y también quiere escribir borrar copiar/mover/destruir), o generalizarlo.

Se utiliza en Wt para proporcionar una interfaz sin plantilla para datos tabulados.

Hay conversiones a cadena para tipos incorporados y Wt, y puede registrar conversiones adicionales al especializarse Wt::any_traits. Esto permite que cualquier cosa se muestre como una entrada en una tabla, las clases de vista no tienen que saber nada sobre los tipos que están mostrando.