Question

我有一个Person类，它有一个name属性（std::string）。

我想创建一个查找表std::unordered_map，因此我可以按名称找到Person。但是，考虑到Person，我也希望能够得到他们的名字。

这需要存储name两次 - 一次作为地图的关键字，一次存放在人物对象内，如下面的代码所示。

由于我有很多Person一次加载到内存中，我不希望两次存储其名称的开销。

我尝试在Person类中使用对键的引用/指针，但这会产生问题，因为映射似乎在修改时重新调整其数据，并且引用变为无效。

我也尝试使用std::unordered_set，但这意味着每次我想要执行查找时都需要构造一个完整的Person对象。

无序地图的密钥和值是否有任何方法可以共享相同的数据？

#include <iostream>
#include <unordered_map>


class Person
{
    private:
        const std::string _name;

    public:
        Person( const std::string& name ) : _name( name )
        {
        }


        const std::string& get_name() const
        {
            return _name;
        }
};


int main()
{
    auto my_set = std::unordered_map<std::string, std::shared_ptr<Person>>();

    my_set.insert( { "alice", std::shared_ptr<Person>( new Person( "alice" )) } );
    my_set.insert( { "bob", std::shared_ptr<Person>( new Person( "bob" )) } );
    my_set.insert( { "charlie", std::shared_ptr<Person>( new Person( "charlie" )) } );

    std::cout << my_set.find( "bob" )->second->get_name() << std::endl;

    return 0;
}

Answer 1

您可以使用Boost.Multi-index来实现此目的。虽然这个库有一个学习曲线，但你会发现它非常快速。所以对于你的情况：

namespace mpi = boost::multi_index;
boost::multi_index_container<
        Person,
        mpi::indexed_by<
           mpi::hashed_unique< mpi::const_mem_fun< Person, const std::string &, &Person::get_name > >
        >
> my_set;

现在您可以将它用作带有字符串键的散列集：

auto f = my_set.find( "bob" );
if( f != my_set.end() )
    std::cout << f->get_name() << std::endl;

这可能看起来有点矫枉过正，但是当您开始向类Person添加更多成员时，您将看到此库的全部功能，您将需要提供不同的索引来访问该成员。假设您添加了一个也是唯一的电话号码（方法const std::string &get_phone() const）：

boost::multi_index_container<
        Person,
        mpi::indexed_by<
           mpi::hashed_unique< mpi::const_mem_fun< Person, const std::string &, &Person::get_name >,
           mpi::hashed_unique< mpi::const_mem_fun< Person, const std::string &, &Person::get_phone >>
        >
> my_set;

// lookup by phone:

const auto &idx = boost::get<1>( my_set );
auto f = idx.find( "1234567890" );
if( f != my_set.end() )
    std::cout << f->get_name() << std::endl;

注意：您可以将存储的数据更改为共享指针，而不是按值存储，我只是省略了它，例如简单。

Answer 2

如果你的人是＆＃34;永远不会复制或移动它们，并且永远不会复制或移动它们的名称，您可以使用指向string而不是string的指针作为您的密钥。这需要使用自定义hash和equal仿函数。

struct myhash
{
    unsigned operator()(std::string* s) const
    {
        return std::hash<std::string>()(*s);
    }
};

struct myequal
{
    unsigned operator()(std::string* s1, std::string* s2) const
    {
        return *s1 == *s2;
    }
};
...
auto my_set = std::unordered_map<std::string*, std::shared_ptr<Person>, myhash, myequal>();

这也使查找变得复杂：你必须查找指向string的指针。

std::string b = "bob";
std::cout << my_set.find(&b)->second->get_name() << std::endl;

此处不可能将字符串bob内联，因为您的代码必须获取指向它的指针。

Answer 3

使用std::set，您可以使用透明比较器（std::unordered_set似乎不支持：/）：

struct LessPerson
{
    using is_transparent = void; // enable "transparent" comparer

    template <typename T1, typename T2>
    bool operator ()(const T1& t1, const T2& t2) const
    {
        // Compare only "name".
        return toString(t1) < toString(t2);
    }

    // trivial one
    const std::string& toString(const std::string& s) const
    {
        return s;
    }

    // the one why we create the class
    const std::string& toString(const Person& p) const
    {
        return p.get_name();
    }

    // A tricky one to handle dereference of (smart) pointers.
    template <typename T,
              std::enable_if_t<std::is_same<Person, std::decay_t<decltype(*std::declval<T>())>>::value>* = nullptr>
    const std::string& toString(const T& p) const
    {
        return (*p).get_name();
    }

};

然后使用它：

auto my_set = std::set<std::shared_ptr<Person>, LessPerson>();

my_set.insert( { std::make_shared<Person>("alice") } );
my_set.insert( { std::make_shared<Person>("bob") } );
my_set.insert( { std::make_shared<Person>("charlie") } );

auto it = my_set.find("bob"); // search using "bob" directly without creating a new Person

Demo

Answer 4

如果你真的在努力记忆，你应该使用boost::flat_set。它具有非常低的内存开销，唯一的问题是，如果你更新你的一组人，它具有可怕的性能。如果您只是创建并且从不修改它，性能会比unordered_更差，但并不可怕。

如果您坚持使用unordered_map，我认为您需要使用unordered_multiset，因为我认为您的班级只使用一个字段来确定2个实例是否相等是没有意义的。这是可能的，但是very ugly，您需要定义自己的散列和相等函数。

另一个更简单但更容易出错的解决方案是使用hash作为这样的键：

#include <string>
#include <iostream>
#include <unordered_map>

class Person {

public:
    Person(const std::string& name, const int age) : name_(name), age_(age) {}
public:
    const std::string& name() const { return name_; }
    int age() const { return age_; }
private:
    std::string name_;
    int age_;
};

int main()
{
    Person p1("Joe", 11), p2("Jane", 22), p3("James", 33), p4("Joe", 44);
    std::unordered_multimap<size_t, Person> persons{ {std::hash<std::string>()(p1.name()), p1}, {std::hash<std::string>()(p2.name()), p2},{std::hash<std::string>()(p3.name()), p3}, {std::hash<std::string>()(p4.name()), p4} };
    auto potential_joes = persons.equal_range(std::hash<std::string>()("Joe"));
    for (auto it = potential_joes.first; it != potential_joes.second; ++it) {
        if (it->second.name() == "Joe") {
            std::cout << it->second.name() << " is " << it->second.age() << " years old" << std::endl;
        }
    }
}

我只会在你的字符串很长的情况下使用它，你实际上测量了内存使用情况，并且你对编写自定义比较器感到不舒服。正如您从代码中看到的那样，您自己重新实现了很多unordred_map逻辑，并且很容易搞砸。

重要提示 如果您的密钥取决于您在地图中的值，则必须确保不要修改值。例如，在我发布的代码中，您应该成员name_ const并评论为什么const。

`std :: unordered_map`没有复制关键数据

4 个答案: