Impossible de trouver un type défini par l'utilisateur dans un ensemble C ++ non commandé avec opérateur personnalisé == ()

Vous essayez de comparer les pointeurs, pas les valeurs. Vous devez spécifier la fonction de hachage pour la classe bloquer code>.

Par exemple, si vous souhaitez utiliser MNAME comme clé, le code sera le suivant: p>

class Block {
private:
    string mName;
    string mLib;
public:
    Block(string const& name, string const& lib)
    {
        mName = name;
        mLib = lib;
    }
    string getName() const {
        return mName;
    };
    string getLib() const {
        return mLib;
    }
    bool operator==(const Block & block) const;
};

template<> struct std::hash<Block> {
    std::size_t operator()(const Block & block) const noexcept {
        return std::hash<std::string>{}(block.getName());
    }
};

bool Block::operator==(const Block & block) const {
    return block.getName() == mName;
}

int main() {
    std::vector<Block> vertices;

    vertices.emplace_back(Block("mod1", "work"));
    vertices.emplace_back(Block("mod2", "work"));
    vertices.emplace_back(Block("mod3", "work"));

    std::unordered_set<Block> undefs;
    undefs.emplace(Block("mod1", "work"));
    undefs.emplace(Block("mod2", "work"));

    for (auto& vertex : vertices) {
        auto search = undefs.find(vertex);
        if (search != undefs.end()) {
            std::cout << "Block: " << vertex.getName() << "\n";
        }
    }
}

Le problème est que vous essayez de comparer les pointeurs, qui sont différents! Je sauverais les raisons de l'utilisation de l'unique_ptr <> mais en faisant que vous essayez réellement de comparer des identités, au lieu d'états qui sont ce que vous voulez.

Vous pouvez donc voir ce que je veux dire, disons que le premier objet de bloc est en position 100 dans votre mémoire. Ce serait son identité. Nous avons donc des objets1 dont l'état est "mod1, travail" et dont l'identité est 100. Nous avons l'objet2, dont l'identité est de 150 mais son état est identique à l'objet1, "mod1, travail".

Tout ce que vous avez à la fois à l'intérieur du vecteur et que les pointeurs sont des pointeurs, vous avez donc des positions de mémoire. Lorsque vous les insérez dans le vecteur, vous avez inséré, disons, positionnez 100. Mais dans le non-ordonné vous inséré 150. Ils ont le même état, mais la méthode de recherche est à la recherche d'une position de mémoire.

J'espère que ma réponse a été utile. Si vous trouvez des erreurs ici ou pensez différemment s'il vous plaît faites le moi savoir. Bonne chance! :)