C++函数/类模板n维数组重载运算符入门

待更新

模板是泛型编程的基础，泛型编程即以一种独立于任何特定类型的方式编写代码。

template <typename T> 
函数返回类型 函数名（函数接口）
{
    函数的主体,其中的T为函数所使用的数据类型的占位符名称
}
或
template <typename T1,typename T2=int> 
函数返回类型 函数名（函数接口）
{
    函数的主体,可有多个参数
   T1和T2为占位符名称，T2=int表示默认为T2为int类型
}

函数模板

以下是一个实例，返回两个数中的最大值

template <typename T>
T const& Max (T const& a, T const& b) 
{ 
    return a < b ? b:a; 
}

类模板

类似函数模板，我们也可以定义类模板，类模板定义为类名<占有符>类对象名

template <class T>
class 类名{
public:
	类主体
private:
};

以下是类模板用STL自带的vector模拟栈stack的实例，因为是类函数的声明和定义是在一起的，所以可以少写template ，和在类名前面少添加"类名::"

template <class T>
class Stack { 
public: 
    void push(T const&){  // 入栈
         // 追加传入元素的副本
        elems.push_back(elem); 
    }
    void pop() {              // 出栈
        if (elems.empty()) { 
            throw out_of_range("Stack<>::pop(): empty stack"); 
        }
        // 删除最后一个元素
        elems.pop_back(); 
    }
    T top() const{            // 返回栈顶元素
        if (elems.empty()) { 
            throw out_of_range("Stack<>::top(): empty stack"); 
        }
        // 返回最后一个元素的副本 
        return elems.back();  
    }
    bool empty() const{       // 如果为空则返回真。
        return elems.empty(); 
    } 
private: 
    vector<T> elems;     // 元素 
}; 

类模板定义数组

主要是在模板类里面定义个占有符类型的指针，用该指针进行new运算达到简易的创建多为数组的效果。当然使用new后需要记得delete数组。
需要注意的是，我个人习惯，记得重载构造函数，复制构造函数，移动构造函数(右值引用)和重载运算符“=”，因为需要存储其他基础四则运算符返回的运算结果。
下面是，类模板定义n维向量Vector，重载+，-，*，/四则运算符，重载类模板的cin,out,=

//#pragma GCC optimize(2)
#include 
using namespace std;
#define endl "\n" 
template<class T>
class Vector{
public:
    Vector(int siz=0){
        cout<<"构造函数"<<endl;
        size=siz;
        if(size>0)array=new T[size];
    }
    Vector(Vector<T>& temp){
        cout<<"复制构造函数"<<endl;
        size=temp.size;
        if(size==0)return ;
        array=new T[size];
        for(int i=0;i<size;i++)
            array[i]=temp.array[i];
    }
    Vector(Vector<T>&&temp){
        cout<<"移动复制函数"<<endl;
        array=move(temp.array);
    }
    ~Vector(){
        cout<<"析构函数"<<endl;
        if(array!=NULL&&size>0)delete []array;
    }
    void show(){
        cout<<"(";
        for(int i=0;i<size;i++)
            cout<<array[i]<<","[i==size-1];
        cout<<")"<<endl;
    }
    Vector<T> operator=( Vector<T> &temp){
        if(this==temp)return *this;
        if(array!=NULL)
            delete []array;
        if(size==0)return *this;
        size=temp.size;
        array=new T[size];
        for(int i=0;i<size;i++)
            array[i]=temp.array[i];
        return *this;    
    }
    T operator[](int i){
        if(i<0||i>=size)return -1;
        else return array[i];
    }
    friend Vector<T> operator+( Vector<T> a, Vector<T> b){
        Vector c(a);
        for(int i=0;i<a.size;i++)
            c.array[i]=a.array[i]+b.array[i];
        return c;
    }
    friend Vector<T> operator-(const Vector<T>& a,const Vector<T>& b){
        Vector temp(a);
        for(int i=0;i<a.size;i++)
            temp.array[i]=a.array[i]-b.array[i];
        return temp;
    }
    friend Vector<T> operator*(const Vector<T>& a,const Vector<T>& b){
       Vector temp(a);
        for(int i=0;i<a.size;i++)
            temp.array[i]=a.array[i]*b.array[i];
        return temp;
    }
    friend Vector<T> operator/(const Vector<T>& a,const Vector<T>& b){
        Vector temp(a);
        for(int i=0;i<a.size;i++)
            temp.array[i]=a.array[i]/b.array[i];
        return temp;
    }
    friend istream & operator >>(istream& in,Vector<T>&temp){
        for(int i=0;i<temp.size;i++)
            in>>temp.array[i];
        return in;
    }
    friend ostream & operator <<(ostream& out,Vector<T>&temp){
        out<<"( ";
        for(int i=0;i<temp.size;i++)
            out<<temp.array[i]<<" ";
        out<<")";
        return out;
    }
private:
    T* array;
    int size;
};
int main(){
    Vector<int>a(4),b(4);
    cin>>a;
    cin>>b;
    Vector<int>c=a+b;
    cout<<c;
    c.show();    
   return 0;
}