C++的模板(十二)：forward模板

标准库的std::forward模板有一个类型T参数。在实际使用时，T取什么值应该不存在疑惑：

class  A {
public:
        A() {}
        A(int n):n(n) {}
        template <class T> A(T &&a);
        void print(A &&a) { printf("A&&\n"); }
        void print(A &a) { printf("A&\n"); }
        void print(const A &a) { printf("const A&\n"); }
        int n;
};


template <class T> A::A(T &&a)
{
        printf("template %s(&&a): a ",__FUNCTION__);
        print(std::forward<T>(a));
        n= a.n+1;
}

这个例子中，复制构造函数写成了模板。呵呵，广义复制构造函数。这不是太可靠。不过这个例子不会乱传不可使用的类型T，这样写已经足够。在复制构造函数模板中，向重载的print()成员函数转发了参数a。模板并不清楚传给它的类型是哪种重载类型，因此转发给print()，让它打印出来。这里，forward模板携带的参数类型T，照抄模板的传入类型。

A  f(int n)
{
        A a;
        a.n=n;
        printf("A f(%d) return\n", n);
        return a;
}

A  g(int n)
{
        printf("A g(%d) return\n", n);
        return A(n);
}


int main()
{
        A a;  a.n=900;
        printf("f(100): \n");
        A b=f(100);
        printf("%d\n", b.n);
        printf("g(100): \n");
        A b1=g(100);
        printf("%d\n", b1.n);
        printf("*******\n");
        const A *pa= &a;
        A b2= *pa;
        printf("%d\n", b2.n);
        printf("c:");
        A c(a);
        printf("c.n=%d\n", c.n);
}

打印出来是这样的信息：

f(100):
A f(100) return
template A(&&a): a A&
template A(&&a): a A&&
102
g(100):
A g(100) return
template A(&&a): a A&&
template A(&&a): a A&&
102
*******
b2: 900
c:template A(&&a): a A&
c.n=901

f()和g()函数的"赋值"语句(赋值格式的初始化语句)各导致了2次复制构造函数调用。一次return语句向返回值复制，一次返回值向接收的变量复制。第2次都是移动构造，第一次在g()函数也是移动构造。

但是, b2并没有调用这个“广义复制构造函数”。如果没有显式定义复制构造函数，C++会自动生成一个。这里调用的正是C++自动生成那个。模板复制构造函数不影响C++自动生成构造函数。所以用“广义复制构造函数抓取const 引用”的设想落空了。为了证实这一点，可以塞给class A一个base类，在base里面打印复制构造函数。如果调用的是C++自动生成那个版本，会自动调用基类的对应的复制构造函数。也就是base(const base &b);

class base {
public:
        base(){}
        base(const base &b) { printf("copy constructor(const&)\n");}
        base(base &b) { printf("copy constructor(&)\n");}
        base(base &&b) { printf("copy constructor(&&)\n");}
};
class  A :public base{
public:
        A() {}
        A(int n):n(n) {}
        template <class T> A(T &&a);
        void print(A &&a) { printf("A&&\n"); }
        void print(A &a) { printf("A&\n"); }
        void print(const A &a) { printf("const A&\n"); }
        int n;
};

别的代码不变。运行结果提示，b2确实调用了C++自动生成的那个复制构造函数。所以复制构造函数模板不是很圆满。

例子中的print()打印了类型信息。这个信息很有用。虽然，print没有返回值，但可以让它有。

        int print(A &&a) { printf("A&&\n"); return 1; }
        int print(A &a) { printf("A&\n"); return 2;}
        int print(const A &a) { printf("const A&\n"); return 3;}
        

这样模板用forward转发一下，从返回值就可以知道自己参数是什么类型了。

template <class T> A::A(T &&a)
{
		int ret;
        printf("template %s(&&a): a ",__FUNCTION__);
        ret =print(std::forward<T>(a));
        switch (ret) {
       	//......
        }
        n= a.n+1;
}

这样就可以对不同的类型，做不同的处理。经过forward，模板是可以知道自己的传入类型。

意识到这种识别对任意类型的通用性，最终把这也写成了模板：

template <class T>
struct eval_forward_t {
        typedef typename std::remove_reference<T>::type noref;
        typedef typename std::remove_const<noref>::type type;

        static int eval(type &&a) {return 1;}
        static int eval(type &a) {return 2;}
        static int eval(const type &a) {return 3;}
};

template <class T> A::A(T &&a)
{
        printf("template %s(&&a): a ",__FUNCTION__);
        print(std::forward<T>(a));
        printf("eval_forward: %d\n",
                eval_forward_t<T>::eval(std::forward<T>(a)));
        n= a.n+1;
}