模板参数演绎/替换在多线程处理中失败

Question

在传递函数时，我遇到了这个模板演绎/替换问题。有人可以帮忙吗，我非常感谢：

#include <iostream>
#include <vector>
#include <future>


template< class D > class Region
{

public:

  virtual bool                   setRegion( D& );

protected:


  int                            computeValue( int input, D& dataPack );
  template < class Fn > bool     setRegionValue( const int, D&, Fn&& );
  template < class Fn > bool     setAllValues( D&, Fn&& );

protected:

  std::vector< int >                  m_regionValues;
  std::vector< std::future< bool > >  m_futures;
};



template< class D > int Region< D >::computeValue( const int input,
                                                   D& dataPack )
{
  return input * dataPack.getData();
}


template< class D > 
template < class Fn > bool Region< D >::setRegionValue( const int input,
                                                        D& dataPack,
                                                        Fn&& function )
{
  int output = function( input, dataPack, output );
  m_regionValues.push_back( output * 2 );
  //check..
  return true;
}
  

template< class D > 
template< class Fn > bool Region< D >::setAllValues( D& dataPack,
                                                     Fn&& fn )
{
  for ( int indx = 0; indx < 10; ++indx )
  {
    int input = indx * 5;
    m_futures.push_back( std::async( std::launch::async,
                                     &Region::setRegionValue< std::remove_reference_t< Fn > >,
                                     this, input, std::ref( dataPack ),
                                     std::forward< Fn >( fn ) ) );
  }

  //check thread status..
  return true;
}


template< class D > bool Region< D >::setRegion( D& dataPack )
{
  auto func = std::bind( &Region::computeValue, this,
                         std::placeholders::_1, std::placeholders::_2 );
  
  return setAllValues( dataPack, func );
}


struct Region1Data
{
  int        m_regionData;
  int        getData() const;
};


int Region1Data::getData() const
{
  return m_regionData;
}
  

class Region1: public Region< Region1Data >
{
public:

  bool                         setRegion( Region1Data& );
  void                         outputValue();
};


void Region1::outputValue()
{
  //..
}


bool Region1::setRegion( Region1Data& dataPack )
{
  if ( !Region::setRegion( dataPack ) )
  {
    return false;
  }

  outputValue();
  return true;
}


int main()
{
  Region1 thisRegion;
  Region1Data dataPack;
  dataPack.m_regionData = 10;
  
  thisRegion.setRegion( dataPack );
  return 0;
}

以下是编译代码时的错误：

示例.cpp：在 'bool Region：：setAllValues（D） 的实例化中

Answer 1

setAllValues使用左值调用：

template< class D > bool Region< D >::setRegion( D& dataPack ) {
  auto func = std::bind( &Region::computeValue, this,
                         std::placeholders::_1, std::placeholders::_2 );

  return setAllValues( dataPack, func );         // func as named object is Lvalue
}

由于转发引用规则，< code>Fn被推导为< code>Fn

template< class D > 
template< class Fn > bool Region< D >::setAllValues( D& dataPack,
                                                     Fn&& fn )          // Fn is Fn& 

在下面

&Region::setRegionValue< std::remove_reference_t< Fn > >,
                        ^^^ you put explicitly type in template argument list 

删除Fn的引用性。因为您将setRealonValue的显式参数指定为Fn，所以它的第三个参数的类型是Fn

要将 Fn 作为 Lvalue 处理，您可以编写：

template< class D > 
template< class Fn > bool Region< D >::setAllValues( D& dataPack,
                                                     Fn&& fn ) {             // Fn& &&fn
  for ( int indx = 0; indx < 10; ++indx )
  {
    int input = indx * 5;
    m_futures.push_back( std::async( std::launch::async,
                                     &Region::setRegionValue< Fn >,          // <- here is Fn&
                                     this, input, std::ref( dataPack ),
                                     std::ref( fn ) ) );                     // <-
  }
  return true;
}

在以下情况下

工作版本 1

上述代码不处理将右值传递到＜code＞setAllValues＜/code＞中的情况。

如果你写道:

return setAllValues( dataPack, std::bind( &Region::computeValue, this,
                         std::placeholders::_1, std::placeholders::_2 ) );

setAllValues 的定义应该是：

template< class D > 
template< class Fn > bool Region< D >::setAllValues( D& dataPack,
                                                     Fn&& fn ) {
  for ( int indx = 0; indx < 10; ++indx )
  {
    int input = indx * 5;
    m_futures.push_back( std::async( std::launch::async,
                                     &Region::setRegionValue< Fn >,
                                     this, input, std::ref( dataPack ),
                                     std::forward<Fn>( fn ) ) );
  }
  return true;
}

其中fn作为临时转发。

工作版本2

很难在一次调用中容纳< code>std::ref(这是< code>std::async所必需的)和< code>std::forward，您可以进行两次重载:

template < class Fn > bool     setAllValues( D&, Fn&& );   // uses std::forward
template < class Fn > bool     setAllValues( D&, Fn& );    // uses std::ref

处理这两种情况。