其实同事已经对C++0X中的完美转发有了很好的理解，在这里我只是在自己的基础上衍生的一些理解加上去
同事博客C++完美转发地址参考：http://www.cnblogs.com/alephsoul-alephsoul/archive/2013/01/10/2853900.html
引言
其实完美转发，其实就是在调用了函数的基础上，能够相当于调用第二个函数，那么这个函数中的参数就完美转发给了第二个函数。
转发方式一：非常量左值引用
1 #include <iostream> 2 using namespace std; 3 4 void F(int a1, int a2, int a3) { 5 cout << a1 + a2 + a3 <<endl; 6 } 7 8 template<class A1, class A2, class A3> 9 void G(A1& a1, A2& a2, A3& a3) { 10 return F(a1, a2, a3); 11 } 12 13 int main() { 14 int i,j,k; 15 G(i, j, k); 16 G(1, 2, 3); 17 F(1, 2, 3); 18 19 system("pause"); 20 }
16行代码中G（1，2，3）是不能编译通过的，因为我们无法接收非常量右值的参数。
但是，代码中15行是完全可以编译通过的，虽然此时的i，j,k均是左值，但此时的G(i, j, k)实际上就是取了i,j,k的任意值相加。
F（1，2，3）可以完全略去不讲。
转发方式二：常量左值引用
1 #include <iostream> 2 using namespace std; 3 4 void F(int& a1, int& a2, int& a3) { 5 cout << a1 + a2 + a3 <<endl; 6 } 7 8 template<class A1, class A2, class A3> 9 void G(A1 const & a1, const A2& a2,const A3& a3) { 10 return F(a1, a2, a3); 11 } 12 13 int main() { 14 int i,j,k; 15 G(i, j, k); 16 G(1, 2, 3); 17 18 system("pause"); 19 }
此时的15、16行均会出错，原因就在于无法将一个常量左值引用转发给一个非常量左值引用。
虽然15行中传入的是非常量左值，但是G函数可供接收的却是常量左值引用，因此失败。
转发方式三：非常量左值引用+常量左值引用
1 #include <iostream> 2 using namespace std; 3 4 void F(int a) { 5 cout << a <<endl; 6 } 7 8 template<class A> 9 void G(A &a) { 10 return F(a); 11 } 12 13 template<class A> 14 void G(const A &a) { 15 return F(a); 16 } 17 18 int main() { 19 int i; 20 G(i); 21 G(1); 22 23 system("pause"); 24 }
通过函数重载来让转发时找到合适的转发方式，这种方式倒是实现了转发，但是却非常的不“完美”，详细请看同事的博客。
需要注意的是，第20行中，G(i)由于i是非常量左值，因此进入的是G(A &a)函数，但是由于i未被初始化，所以出现的是一个任意值。
转发方式四：常量左值引用+const_cast
1 #include <iostream> 2 using namespace std; 3 4 void F(int a) { 5 cout << a <<endl; 6 } 7 8 template<class A> 9 void G(const A &a) { 10 return F(const_cast<A &>(a)); 11 } 12 13 int main() { 14 int i; 15 G(i); 16 G(1); 17 18 system("pause"); 19 }
整个过程编译是没有问题的，但是通过const_cast，却将传入的const属性去除了，这样在调用G()函数后，我们就可以通过F()函数来修正传入的常量左值和常量右值了。当一个参数的属性都被修正了，还叫“完美”么？
转发方式五：非常量左值引用+修改的参数推倒规则转发
1 #include <iostream> 2 using namespace std; 3 4 void F(int a) { 5 cout << a <<endl; 6 } 7 8 template<class A> 9 void G(A &a) { 10 return F(a); 11 } 12 13 void G(const long &a) { 14 return F(a); 15 } 16 17 int main() { 18 int i; 19 G(i); 20 G(1); 21 22 system("pause"); 23 }
奈何啊，模板编程的参数推倒规则不懂啊，这里理解起来非常困难。
按照我的理解，其实修正后的模板规则跟函数重载差不多，系统会自动匹配最佳的规则。
转发方式六：右值引用
1 #include <iostream> 2 using namespace std; 3 4 void F(int a) { 5 cout << a <<endl; 6 } 7 8 template<class A> 9 void G(A &&a) { 10 return F(a); 11 } 12 13 int main() { 14 int i; 15 G(i); 16 G(1); 17 18 system("pause"); 19 }
第9行的代码就是C++11中提出的右值引用新标准，如果你在VS08中编译的话是不会通过的，只有在10以上的才可以。
同事的博客上写的是不能将一个左值传递给一个右值引用，这句话本身是没有问题的，但是在代码15行中，i是作为一个左值的出现，所以需要注意的是传到G(A &&a)中的参数其实是一个为2的右值，在G()函数中并没有保证传递参数的属性，所以也算不上完美转发。
转发方式七：右值引用+修改的参数推倒规则转发
1、T& + & = T& 2、T& + && = T& 3、T&& + & = T& 4、T或T&& + && = T&&
上述的4个引用叠加规则的理解至关重要，修改后的针对右值引用的参数推导规则为：若函数模板的模板参数为A，模板函数的形参为A&&，则可分为两种情况讨论：
1、若实参为T&，则模板参数A应被推导为引用类型T&。（由引用叠加规则第2点T& + && = T&和A&&=T&，可得出A=T&）
2、若实参为T&&，则模板参数A应被推导为非引用类型T。（由引用叠加规则第4点T或T&& + && = T&&和A&&=T&&，可得出A=T或T&&，强制规定A=T）
基于以上的分析，我们可以写出以下的代码：
1 #include <iostream> 2 using namespace std; 3 4 void F(int a) { 5 cout << a <<endl; 6 } 7 8 template<class A> 9 void G(A &&a) { 10 return F(static_cast<A &&>(a)); 11 } 12 13 int main() { 14 int i = 2; 15 G(i); 16 G(1); 17 18 system("pause"); 19 }
当传给f一个左值（类型为T）时，由于模板是一个引用类型，因此它被隐式装换为左值引用类型T&，根据推导规则1，模板参数A被推导为T&。这样，在f内部调用F(static_cast<A &&>(a))时，static_cast<A &&>(a)等同于static_cast<T& &&>(a)，根据引用叠加规则第2点，即为static_cast<T&>(a)，这样转发给g的还是一个左值。
当传给f一个右值（类型为T）时，由于模板是一个引用类型，因此它被隐式装换为右值引用类型T&&，根据推导规则2，模板参数A被推导为T。这样，在G内部调用F(static_cast<A &&>(a))时，static_cast<A &&>(a)等同于static_cast<T&&>(a)，这样转发给F的还是一个右值（不具名右值引用是右值）。
这样看来，无论左值还是右值，都实现了完美的转发，所以这种被称为是完美转发。
在C++11中，专门提供了一个函数模板来实现完美转发，他就是forward。
1 #include <iostream> 2 using namespace std; 3 4 void F(int a) { 5 cout << a <<endl; 6 } 7 8 template<class A> 9 void G(A &&a) { 10 return F(forward<A &&>(a)); 11 } 12 13 int main() { 14 int i = 2; 15 G(i); 16 G(1); 17 18 system("pause"); 19 }
上述代码需要在VS10基础上运行，至此，完美转发均完全实现了。