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类的了解不是很深，所以我想问你：

为什么会这样？真诚的，我只希望一个ThreadClass的实例。
为了避免意外的行为，是否有必要重载一些类运算符？

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 ++明确定义的行为。

关于std :: thread类的问题

1 个答案: