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

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

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

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

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

 1 #include<iostream>

 2 using namespace std;

 3

 4 int P(int (&a)[5]);  　　//子函数

 5 int main(){

 6

 7     int a[5]={0};

 8

 9     int b=P(a);

10

11     cout<<b<<endl;

12

13     return 0;

14 }

15 int P(int (&a)[5]){　　　　　　//进行了引用传递

16

17     return sizeof(a)/sizeof(a[0]);

18 }

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

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

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

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

以下代码思路：

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

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

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

 1 #include<iostream>

 2

 3 using namespace std;

 4

 5 template <typename T1,typename T2>         //要在模板参数列表中定义两个模板参数；因为：

 6 int* plusArr(T1& a,T2& b);                //将来传入的int[10]和int[5]是两个不同的类型

 7

 8 int main(){

 9

10     int a[10]={1,2,3,4,5,6,7,8,9,0};

11     int b[5]={3,4,5,6,7};

12

13     int* sum=plusArr(a,b);                //用sum保存这个指针，因为plusArr栈会清掉（包括指针p）

14

15     int i=0;

16     while(sum[i]!='\0'){

17         cout<<sum[i]<<' ';

18         ++i;

19     }

20

21     delete[] sum;                        //释放内存 在此，delete一定要加中括号[]！！

22 }

23

24 template<typename T1,typename T2>

25 int* plusArr(T1& a,T2& b){

26

27     int m=(int)sizeof(a)/sizeof(a[0]);

28     int n=(int)sizeof(b)/sizeof(b[0]);

29

30     if(m>n){

31         int* p=new int[m+1];            //在堆上分配了动态内存 （并未初始化）

32         for(int i=0;i<n;i++){            //开始赋值

33             p[i]=a[i]+b[i];

34         }

35         for(int i=n;i<m;i++){

36             p[i]=a[i];

37         }

38         p[m]='\0';                        //用来标志

39         return p;

40     }

41     else{                                //上面的是a长度大，下面b同理

42         int* p=new int[n+1];

43         for(int i=0;i<m;i++){

44             p[i]=a[i]+b[i];

45         }

46         for(int i=n;i<m;i++){

47             p[i]=b[i];

48         }

49         p[n]='\0';

50         return p;

51     }

52

53 }

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

转载请注明来源

巴特西

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

最新文章

热门文章