我创建了两个类 cl1 和 cl2 并且 cl1 有一个带有 cl2& 参数的构造函数. 我有三个函数，一个以 cl1 为参数，一个以 cl1&& 为参数，一个以 cl1& 为参数。

#include <thread>
#include <iostream>

class cl1;
class cl2;


class cl2 {
public:
    int y;
    cl2(int y) : y(y)   {}                  //ctor
};

class cl1 {
public:
    int x;
    cl1(int x) : x(x) {}                 //ctor
    cl1(cl2& ob1) : x(ob1.y * 2) {}      //ctor for automatic conversion of cl2& to cl1, x = y*2
};

void do_work_with_cl(cl1 ob) {              //This works as usual by actually copying the object through the conversion constructor
    std::cout << "The x of ob is " << ob.x << std::endl;
}

void do_work_with_cl_rref(cl1&& ob) {       //I guess this works because it takes an rvalue and the automatic
                                            //conversion ctor of cl1 does just that
    std::cout <<"Inside the function that takes cl1 as rvalue, x of ob is"  << ob.x << std::endl;
}

void do_work_with_cl_lref(cl1& ob) {        //This doesn't work as ob is non-const lvalue reference
    std::cout << "lvalue referenced but the object created through implicit conversion is temporary(i.e rvalue)" << std::endl;
}   


int main() {
    //Normal non-threaded calls
    cl2 ob(100);                //create a cl2 object
    do_work_with_cl(ob);            //This is ok
    do_work_with_cl_rref(ob);   //This too works
    //do_work_with_cl_lref(ob)  //This fails, as suspected

    std::cout << "Thread part" << std::endl

    //Now calling the functions through a thread
    std::thread t1(do_work_with_cl_rref, ob);   //Thought this could work here, but doesn't
                                                //The other functions also don't work, but I can understand why.
    t1.join();                                              
}

在 ideone.com:http://ideone.com/MPZc4C ，正如我要问这个问题，这个例子有效。但是对于 g++-4.7，我得到一个错误，如:

In file included from /usr/include/c++/4.7/ratio:38:0,
             from /usr/include/c++/4.7/chrono:38,
             from /usr/include/c++/4.7/thread:38,
             from main.cpp:1:
/usr/include/c++/4.7/type_traits: In instantiation of ‘struct std::_Result_of_impl<false, false, void (*)(cl1&&), cl2>’:
/usr/include/c++/4.7/type_traits:1857:12:   required from ‘class std::result_of<void (*(cl2))(cl1&&)>’
/usr/include/c++/4.7/functional:1563:61:   required from ‘struct std::_Bind_simple<void (*(cl2))(cl1&&)>’
/usr/include/c++/4.7/thread:133:9:   required from ‘std::thread::thread(_Callable&&, _Args&& ...) [with _Callable = void (&)(cl1&&); _Args = {cl2&}]’
main.cpp:13:44:   required from here
/usr/include/c++/4.7/type_traits:1834:9: error: invalid initialization of reference of type     ‘cl1&&’ from expression of type ‘cl2’
make: *** [main.o] Error 1

我真的不知道这是否是实现或代码有问题。我只是在学习 C++ 中的线程和其他东西，所以我没有这样做的实际原因。请让我知道问题出在哪里，以及我在代码注释中是否正确。 (代码中的注释“This works...”意味着当从 main() 以对象作为参数(而不是对它的引用)调用它们时它们是好的。)

最佳答案

C++ 标准第 30.3.1.2/3 段说:

“要求:F 和 Args 中的每个 Ti 应满足 MoveConstructible 要求。INVOKE(DECAY_COPY(std::forward<F>(f)), DECAY_COPY(std::forward<Args>(args))...) (20.8.2) 应为有效表达式”。

表达式DECAY_COPY(x)又在 30.2.6 中定义:

“在本条款的几个地方使用了操作 DECAY_COPY(x)。所有这些使用都意味着调用函数 decay_copy(x) 并使用结果，其中 decay_copy 定义如下:”

template <class T> typename decay<T>::type decay_copy(T&& v)
{ return std::forward<T>(v); }

自 decay操作从对象中删除 cv 限定符，需要有一个普遍有效 类型的转换构造函数或转换运算符 cl1输入 cl2 .为了检查这一点，std::thread 的 cargo 机械显然生成对 cl1 的右值引用并尝试获取 c2 的实例从他们。这失败了，因为右值引用不能绑定(bind)到转换构造函数中的非常量左值引用。

如果您将构造函数的签名从 cl1(cl2& ob1) 更改为进入cl1(cl2 const& ob1)它适用于 GCC 4.7.2，因为右值引用可以绑定(bind)到左值引用 const .

关于c++ - 关于 std::thread 中的 C++ 自动类型转换行为，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/14364713/