C
Chris Fairles
Take the following snip (pretend A its a std:air if you wish )
template <class T1,class T2>
struct A {
A(A const&){cout<<"A(const&) ";}
A(A&&){cout<<"A(A&&) ";}
A(T1 const&, T2 const&){cout<<"A(T1,T2) ";}
template<class U1, class U2>
A(A<U1,U2> &&) {cout<<"A(A<U1,U2>&&) ";}
template<class U, class... Args>
A(U&&,Args&&...){cout<<"A(U&&,Args&&...) ";}
};
int main(){
A<int,int> a(1,1);
A<int,int> b(a);
}
The output (gcc 4.3.0 20070824 with -std=c++0x) is:
A(U&&,Args&&...) A(U&&,Args&&...)
If I was to guess I would have thought:
A(T1,T2) A(const&)
So, the literal 1's are rvalues of type int&& I guess. So when the
params are deduced for the templated ctor with the variadic parameter,
I'm guessing U = int, Args... = int. Since 1 is an rvalue, A(int&&,
int&&) is the best match.
Ok. The next one, 'a' is an Lvalue of type A<int,int>. U then is
deduced to type A<int,int>& (N2639 14.8.2.1.3 I guess). I take it the
&& is dropped but I'm not sure how during the deduction process. I
guess it looks at parameter type U, see's that the argument is type
U&& but the REAL argument type is an lvalue so it converts the entire
argument type to an lvalue reference (unlike the first case where
int&& is the argument type, the real argument type is rvalue of type
int, so int&& is valid).
So, I go and add remove_reference<>'s to the parameter types (U and
Args). Now, in the first case A(T1,T2) is picked. I'd take a stab and
say that in "remove_reference<U>::type &&", the remove_reference is
applied AFTER the argument type is deduced to be int&& ? So the
argument type is... int? And the constant lvalue reference is picked
over an lvalue of type int when the actual argument type is an rvalue
int?
My head spins when I try to figure this stuff out so I wouldn't mind
if someone shed some light on the deduction process in the two cases
(that is, with and without remove_reference).
Much appreciated,
Chris
template <class T1,class T2>
struct A {
A(A const&){cout<<"A(const&) ";}
A(A&&){cout<<"A(A&&) ";}
A(T1 const&, T2 const&){cout<<"A(T1,T2) ";}
template<class U1, class U2>
A(A<U1,U2> &&) {cout<<"A(A<U1,U2>&&) ";}
template<class U, class... Args>
A(U&&,Args&&...){cout<<"A(U&&,Args&&...) ";}
};
int main(){
A<int,int> a(1,1);
A<int,int> b(a);
}
The output (gcc 4.3.0 20070824 with -std=c++0x) is:
A(U&&,Args&&...) A(U&&,Args&&...)
If I was to guess I would have thought:
A(T1,T2) A(const&)
So, the literal 1's are rvalues of type int&& I guess. So when the
params are deduced for the templated ctor with the variadic parameter,
I'm guessing U = int, Args... = int. Since 1 is an rvalue, A(int&&,
int&&) is the best match.
Ok. The next one, 'a' is an Lvalue of type A<int,int>. U then is
deduced to type A<int,int>& (N2639 14.8.2.1.3 I guess). I take it the
&& is dropped but I'm not sure how during the deduction process. I
guess it looks at parameter type U, see's that the argument is type
U&& but the REAL argument type is an lvalue so it converts the entire
argument type to an lvalue reference (unlike the first case where
int&& is the argument type, the real argument type is rvalue of type
int, so int&& is valid).
So, I go and add remove_reference<>'s to the parameter types (U and
Args). Now, in the first case A(T1,T2) is picked. I'd take a stab and
say that in "remove_reference<U>::type &&", the remove_reference is
applied AFTER the argument type is deduced to be int&& ? So the
argument type is... int? And the constant lvalue reference is picked
over an lvalue of type int when the actual argument type is an rvalue
int?
My head spins when I try to figure this stuff out so I wouldn't mind
if someone shed some light on the deduction process in the two cases
(that is, with and without remove_reference).
Much appreciated,
Chris