std ::非无效函数的线程（C ++ 11）

Question

How can i get the return of the functions sent to the std::threads? I'm working ina function that apllies a filter, created to 2d Images, in each channel of an color/multispectral image. But many of the functions previously implemented in this library have an image as return, i tried to create a function that takes the return image as a parameter, but it didn't work. Here's a copy of the code:

template< class D, class A >
  template < typename... Args>
  void Image < D, A >::VoidFunction( Image< D, A > &out, Image < D, A > function ( const Image< D, A >& , Args ... ),
                     const Image <D, A > &in, Args... args ) {
    out = ( function ) ( in, args... );
    return ;
  }

  template< class D, class A >
  template < typename... Args>
  Image < D, A > Image < D, A >::multiSpecImgFilter( Image < D, A > function ( const Image<D, A>& , Args ... ),
                             const Image <D, A > &img, Args... args ) {   
    if ( img.Dims() != 3 ) {
      std::string msg( std::string( __FILE__ ) + ": " + std::to_string( __LINE__ ) + ": Image<D,A> " + "::" + 
               std::string( __FUNCTION__ ) + ": error: Image channels must have 2 dimensions" );
      throw( std::logic_error( msg ) );
    }
    std::vector< Image < D, A > > channel = img.Split( );  
    // std::vector< std::thread > threads ;
    // for( size_t thd = 0; thd < channel.size(); ++thd )
    //   threads[ thd ].join( );

    try {
      for ( int ch = 0; ch < channel.size() ; ch++ )
    std::thread thd ( &VoidFunction, channel[ch], function, channel[ch], args... );
    }
    catch( ... ) { 
      for ( int ch = 0; ch < img.size(2) ; ch++ )
        channel[ ch ] = ( function ) ( channel [ ch ], args... );
    }
    return ( Image< D, A >::Merge( channel, img.PixelSize().back(), img.Channel().back() ) );  
  }

Answer 1

You can use a lambda and store the result in it.

#include <iostream>
#include <thread>

int threadFunction()
{
    return 8;
}


int main()
{
    int retCode;
    //retCode is captured by ref to be sure the modifs are also in the main thread
    std::thread t([&retCode](){
        std::cout << "thread function\n";
        retCode=threadFunction();
    });
    std::cout << "main thread\n";//this will display 8
    t.join();//to avoid a crash
    return 0;
}

Answer 2

or pass by std::ref. This is an example from : https://www.acodersjourney.com/c11-multithreading-tutorial-via-faq-thread-management-basics/

#include <string>
#include <thread>
#include <iostream>
#include <functional>
using namespace std;
void ChangeCurrentMissileTarget(string& targetCity)
{
  targetCity = "Metropolis";
  cout << " Changing The Target City To " << targetCity << endl;
}
int main()
{
  string targetCity = "Star City";
  thread t1(ChangeCurrentMissileTarget, std::ref(targetCity));
  t1.join();
  cout << "Current Target City is " << targetCity << endl;
  return 0;
}

Answer 3

The canonical way of doing this, I suppose, is to use async .

#include <functional>
#include <future>
#include <iostream>

int main()
{
    auto result = std::async(std::launch::async, std::plus<>{}, 42, 42);
    std::cout << result.get() << "\n"; // outputs 84
}

( live demo )

I'd say this looks better than using an output parameter.

---

You can also directly use a packaged_task :

#include <functional>
#include <future>
#include <iostream>

int main()
{
    std::packaged_task<int(int, int)> task{std::plus<>{}};
    auto result = task.get_future();

    std::thread t{std::move(task), 42, 42};
    std::cout << result.get() << "\n"; // outputs 84

    t.join();
}

( live demo )