std :: thread定义线程函数时的符号 [英] std::thread notation when defining the threaded function
问题描述
我明白 std :: thread rel =nofollow> here ,并转载如下:
I understand the std::thread
notation presented here and reproduced as follows
#include <iostream>
#include <utility>
#include <thread>
#include <chrono>
#include <functional>
#include <atomic>
void f1(int n)
{
for (int i = 0; i < 5; ++i) {
std::cout << "Thread " << n << " executing\n";
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
void f2(int& n)
{
for (int i = 0; i < 5; ++i) {
std::cout << "Thread 2 executing\n";
++n;
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
int main()
{
int n = 0;
std::thread t1; // t1 is not a thread
std::thread t2(f1, n + 1); // pass by value
std::thread t3(f2, std::ref(n)); // pass by reference
std::thread t4(std::move(t3)); // t4 is now running f2(). t3 is no longer a thread
t2.join();
t4.join();
std::cout << "Final value of n is " << n << '\n';
}
因为 f1
和 f2
在主
内,但无法理解
because the definition of f1
and f2
is within main
but fail to understand
#ifndef THREADED_H_
#define THREADED_H_
class Threadme
{
long count;
public:
Threadme();
void run(void);
void delay(long);
};
#endif
#include "threaded.h"
#include <iostream>
#include <chrono>
Threadme::Threadme() : count(0) {}
void Threadme::delay(long seconds)
{
std::chrono::steady_clock::time_point end_t = std::chrono::system_clock::now() + std::chrono::seconds(seconds);
while(std::chrono::system_clock::now() < end_t)
;
}
void Threadme::run(void)
{
while(count < 10)
{
++count;
std::cout << count << std::endl;
delay(1);
}
}
#include <cstdlib>
#include <thread>
#include "threaded.h"
int main(int argc, char *argv[]){
std::thread t1(&Threadme::run, Threadme());
t1.join();
return EXIT_SUCCESS;
}
特别是表达式 std :: thread t1 ; $
run
在之外 main
。为什么引用&
以及为什么线程参数
是一个构造函数调用?
specifically the expression std::thread t1(&Threadme::run, Threadme());
as it relates to defining the threaded function run
outside of main
. Why the reference &
and why the thread parameters
is a constructor invocation?
推荐答案
& Foo :: mem
其中 Foo
是一个类类型, Foo
的一个成员(函数或值)的 mem
是C ++表示法,成员(函数或值)。存在一个特殊的语法用于调用对象上的成员函数指针,但这通常通过使用 std :: mem_fun
来消除,它将成员函数指针转换为普通函数,其中第一个参数必须是成员函数取自的类型的对象。
&Foo::mem
where Foo
is a class type and mem
a member (function or value) of Foo
, is C++ notation for obtaining a pointer to a member (function or value). There exist a special syntax for invoking a member function pointer on an object, but this is usually sugared away by using std::mem_fun
, which will turn a member function pointer into an ordinary function where the first argument has to be an object of the type the member function was taken from.
std :: thread
了解这里发生的情况,并且正确地执行:对作为第二个参数传递的对象调用 Foo :: mem
。
std::thread
understands what is happening here and does exactly that: invoke Foo::mem
on the object passed as the second argument.
一个小例子可以在本地重现这个实例,而不实际涉及 std :: thread
:
A small example to reproduce this locally without actually involving std::thread
:
#include <functional>
class Foo { void mem() {} };
int main() {
Foo f;
f.mem(); // normal invoke
auto func = std::mem_fun(&Foo::mem);
func(std::ref(f)); // invoke mem on f
func(f); // invoke mem on a copy of f
func(&f); // invoke mem on f through a pointer
}
为什么我们不需要 std :: thread
时, mem_fun
它
通过重载自动检测这些情况,并且
自己正确的东西。
Why don't we need the mem_fun
when constructing std::thread
? It
automatically detects those situations through an overload and does
the right thing all by itself.
这篇关于std :: thread定义线程函数时的符号的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!