Given the following code
#include <iostream>
using namespace std;
template <typename Type>
struct Something {
Something() {
cout << "Something()" << endl;
}
template <typename SomethingType>
Something(SomethingType&&) {
cout << "Something(SomethingType&&)" << endl;
}
};
int main() {
Something<int> something_else{Something<int>{}};
auto something = Something<int>{};
Something<int>{something};
return 0;
}
I get the following output
Something()
Something()
Something(SomethingType&&)
Why is the copy constructor being resolved to the templated forwarding reference constructor but not the move constructor? I am guessing that it's because the move constructor was implicitly defined but not the copy constructor. But I am still confused after reading the cases for where the copy constructor is not implicitly defined in stack overflow.
No, both are implicitly defined for class
Something
.Because the copy constructor takes
const Something&
as its parameter. That means for the copy constructor to be called, implicit conversion is needed for addingconst
qualifier. But the forwarding reference constructor could be instantiated to takeSomething&
as its parameter, then it's an exact match and wins in the overload resolution.So if you make
something
const
, the implicitly defined copy constructor will be invoked for the 3rd case instead of the forwarding reference constructor.LIVE
Because for the move constructor the above issue doesn't matter. For the invocation of the 1st and 2nd case, both implicitly defined move constructor and forwarding reference constructor are exact match, then non-template move constructor wins.