Question

我尝试将Movie对象插入unordered_set<Movie>容器，但是我收到一条错误消息，说没有这样的匹配成员函数。我做了类似的事情

void ActorGraph::addActor(string actor_name, string movie_title, int movie_year){
    unordered_map<string, unordered_set<ActorNode>>::iterator con_itr = connections.find(actor_name);
    ActorNode actor(actor_name);
    Movie movie(movie_title, movie_year);

    if(con_itr != connections.end()){
        auto adjSet = con_itr->second;
        unordered_set<ActorNode>::iterator act_itr = adjSet.find(actor);
        if(act_itr != adjSet.end()){
            //in the set
            auto mov_itr = act_itr->movies.find(movie);
            if( mov_itr == act_itr->movies.end()){
                act_itr->movies.insert(movie) //no matching function, while act_itr->movies is of type unordered_set<Movie>
            }
        }
    }else{
        unordered_set<ActorNode> adjSet;
        actor.movies.insert(movie);
        adjSet.insert(actor);
        connections[actor_name] = adjSet;
        cout << "The size is: " << actor.movies.size() << endl;
    }
}

我的ActorNode是一个看起来像这样的结构

struct ActorNode{
    //the name of the actor/actress
    string name;

    /** the movie that this actor/actree participated in
     */
    unordered_set<Movie> movies;

    ActorNode(string n) : name(n){}

    bool operator ==(const ActorNode &other) const;
};


namespace std
{
    template <>
    struct hash<ActorNode>
    {
        size_t operator()(const ActorNode& actor) const
        {
            return hash<std::string>{}(actor.name);
        }
    };
}

电影结构

#ifndef Movie_h
#define Movie_h

#include <iostream>
using namespace std;

struct Movie{
    string name;
    int year;
    Movie(string n, int y): name(n), year(y){}
    bool operator ==(const Movie &m) const;
};



namespace std
{
    template <>
    struct hash<Movie>
    {
        size_t operator()(const Movie& movie) const
        {
            return hash<std::string>{}(movie.name + to_string(movie.year));
        }
    };
}


#endif /* Movie_ph*/

我已经实现并覆盖了运算符，并使我的Movie和ActorNode结构兼容，以便在unordered_set的密钥中使用

这是存储库： Repo

Minimal Reproduction Example

#include <iostream>
#include <string>
#include <unordered_set>

struct Movie{
    std::string name;
    int year;

    Movie(std::string n, int y): name(std::move(n)), year(y)
    {
    }

    bool operator ==(const Movie &m) const
    {
        return year == m.year && name == m.name;
    };
};


namespace std
{
    template <>
    struct hash<Movie>
    {
        size_t operator()(const Movie& movie) const
        {
            return hash<std::string>{}(movie.name + to_string(movie.year));
        }
    };
}
////////////////////

struct ActorNode
{
    std::string name;
    std::unordered_set<Movie> movies;

    ActorNode(std::string n) : name(std::move(n))
    {
    }

    bool operator ==(const ActorNode &other) const
    {
        return name == other.name;
    }
};


namespace std
{
    template <>
    struct hash<ActorNode>
    {
        size_t operator()(const ActorNode& actor) const
        {
            return hash<std::string>{}(actor.name);
        }
    };
}
////////////////////


int main()
{
    std::unordered_set<ActorNode> actors;
    actors.emplace("Gene Wilder");

    auto itr = actors.find(ActorNode("Gene Wilder"));
    if (itr != actors.end())
    {
        // error: no matching function for call to                  
        //  'std::unordered_set<Movie>::insert(Movie) const'
        itr->movies.insert(Movie("Stir Crazy", 1980)); 
    }
}

Answer 1

问题是您无法修改set的密钥，因为它可能导致set重建，但set将不会被重建，因为您只修改变量，没有别的。所以，它是明确禁止的。

unordered_set

中迭代器的定义

iterator    Constant ForwardIterator
const_iterator  Constant forward iterator

在unordered_set上没有匹配的成员插入

1 个答案: