c++: error: no type named ‘type’ in ‘class std::result_of<void (*(std::unordered_map

Question

Following is just a simple program to test using two threads to insert a hash table. For test no lock is used.

#include <iostream>
#include <unordered_map>
#include <thread>

using namespace std;

void thread_add(unordered_map<int, int>& ht, int from, int to)
{
    for(int i = from; i <= to; ++i)
        ht.insert(unordered_map<int, int>::value_type(i, 0));
}

void test()
{
    unordered_map<int, int> ht;
    thread t[2];

    t[0] = thread(thread_add, ht, 0, 9);
    t[1] = thread(thread_add, ht, 10, 19);

    t[0].join();
    t[1].join();

    std::cout << "size: " << ht.size() << std::endl;
}

int main()
{
    test();
    return 0;
}

However, there are errors when compiling it.

$ g++ -std=c++11 -pthread test.cpp
...
/usr/include/c++/4.8.2/functional:1697:61: error: no type named ‘type’ in ‘class std::result_of<void (*(std::unordered_map<int, int>, int, int))(std::unordered_map<int, int>&, int, int)>’
       typedef typename result_of<_Callable(_Args...)>::type result_type;
...

Took a while but still cannot correct it. Thanks.

Answer 1

I could compile your code successfully with MSVC2013. However, thread() works passing copies of its argument to the new thread. This means that if your code would compile on your compiler, each thread wourd run with its own copy of ht , so that at the end, main 's ht would be empty.

GCC doesn't compile with this weird message. You can get rid of it by using the reference wraper with thread:

t[0] = thread(thread_add, std::ref(ht), 0, 9);
t[1] = thread(thread_add, std::ref(ht), 10, 19);

This will compile succesfully. And each reference used by the threads would refer to the same object.

However, there are high chances that you'll get some runtime error or unexpected results. This is because two threads are concurently trying to insert into ht . But unordered_map is not thread safe, so these racing conditions might cause ht to reach an unstable state (ie UB, ie potential segfault).

To make it running properly, you have to protect your concurent accesses:

#include <mutex>
...
mutex mtx;   // to protect against concurent access

void thread_add(unordered_map<int, int>& ht, int from, int to)
{
    for (int i = from; i <= to; ++i) {
        std::lock_guard<std::mutex> lck(mtx);  // protect statements until end of block agains concurent access
        ht.insert(unordered_map<int, int>::value_type(i, 0));
    }
}

Answer 2

The error is very cryptic indeed, but the problem is that thread_add takes its first parameter by reference, but you're passing it by value. This causes the functor type to be deduced wrong. If you want to pass something actually by reference to a functor like std::bind or the main function of a std::thread , you need to use a reference wrapper ( std::ref ):

void test()
{
    // ...

    t[0] = thread(thread_add, std::ref(ht), 0, 9);
    t[1] = thread(thread_add, std::ref(ht), 10, 19);

    // ...
}

[Live example]