Compile error defining a std::hash for a template class nested class

Question

I have a class:

namespace App
{

template<typename A, typename B>
class MyClass
{
    //...
    class NestedClass
    {
        //...
    }
}

} //namespace App

I would like to define a std::hash for NestedClass

//Definition of hash functions
namespace std
{
    //Definition of a hash to use generic pairs as key
    template<typename A, typename B>
    struct hash<App::MyClass<A,B>::NestedClass>
    {
    public:
        size_t operator()(const App::MyClass<A,B>::NestedClass &it) const
        {
            return std::hash(it.toInt());
        }
    };
}

I get the error:

source.h:1166: error: type/value mismatch at argument 1 in template parameter list for 'template<class _Tp> struct std::hash'
  struct hash<App::MyClass<A,B>::const_NestedClass>
                                                  ^

Any idea? Thanks!

nestedclass is private? also: http://stackoverflow.com/help/mcve — xaxxon, Feb 10 '17 at 11:23
When naming a type defined by a templated type, you have to specify that it is a type with `typename`. Try `typename App::MyClass::NestedClass` instead. — François Andrieux, Feb 10 '17 at 11:26
@xaxxon If you write MCVE in square brackets you get this: [MCVE] — Jonas, Feb 10 '17 at 11:31

score 4 · Accepted Answer · edited May 23 '17 at 12:09

You can fix your error by adding typename where appropriate to inform the compiler that the symbol following :: is indeed a type:

template<typename A, typename B>
struct hash<typename App::MyClass<A, B>::NestedClass>
{//         ^^^^^^^^
public:
    size_t operator()(const typename App::MyClass<A,B>::NestedClass &it) const
//                          ^^^^^^^^
    {
        return hash(it.toInt());
    }
};

Now you get a new error:

prog.cc:22:12: error: class template partial specialization contains template parameters that cannot be deduced; this partial specialization will never be used [-Wunusable-partial-specialization]
    struct hash<typename App::MyClass<A, B>::NestedClass>
           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
prog.cc:21:23: note: non-deducible template parameter 'A'
    template<typename A, typename B>
                      ^
prog.cc:21:35: note: non-deducible template parameter 'B'
    template<typename A, typename B>

It is impossible for the compiler to deduce A and B in this context, as there's no guarantee that NestedClass exists for all MyClass<A, B> instantiations. More information:

You'll probably be able to work around this by assuming that NestedClass exists and hashing on MyClass<A, B> instead. Provide some way of accessing NestedClassfrom MyClass and you'll be able to write something like this:

template<typename A, typename B>
struct hash<typename App::MyClass<A, B>>
{
public:
    size_t operator()(const typename App::MyClass<A,B> &it) const
    {       
        return hash(it.nested.toInt());
    }
};

This is not applicable, as nested is not a simple member of the main class. It is a kind of persistent iterator used for navigating inside the main object — galinette, Feb 10 '17 at 11:42
OK, this means I cannot use NestedClass for a standard hash container directly, unless I fully specialize the main class. — galinette, Feb 10 '17 at 11:44
@galinette: can you move `NestedClass` outside of its parent class and templatize it over ``? — Vittorio Romeo, Feb 10 '17 at 11:51
@galinette Could you pass in the hasher as a template parameter to whatever container you're using? — TartanLlama, Feb 10 '17 at 13:47
@VittorioRomeo : this would do the job, it would be less pretty as the nested class is basically an iterator, but I'll do it as a workaround — galinette, Feb 10 '17 at 19:28

Compile error defining a std::hash for a template class nested class

1 Answers1