std::mutex 和 condition_variable 无法访问类内的私有成员

我已经做了一些谷歌搜索，并在堆栈溢出上看到了关于这个问题的类似问题，但很难理解处理它的原因/解决方案。给定在 ThreadPool.hpp 中声明的以下类，我收到以下 2 个错误：

无法访问在类"std：：mutex"中声明的私有成员 C：\用户\jesse\文档\学校\夏季学期 2012\并发处理\项目 2\ultra_grep v2\ultra_grep\threadpool.hpp 39 1 ultra_grep2

2 错误 C2248："std：：condition_variable：：condition_variable"：无法访问类"std：：condition_variable"中声明的私有成员 C：\用户\杰西\文档\学校\2012 年夏季学期\并发处理\项目 2\ultra_grep v2\ultra_grep\threadpool.hpp 39 1 ultra_grep2

class ThreadPool
{
private:
std::queue<std::string> _consoleTasks;
std::queue<std::tr2::sys::path> _tasks;
std::map<std::string, std::vector<GrepMatch>> _grepMatches;
int _nThreads, _fileMatches, _totalMatches, _workingThreads;
std::vector<thread> _threads;
Arguments _args;
std::mutex _taskMutex, _wakeMutex, _consoleMutex, _threadCountMutex;
std::condition_variable _wakeCondition;
public:
ThreadPool( int threads, Arguments args );
~ThreadPool() {};
void GrepFunc();
void ConsoleFunc();
void SearchFile( std::string );
void SearchFileVerbose( std::string );
void DisplayGrepResults();
queue<std::tr2::sys::path> Tasks() { return _tasks; }
};

以及 ThreadPool 内部实现的代码.cpp：

#include "ThreadPool.hpp"
using namespace std;
namespace fs = std::tr2::sys;
ThreadPool::ThreadPool( int threads, Arguments args )
: _nThreads( threads ), _args( args ), _fileMatches( 0 ), _totalMatches( 0 ), _workingThreads( 0 )
{
for( int i = 0; i < _nThreads; ++i )
{
        _threads.push_back( thread( &ThreadPool::GrepFunc, this ) );
        _tasks.push( args.root() );
        ++_workingThreads;
        _wakeCondition.notify_one();
}
for( auto& t : _threads )
{
    t.join();
}
DisplayGrepResults();
}
void ThreadPool::GrepFunc()
{
// implement a barrier()
while( !_workingThreads )
{
    { unique_lock<mutex> lk( _wakeMutex );
    _wakeCondition.wait( lk ); }
    while( !_tasks.empty() )
    {
        fs::path task;
        bool gotTask = false;
        {
            lock_guard<mutex> tl( _taskMutex );
            if( !_tasks.empty() )
            {
                { lock_guard<mutex> tc( _threadCountMutex );
                ++_workingThreads; }
                task = _tasks.front();
                _tasks.pop();
                gotTask = true;
            }
        }
        if( gotTask )
        {
            if( fs::is_directory( task ) )
            {
                for( fs::directory_iterator dirIter( task ), endIter; dirIter != endIter; ++dirIter )
                {
                    if( fs::is_directory( dirIter->path() ) )
                    {
                        { lock_guard<mutex> tl( _taskMutex );
                        _tasks.push( dirIter->path() ); }
                        _wakeCondition.notify_one();
                    }
                    else
                    {
                        for( auto& e : _args.extensions() )
                        {
                            if( !dirIter->path().extension().compare( e ) )
                            {
                                { lock_guard<mutex> tl( _taskMutex );
                                _tasks.push( dirIter->path() ); }
                                _wakeCondition.notify_one();
                                //SearchFile( dirIter->path() );
                            }
                        }
                    }
                }
            }
            else
            {
                for( auto& e : _args.extensions() )
                {
                    if( !task.extension().compare( e ) )
                    {
                        if( _args.is_verbose() )
                            SearchFile( task );
                        else
                            SearchFileVerbose( task );
                    }
                }
            }
            { lock_guard<mutex> tc( _threadCountMutex) ;
            --_workingThreads; }
        }
    }
}
}
void ThreadPool::SearchFileVerbose( string path )
{
fstream file;
file.open( path );
if( !file )
{
    // error handling
}
else
{
    { 
        lock_guard<mutex> cm( _consoleMutex );
        cout << "nGrepping: " << path << endl;
        int lineNumber = 1;
        string line;
        vector<GrepMatch> matches;
        while( getline( file, line ) )
        {
            int lineMatches = 0;
            sregex_token_iterator end;
            for (sregex_token_iterator i(line.cbegin(), line.cend(), _args.regular_expression() );
                i != end;
                ++i)
            {
                ++lineMatches;
            }
            if( lineMatches > 0 )
            {
                GrepMatch match = GrepMatch( lineNumber, lineMatches, line );
                matches.push_back( match );
                cout << "Matched " << lineMatches << ": " << path << " [" << lineNumber << "] " << line << endl; 
            }
            ++lineNumber;
        }
        if( !matches.empty() )
        {
            _grepMatches[ path ] = matches;
        }
    }
}
}

