有关的std :: thread类问题

Question

考虑下面的类的头：

class ThreadClass {
public:
  ThreadClass();
  ~ThreadClass();
  void operator()(int val);
  void set(int val);
  int get();
private:
  int x;
};

而下面的实现：

ThreadClass::ThreadClass(): x(0) {
  std::cout << "Constructing..." << std::endl;
}
ThreadClass::~ThreadClass() {
  std::cout << "Destructing..." << std::endl;
}
void ThreadClass::operator()(int val) {
  set(val);
  std::cout << get() << std::endl;
  set(val * 2);
  std::cout << get() << std::endl;
}
void ThreadClass::set(int val) {
  x = val;
}
int ThreadClass::get() {
  return x;
}

启动以下main，类析构函数被调用多次，而不是一个：

int main(int argc, char const *argv[]) {
  std::thread x = std::thread(ThreadClass(), 10);
  x.join();
  return 0;
}

>>> Constructing...
>>> Destructing...
>>> Destructing...
>>> 10
>>> 20
>>> Destructing...

由于我对std::thread类知识不是那么深，我想问你：

1. 为什么出现这种情况？真诚的，我期待ThreadClass的只是一个单一的实例。
2. 为了避免意外的行为，是否有必要重载一些类运营商的？

Answer 1

您正在调用，你还没有定义（但已经取得了你）隐含的构造函数。你可以看到他们在这里的行动：

#include <thread>
#include <iostream>

class ThreadClass {
public:
  ThreadClass() {
    std::cout << "Constructing..." << std::endl;
  }

  ThreadClass(const ThreadClass& t) {
    std::cout << "Copy constructing..." << std::endl;
    this->x = t.x;
  }

//   ThreadClass(ThreadClass&& t) {
//     std::cout << "Move constructing..." << std::endl;
//     this->x = t.x;
//   }

  ~ThreadClass() {
    std::cout << "Destructing..." << std::endl;
  }

  void operator()(int val) {
      set(val);
      std::cout << get() << std::endl;
      set(val * 2);
      std::cout << get() << std::endl;
  }
  void set(int val) {
      x = val;
  }
  int get() {
      return x;
  }
private:
  int x;
};

int main(int argc, char const *argv[]) {
  std::thread x = std::thread(ThreadClass(), 10);
  x.join();
  return 0;
}

输出：

构建...

复制构造...

复制构造...

解构...

解构...

10

20

解构...

如果你想看到在行动以及你可以取消移动的构造。

要直接回答你的问题：

为什么出现这种情况？真诚的，我期待ThreadClass的只是一个单一的实例。

这是因为你是在传递一个对象，所以在帖子中提到的额外的构造函数越来越多次调用。

为了避免意外的行为，是否有必要重载一些类运营商的？

你是什​​么意外的行为呢？这将执行C ++究竟如何打算。这是良好定义的行为的C ++。