5

我有一个Baz包含嵌套类的模板类Sub。我想通过专门化 std::hash 为这个子类定义一个哈希函数。但是，它似乎不起作用。

#include <functional>

struct Foo {
    struct Sub {
    };
};

template <class T>
struct Bar {
};

template <class T>
struct Baz {
    struct Sub {
        int x;
    };
};

// declare hash for Foo::Sub - all right
namespace std {
    template <>
    struct hash< Foo::Sub >;
}

// declare hash for Bar<T> - all right
namespace std {
    template <class T>
    struct hash< Bar<T> >;
}

// declare hash function for Baz<T>::Sub - doesn't work!
namespace std {
    template <class T>
    struct hash< Baz<T>::Sub >;
}

// Adding typename produces a different error.
namespace std {
    template <class T>
    struct hash< typename Baz<T>::Sub >;
}

Gcc 4.5.3 抱怨：

$ g++ -std=c++0x -c hash.cpp
hash.cpp:34:30: error: type/value mismatch at argument 1 in template parameter list for ‘template<class _Tp> struct std::hash’
hash.cpp:34:30: error:   expected a type, got ‘Baz<T>::Sub’
hash.cpp:40:12: error: template parameters not used in partial specialization:
hash.cpp:40:12: error:         ‘T’

更新

我真正想做的是实现一个容器，它支持对其中元素的稳定引用（不是 C++ 意义上的）。我希望允许用户将这些引用插入到std::unordered_set类似内容中，并使用它们来有效地访问或修改现有元素。以下只是一个模型，而不是我正在实现的确切容器。问题在于为引用类型定义哈希函数。

template <class T>
class Container {
public:
    class Reference {
    public:
        // operator==, operator!=, operator< ...., isNull()
    private:
        size_t index; // index into m_entries (or could be anything else)
        // possibly more stuff
    };

    Reference insert (const T &value);
    Reference find (const T &value);
    void remove (Reference r);
    Reference first ();
    Reference next (Reference prev);

private:
    struct Entry { T value, ... };

    std::vector<Entry> m_entries;
};
4

3 回答 3

4

Just pull the Reference class out of Container.

template <class Container>
class Reference {
public:
    typedef typename Container::value_type value_type; // etc...

    // operator==, operator!=, operator< ...., isNull()
private:
    size_t index; // index into m_entries (or could be anything else)
    // possibly more stuff
};

template <class T>
class Container {
public:
    typedef ::Reference<Container> Reference;
    friend class Reference; // If you cannot help it

    typedef T value_type;

    Reference insert (const T &value);
    Reference find (const T &value);
    void remove (Reference r);
    Reference first ();
    Reference next (Reference prev);

private:
    struct Entry { T value, ... };

    std::vector<Entry> m_entries;
};

Specialize like this:

namespace std {
    template <typename Container>
    struct hash<Reference<Container>>;
}
于 2012-05-06T00:15:45.593 回答
2

这个问题的答案是，你想要做的事情根本不可能做到。编译器无法确定哪个外部类包含子类型。考虑原因：

struct outer1 { typedef int Sub; };
struct outer2 { typedef int Sub; };

编译器在获得 Sub 时应该如何确定您想要哪个外部？这不可以。没有办法让这个工作。

在您的情况下，虽然非常困难，但可能很可能导出 IFF Sub 依赖于 T。但这需要编译器知道 Sub 来自哪里，而它只是不知道。

所以你根本无法做到这一点。没办法，没办法。

如果您需要一些通用方法来为您的类型查找哈希函数，那么您需要创建一个元函数 get_hash。默认情况下，它可以查找“hash_type”内部类型定义，并被标准哈希覆盖。打字多...

或者，将 Sub 作为其自己的模板从包含类中取出，并在那里使用 typedef 而不是内部类。然后你可以在你的模板上专门散列。

否则，只需将您知道所需的哈希值提供给您正在使用的模板的哈希函数参数。

于 2012-05-05T23:28:51.793 回答
0

您不能将模板专门用于这样的依赖类型。我会尝试这样的事情。

struct yes {};

template <typename T>
yes accept_baz_sub(typename Baz<T>::Sub&&);
void accept_baz_sub(...);

template <class T>
struct is_baz_sub : std::is_same<decltype(accept_baz_sub(std::declval<T>())), yes>
{};

template <typename BazSub>
using CheckedBazSub = typename std::enable_if<is_baz_sub<BazSub>::value, BazSub>::type;

namespace std {
    template <class BazSub>
    struct hash<CheckedBazSub<BazSub>>;
}

编辑：这不太有效，根据 [temp.alias] §14.5.7.2 永远不会推断出别名模板名称。

另一种解决方案是编写自己的哈希函数对象并让容器使用它（std::unordered_map例如第三个模板参数）。

于 2012-05-05T23:09:57.073 回答