我在互斥锁和condition_variable上都收到错误，说它们无法访问类内声明的私有成员。我的理解是，这是指复制构造函数？虽然我不明白为什么会发挥作用，因为我看不出我在哪里尝试复制，因为他们只是班级的私人成员。

根据最初的评论，我只实例化了 ThreadPool 的一个实例，它不会复制到任何地方。我唯一一次尝试接触互斥体是在我类的.cpp实现中。

谁能帮助我更好地了解为什么会发生这种情况？

对于那些感兴趣的人，这里是编译器输出：

1>------ Build started: Project: ultra_grep2, Configuration: Debug Win32 ------
1>  ultra_grep_main.cpp
1>  Unknown compiler version - please run the configure tests and report the results
1>c:usersjessedocumentsschoolsummer semester 2012concurrent processingproject 2ultra_grep v2ultra_grepthreadpool.hpp(39): error C2248: 'std::mutex::mutex' : cannot access private member declared in class 'std::mutex'
1>          c:program files (x86)microsoft visual studio 11.0vcincludemutex(116) : see declaration of 'std::mutex::mutex'
1>          c:program files (x86)microsoft visual studio 11.0vcincludemutex(107) : see declaration of 'std::mutex'
1>          This diagnostic occurred in the compiler generated function 'ThreadPool::ThreadPool(const ThreadPool &)'
1>          c:program files (x86)microsoft visual studio 11.0vcincludemutex(116) : see declaration of 'std::mutex::mutex'
1>          c:program files (x86)microsoft visual studio 11.0vcincludemutex(107) : see declaration of 'std::mutex'
1>          c:program files (x86)microsoft visual studio 11.0vcincludemutex(116) : see declaration of 'std::mutex::mutex'
1>          c:program files (x86)microsoft visual studio 11.0vcincludemutex(107) : see declaration of 'std::mutex'
1>          c:program files (x86)microsoft visual studio 11.0vcincludemutex(116) : see declaration of 'std::mutex::mutex'
1>          c:program files (x86)microsoft visual studio 11.0vcincludemutex(107) : see declaration of 'std::mutex'
1>c:usersjessedocumentsschoolsummer semester 2012concurrent processingproject 2ultra_grep v2ultra_grepthreadpool.hpp(39): error C2248: 'std::condition_variable::condition_variable' : cannot access private member declared in class 'std::condition_variable'
1>          c:program files (x86)microsoft visual studio 11.0vcincludecondition_variable(45) : see declaration of 'std::condition_variable::condition_variable'
1>          c:program files (x86)microsoft visual studio 11.0vcincludecondition_variable(30) : see declaration of 'std::condition_variable'
1>          This diagnostic occurred in the compiler generated function 'ThreadPool::ThreadPool(const ThreadPool &)'
1>  ThreadPool.cpp
1>  Generating Code...
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========