C++ 如果我想对自定义类型使用tr1无序映射，如何避免在头中使用哈希函数impl？

我需要散列四种不同内容的组合，包括20个字节，正如我定义的：

struct holder
{
  char a;
  uint16_t b;
  uint64_t c;
  char d[9];
} __attribute((__packed__));

然后我可以加载上面的一个函数并将其传递给哈希函数。因此，我希望我的类

Foo

有一个

std:：tr1:：unordered_map

。但是为了声明在

Foo

的头文件中，我需要包含

holder

的定义，以及

std:：tr1

中针对我的类型的

hash

的模板专门化，结果是完整的hash函数。有没有办法不让所有这些代码都出现在头文件中，但仍然给我的类这个hashmap？

只需在头文件中声明函数，然后在cpp文件中定义它

这看起来像：

// Header
namespace std { namespace tr1

// Define specialization
template<>
struct hash<holder>: unary_function<holder, size_t> {
    // Declare member
    size_t operator()(holder const&) const;
};

} }

// Source

// Define member
std::size_t std::tr1::hash<holder>::operator()(holder const&) const
{ /* implementation */ }

//头
命名空间std{namespace tr1
//定义专门化
样板
结构哈希：一元函数{
//宣布成员
size_t运算符（）（holder const&）const；
};
} }
//来源
//定义成员
std:：size\u t std:：tr1:：hash:：operator（）（holder const&）const
{/*实现*/}

只需在头文件中声明函数，并在cpp文件中定义它

这看起来像：

// Header
namespace std { namespace tr1

// Define specialization
template<>
struct hash<holder>: unary_function<holder, size_t> {
    // Declare member
    size_t operator()(holder const&) const;
};

} }

// Source

// Define member
std::size_t std::tr1::hash<holder>::operator()(holder const&) const
{ /* implementation */ }

//头
命名空间std{namespace tr1
//定义专门化
样板
结构哈希：一元函数{
//宣布成员
size_t运算符（）（holder const&）const；
};
} }
//来源
//定义成员
std:：size\u t std:：tr1:：hash:：operator（）（holder const&）const
{/*实现*/}

hash for holder的专门化可以在您的头中，但实现不必如此。为了便于理解，它（专门化）可以简单地调用您在cpp文件中定义的holder上的bog标准函数。

holder的哈希专门化可以在您的头中，但实现不必如此。为了便于理解，它（专门化）可以简单地调用您在cpp文件中定义的holder上的bog标准函数。

也可以直接专门化

std:：tr1:：hash:：operator（）

，而无需专门化

std:：tr1:：hash

本身，但该函数采用

holder

，因此必须声明为

模板大小\u t hash:：operator（）（holder）const

。也可以直接专门化

std:：tr1:：hash:：operator（）

，而无需专门化

std:：tr1:：hash

本身，但该函数采用

holder

，因此必须声明为

模板大小\u t hash:：operator（）（holder）常量。