C/C++编程：成员模板

╰半橙微兮° 2023-01-13 14:53 117阅读 0赞

类成员也可以是模板。嵌套类和成员函数都可以作为模板。

*  普通类的成员函数模板：普通类的成员函数模板可以在类中实现，也可以在类外实现。在类外实现时，由于类不是模板，无需在类后面增加模板实参类表

#include <string>
    #include <iostream>
    
    
    struct normal_class{
        
        int value;
    
        template <typename T>
        void set(T const&v){
         value = int(v);}
    
        template <typename T>
        T get();
    };
    
    template <typename T>
    T normal_class::get() {
        
        return T(value);
    }

*  类模板中的成员函数模板：
    
     *  类模板中的成员函数可以有额外的模板实参类表
     *  成员函数模板的参数不能和类模板参数同名，否则会造成命名冲突
     *  不同成员函数模板的参数名不相干，可以同枚
     *  成员函数模板参数只在本函数实现体可见，而类模板之外实现成员函数时，需要用到两个template分别引导类模板和成员函数模板的参数

template <typename T0>
    struct a_class_template{
        
        T0 value;
    
        template <typename T1>
        void set(T1 const &v){
        value = T0(v);}
    
        template <typename T1>
        T1 get();
    };
    
    template <typename T0> template <typename T1>
    T1 a_class_template<T0>::get() {
        
        return T1(value);
    }

有关于**友元函数模板**：友元函数模板和类模板的任何实例都是该类的友元，可以访问类的私有成员：

class citizen{
        
        int id;
        double money;
    
        template <typename T>
        friend class FIB_agent;
    
        template <typename T>
        friend T duty(citizen&);
    
    public:
        citizen(int id) : id(id){
        }
    };

现在通过一个`Stack<>`类模板来说明这种(作为模板的)能力的优点和应用方法。

通常而言，栈之间只有类型完全相同时才能相互赋值，不同就不能相互赋值，即使这两种(元素的)类型之间存在隐式类型转换，比如：

Stack<int> intStack1, intStack2; // int栈
    Stack<float> floatStack1; // float栈
    
    intStack1 = intStack2; // ok: 具有相同的类型
    floatStack1 = intStack1 ; // ERROR：两边栈类型不同

缺省赋值运算符要求两边具有相同的类型，当元素类型不同时，两个栈的类型就不同，不能符合缺省赋值运算符的要求

然后，通过定义一个身为模板的赋值运算符，针对元素类型可以转换的两个栈就可以进行相互赋值。为了达到这个目的，你需要这样声明`Stack<>`：

template <typename T>
    class Stack {
        
      private:
        std::deque<T> elems;   // 存储元素的容器
      public:
        void push(T const&);   // 压入元素
        void pop();            // 弹出元素
        T top() const;         // 拿到栈顶元素
        bool empty() const {
           // 返回栈是否为空
            return elems.empty();
        }
    
        // 使用元素类型为T2的栈进行赋值
        template <typename T2>
        Stack<T>& operator= (Stack<T2> const&);
    };

在这里，我们进行了两处改动：

*  增加了一个赋值运算符的声明，它可以把元素类型为T2的栈赋值为原来的栈
 *  栈限制改用deque作为元素的内部容器。实际上，这是为了满足新赋值运算符实现的要求

新赋值运算符的实现大致如下：

template <typename T>
    template <typename T2>
    Stack<T>& Stack<T>::operator=(const Stack<T2> & op2) {
        
        if ((void *) this == (void *)&op2){
          // 赋值给自身吗？
            return *this;
        }
        
        Stack<T2> tmp(op2);  // 产生一个赋值栈的拷贝
        
        elems.clear();            // 删除现存的元素
        while (!tmp.empty()){
           // 拷贝所有的元素
            elems.push_front(tmp.top());
            tmp.pop();
        }
        
        return *this;
    }

让我们先来看成员模板的语法，在定义有模板参数T的模板内部，还定义了一个含有模板参数T2的内部模板：

template <typename T>
    template <typename T2>
    ...

实现了上面的成员模板后，就可以把一个int栈赋值给一个float栈了

Stack<int> intStack1, intStack2; // int栈
    Stack<float> floatStack1; // float栈
    
    intStack1 = intStack2; // ok: 具有相同的类型
    floatStack1 = intStack1 ; //ok：虽然时具有不同类型的栈，但是int可以转换为float

这个赋值函数好像屏蔽了类型检查，看起来你可以用任意类型的栈来对目标栈进行赋值；但是实际情况并非如此，类型检查仍然存在。当源站(的拷贝)的元素被移入到目标栈时，就要执行必要的类型检查，也就是说类型检查发生再如下语句执行时：

elems.push_front(tmp.top());

证明类型检查没有被屏蔽可以从下面例子看出：

Stack<std::string> stringStack;
    Stack<float> floatStack;
    
    floatStack = stringStack; // ERROR -- std::string并不能转换为float

**模板赋值运算符并没有取代缺失赋值运算符。对于相同类型栈之间的赋值，依然会调用缺省赋值运算符**

**同样，我们可以把内部容器类型实现为一个模板参数，这样就有机会改变内部容器的类型**：

template <typename T, typename CONT = std::deque<T> >
    class Stack {
        
      private:
        CONT elems;            // elements
    
      public:
        void push(T const&);   // push element
        void pop();            // pop element
        T top() const;         // return top element
        bool empty() const {
           // return whether the stack is empty
            return elems.empty();
        }
    
        // assign stack of elements of type T2
        template <typename T2, typename CONT2>
        Stack<T,CONT>& operator= (Stack<T2,CONT2> const&);
    };

此时，模板复制运算符的实现如下：

template<typename T, typename CONT>
    template<typename T2, typename CONT2>
    Stack<T, CONT> & Stack<T, CONT>::operator=(const Stack<T2, CONT2> &op2) {
        
        if ((void *) this == (void *) &op2){
          //
            return *this;
        }
    
        Stack<T2, CONT2> tmp(op2);
    
        elems.clear();
        while (!tmp.empty()){
        
            elems.push_front(tmp.pop());
            tmp.pop();
        }
        return *this;
    }

需要再次提醒的是：**对于类模板而言。只有那些被调用的成员函数才会被实例化**。因此，如果在元素类型不同的栈之间没有相互赋值，就可以使用vector作为内部容器：

Stack<int, std::vector<int>> vStack;
    
    vStacl.push(42);