trouver un élément dans std :: vector de std :: any

Si les types sont int , float et string (ou un ensemble limité de types), vous pouvez utiliser une combinaison de std :: variant et std :: get_if pour réaliser ce que vous voulez faire de manière simple:

std :: get_if consiste à déterminer lequel des types est stocké dans le std::variant.

Un exemple minimal:

#include <iostream>
#include <vector>
#include <string>
#include <variant>

int main(){
    std::vector<std::variant<int, float, std::string>> temp;
    temp.emplace_back(std::string("A"));
    temp.emplace_back(10);
    temp.emplace_back(3.14f);     

    for (const auto& var: temp) {
      if(std::get_if<std::string>(&var)) { 
          if(std::get<std::string>(var) == "A") std::cout << "found string\n"; 
      }
      if(std::get_if<int>(&var)) { 
          if(std::get<int>(var) == 10) std::cout << "found int\n"; 
      }
      if(std::get_if<float>(&var)) { 
          if(std::get<float>(var) == 3.14f) std::cout << "found float\n"; 
      }
    }
}

Démo en direct

Malheureusement, si vous voulez trouver une instance std :: any dans un vecteur d'instances std :: any , la réponse est non.

std :: any a besoin d'un peu de "magie" par exemple pour pouvoir gérer la création de types d'objets inconnus mais cette machine est privée et ne doit prendre en charge que la création d'objet et non la comparaison d'égalité.

/ p>

Il serait possible d'implémenter ce que vous recherchez en utilisant la même approche, mais pas avec le standard std :: any qui ne publie pas les détails nécessaires. Le modèle "manager" doit énumérer toutes les opérations possibles et, par exemple, dans l'implémentation g ++, elles sont "access", "get_type_info", "clone", "destroy", "xfer".

variante est complètement différente, car elle répertorie explicitement tous les types autorisés et donc à tout endroit où elle est utilisée peut accéder à toutes les méthodes.

Utiliser un any dans ce genre de but n'est pas une bonne utilisation de any . La meilleure façon de procéder est simplement d'utiliser une variante - puisque vous avez un ensemble fermé de types:

using V = std::variant<int, float, std::string>
bool isItemPresentInAnyVector(std::vector<V> const& items, V const& item)
{
    return std::find(items.begin(), items.end(), item) != items.end();
}

En fait, c'est encore mieux, car comme le souligne Kilian, operator == code> fonctionne déjà exactement comme ceci:

struct Equals {
    template <typename T>
    constexpr bool operator()(T const& a, T const& b) const { return a == b; }

    template <typename T, typename U>
    constexpr bool operator()(T const& a, U const& b) const { return false; }
};

using V = std::variant<int, float, std::string>
bool isItemPresentInAnyVector(std::vector<V> const& items, V const& item)
{
    auto it = std::find_if(items.begin(), items.end(), [&](V const& elem){
        return std::visit(Equals{}, elem, item);
    });
    return it != items.end();
}