时间戳

首页 > 解决方案 > 线程中的 C++ 方法。传递之间的区别：对象、对象的地址、对象的 std::ref

c++ - 线程中的 C++ 方法。传递之间的区别：对象、对象的地址、对象的 std::ref

问题描述

我正在尝试在 C++ 线程中执行对象的方法。

我可以通过将方法的地址和对象（或对象的地址，或 std::ref(my_obj)）传递给线程的构造函数来做到这一点。

我观察到，如果我传递对象，而不是对象的地址或 std::ref(my_obj)，那么对象会被复制两次（我在复制构造函数中打印一些信息以查看）。

这是代码：

class Warrior{
    string _name;
public:
    // constructor
    Warrior(string name): _name(name) {}

    // copy constructor (prints every time the object is copied)
    Warrior(const Warrior & other): _name("Copied " + other._name){
        cout << "Copying warrior: \"" << other._name;
        cout << "\" into : \"" << _name << "\"" << endl;
    }

    void attack(int damage){
        cout << _name << " is attacking for " << damage << "!" << endl;
    }
};

int main(){
    Warrior conan("Conan");

    // run conan.attack(5) in a separate thread
    thread t(&Warrior::attack, conan, 5);
    t.join(); // wait for thread to finish

}

在这种情况下我得到的输出是

Copying warrior: "Conan" into : "Copied Conan"
Copying warrior: "Copied Conan" into : "Copied Copied Conan"
Copied Copied Conan is attacking for 5!

如果我只是将&conanorstd::ref(conan)作为第二个参数传递给thread t(...)（而不是传递conan），则输出只是：

Conan is attacking for 5!

我有4个疑问：

  1. 为什么我有对象的 2 个副本而不是 1 个？

    我期待通过将对象的实例传递给线程的构造函数，对象将在线程自己的堆栈中复制一次，然后attack()在该副本上调用该方法。

  2. 线程的构造函数可以接受对象、地址或 的确切原因是std::ref什么？是否使用此版本的构造函数（我承认我不完全理解）

    template< class Function, class... Args > explicit thread( Function&& f, Args&&... args );

    在所有 3 种情况下？

  3. 如果我们排除第一种情况（因为它效率低下），我应该在&conanand之间使用什么std::ref(conan)？

  4. 这是否与所需的语法有关std::bind？

标签： c++multithreadingmethodscopy-constructorref

解决方案

为什么我有对象的 2 个副本而不是 1 个？

当你启动一个线程时，参数被复制到线程对象中。然后将这些参数复制到创建的实际线程中，因此您有两个副本。这就是为什么std::ref当您想要传递函数通过引用获取的参数时必须使用的原因。

线程的构造函数可以接受对象、地址或 std::ref 的确切原因是什么？是否使用此版本的构造函数（我承认我不完全理解）

std::thread基本上用一个调用来启动新线程

std::invoke(decay_copy(std::forward<Function>(f)), 
            decay_copy(std::forward<Args>(args))...);

std::invoke旨在处理所有不同类型的可调用对象，其中之一是当它具有成员函数指针和对象时，它会适当地调用该函数。它还知道std::reference_wrapper并且可以处理调用指向std::reference_wrapper对象的成员函数的指针。

如果我们排除第一种情况（因为它效率低下），我应该在&conanand之间使用什么std::ref(conan)？

这主要是基于意见。它们基本上都做同样的事情，尽管第一个版本写起来更短。

这是否与所需的语法有关std::bind？

有点儿。 std::bind的operator()也是使用实现的，std::invoke因此它们具有非常通用的接口。

所有这一切都表明您可以使用 lambda 为自己提供一个通用接口。

thread t(&Warrior::attack, conan, 5);

可以改写为

thread t([&](){ return conan.attack(5); });

您可以将此表单用于您想要调用的几乎任何其他功能。我发现看到 lambda 时更容易解析。

推荐阅读