面向对象程序设计（二）：C++模板初探

背景：老师留了一个作业，对两个数组进行相加，但是总是会出现错误；首先我们需要知道当数组作为参数传递的时候是不能用 sizeof 的，因为当数组传入子函数就变成了普通的数组头；这时候使用 sizeof 只会检测到指针的长度；

 

我们用模板来传递数组，实际上并非模板可以传递数组，而是引用传递完成了这件事

对应的现象是：值传递的数组会衰减成指针

下面给出利用引用传递的代码（没有使用模板）

#include<iostream>
using namespace std;

int P(int (&a)[5]);  　　//子函数
int main(){
    
    int a[5]={0};
    
    int b=P(a);
    
    cout<<b<<endl;
    
    return 0;
} 
int P(int (&a)[5]){　　　　　　//进行了引用传递
    
    return sizeof(a)/sizeof(a[0]);
}

　　在这个代码中我们发现一件事，如果要传递这个数组，我们首先要知道数组的位数，但是我们要求的不就是数组的位数吗，这就是上文我们做的，其实也是模板的主要作用：实参演绎，我们规定了两个参数，这两个参数到底谁是5位数组，谁是10位数组，这个工作在模板中被自动的完成了，综合了上述两种技术我们实现了数组的传递

　　其次，我们需要知道子函数返回的数组的时候也很麻烦，不仅仅因为返回的是指针，更是因为在子函数中定义的数组会随着函数的结束而释放，最终只留下数组头一个数据可以使用，所以我们用动态内存，去主动的分配一个空间给数组

---

 

 

现在我们把操作和方法放在下面：

模板：	传入一个数组（实现泛型编程，因为要传入的这个数组长度是不确定的）
引用传递：	这里没有操作原来的数，仅仅是为了减少拷贝的操作
new：	给数组创建内存
delete：	配合new，释放内存

 

 

　　 

 

　　 

 

以下代码思路：

先弄两个数组，一起传入到子函数中

由子函数创建新的数组，通过加减法给新的数组赋值，（new）

操作完新的数组之后结束程序（delete）

#include<iostream>

using namespace std;

template <typename T1,typename T2>         //要在模板参数列表中定义两个模板参数；因为： 
int* plusArr(T1& a,T2& b);                //将来传入的int[10]和int[5]是两个不同的类型 

int main(){
    
    int a[10]={1,2,3,4,5,6,7,8,9,0};
    int b[5]={3,4,5,6,7};
    
    int* sum=plusArr(a,b);                //用sum保存这个指针，因为plusArr栈会清掉（包括指针p） 
    
    int i=0;
    while(sum[i]!='\0'){
        cout<<sum[i]<<' ';
        ++i;
    }
    
    delete[] sum;                        //释放内存 在此，delete一定要加中括号[]！！
} 

template<typename T1,typename T2> 
int* plusArr(T1& a,T2& b){
    
    int m=(int)sizeof(a)/sizeof(a[0]);
    int n=(int)sizeof(b)/sizeof(b[0]);
    
    if(m>n){
        int* p=new int[m+1];            //在堆上分配了动态内存 （并未初始化）
        for(int i=0;i<n;i++){            //开始赋值 
            p[i]=a[i]+b[i];
        }
        for(int i=n;i<m;i++){
            p[i]=a[i];
        }
        p[m]='\0';                        //用来标志 
        return p;
    } 
    else{                                //上面的是a长度大，下面b同理 
        int* p=new int[n+1];
        for(int i=0;i<m;i++){
            p[i]=a[i]+b[i];
        }
        for(int i=n;i<m;i++){
            p[i]=b[i];
        }
        p[n]='\0';
        return p;    
    }
    
}

 

　　这个函数写出来呢，主要是验证一些函数的用法，这些函数虽然在这个程序中显得“过分”了，但是在将来涉及到复用的时候，像这种泛型编程就可以大显身手，顺便复习一下new delete

 

---

 

更加深入的理解：

 

在人民邮电出版社《C++模板：tamplate》一书中开头就提醒我们模板的定义一定要写常量引用，而且注意const的顺序一定是在后面；

下面我们列出一个模板的定义，并尝试去理解他的形式参数性质：

 1 #include<iostream>
 2 int main(){
 3     int* b;
 4     int* &a=b;          //这里对指针a的操作等于直接对指针b进行操作 
 5     
 6     int const c;
 7     int* const d;        //定义一个正常的常量指针d 
 8     
 9     int* n; 
10     int* const &m=n;         //定义一个常量指针的引用，这里n是常量，所有对m的操作最终会作用到n上 
11     
12     //在模板中我们经常看到如下定义
13     tamplate<typename T>
14     T const& name(T const& a,T const& b){    //这里是引用传递，并且我们不会用引用去更改外面的值 
15         ;                 
16     } 
17     
18     return 0;
19 }

 

转载请注明来源