c++的数组作为函数形参的退化问题

在项目过程中，因为涉及到用c#调用c++的dll，其中有一个定义好的数组，想转为c++中的vector，将数组作为形参传到函数内部后，需要遍历每个数组，代码如下：

可以看到，在函数内部需要知道数组的长度，也就是元素个数，但使用了网上说的sizeof函数，始终求出来等于8，仔细查阅资料才发现这里存在一个数组作为函数参数的退化问题。即当数组被初始化后，在不被函数调用的情况下，可以用sizeof求出正确的数组长度，一旦作为函数参数传递到函数内部，该参数就退化为一个指针，对该指针求sizeof则始终是一个指针的长度，而不是数组的长度（我能吐槽这个奇葩的隐含规则么？这对于代码重构可是一个灾难性的后果）

       对于c++老手高手高高手来说，这可能是一个基础性的常识问题，但对于新人来讲，绝对会发出“人生苦短，远离c渣渣”的感叹。幸好网友的智慧是无穷的，随手一查，就发现很多高手已经给出了解决方案。

      1、把数组长度作为另外一个参数传进去。（好吧，也就多一个参数不是么）

     2、自定义数组模板。（既然需要造轮子，那就只好造一个了），具体如下：

参考网友gaopengtttt的文章：C++ 简单实现数组类泛型编程示例

1. 模板类实现：
   
2. /*************************************************************************
   
3.     > File Name: arra.cpp
   
4.     > Author: gaopeng QQ:22389860 all right reserved
   
5.     > Mail: gaopp_200217@163.com
   
6.     > Created Time: Mon 10 Apr 2017 08:28:01 AM CST
   
7.  ************************************************************************/
   
8. 
   
9. #include<iostream>
   
10. #include <stdlib.h>
    
11.  #include <string.h>
    
12. using namespace std;
    
13. 
    
14. 
    
15. template <typename T>
    
16. class myarray
    
17. {
    
18.         private:
    
19.                 T* array;
    
20.                 unsigned int lenth;
    
21.         public:
    
22.                 myarray();
    
23.                 myarray(unsigned int len);
    
24.                 myarray(const myarray& a);
    
25.                 myarray& operator=(const myarray& b);
    
26.                 T& operator[](int ind);
    
27.                 ~myarray();
    
28. };
    
29. 
    
30. 
    
31. 
    
32. 
    
33. template <typename T>
    
34. myarray<T>::~myarray()
    
35. {
    
36.         if(this->array != NULL)
    
37.         {
    
38.                 delete [] this->array;
    
39.                 this->array = NULL;
    
40.         }
    
41. 
    
42. }
    
43. 
    
44. 
    
45. template <typename T>
    
46. myarray<T>::myarray()
    
47. {
    
48.         this->array = NULL;
    
49.         this->lenth = 0;
    
50. }
    
51. 
    
52. template <typename T>
    
53. myarray<T>::myarray(unsigned int len)
    
54. {
    
55.         this->array = new T[len];
    
56.         this->lenth = len;
    
57.         memset(this->array,0,sizeof(T)*len);
    
58. }
    
59. template <typename T>
    
60. myarray<T>::myarray(const myarray<T>& a)
    
61. {
    
62.         int i;
    
63.         this->lenth = a.lenth;
    
64.         this->array = new T[a.lenth];
    
65.         memset(this->array,0,sizeof(T)*a.lenth);
    
66.         for(i=0;i<a.lenth;i++)
    
67.         {
    
68.                 *(this->array+i) = *(a.array+i);
    
69.         }
    
70. }
    
71. 
    
72. template <typename T>
    
73. myarray<T>& myarray<T>::operator=(const myarray<T>& a)
    
74. {
    
75.         if(this->array != NULL)
    
76.         {
    
77.                 delete [] this->array;//调用类的析构函数不能用free
    
78.                 this->array = NULL;
    
79.         }
    
80.         this->array = new T[a.lenth];
    
81.         this->lenth = a.lenth;
    
82. 
    
83.         for(int i=0;i<a.lenth;i++)
    
84.         {
    
85.                 *(this->array+i) = *(a.array+i);//元素对象复制调用对象的=操作符重载
    
86.         }
    
87. 
    
88.         return *this;
    
89. }
    
90. 
    
91. template <typename T>
    
92. T& myarray<T>::operator[](int ind)
    
93. {
    
94.         if(ind>=this->lenth)
    
95.         {
    
96.                 exit(10);
    
97.         }
    
98.         return *(this->array+ind);
    
99. }

1. 测试
   
2. /*************************************************************************
   
3.     > File Name: main.cpp
   
4.     > Author: gaopeng QQ:22389860 all right reserved
   
5.     > Mail: gaopp_200217@163.com
   
6.     > Created Time: Mon 10 Apr 2017 08:31:57 AM CST
   
7.  ************************************************************************/
   
8. 
   
9. #include<iostream>
   
10. #include<stdlib.h>
    
11. #include<string.h>
    
12. #include"arra.cpp"
    
13. 
    
14. using namespace std;
    
15. 
    
16. class test
    
17. {
    
18.         private:
    
19.                 int a;
    
20.                 int b;
    
21.                 char* myc;
    
22.         public:
    
23.                 test()
    
24.                 {
    
25.                         a = 0;
    
26.                         b = 0;
    
27.                         myc = NULL;
    
28.                 }
    
29.                 test(const test& a)
    
30.                 {
    
31.                         this->a = a.a;
    
32.                         this->b = a.b;
    
33.                         this->myc = (char*)calloc(strlen(a.myc)+1,0);
    
34.                         strcpy(this->myc,a.myc);
    
35.                 }
    
36. 
    
37. 
    
38.                 friend ostream& operator<<(ostream& out,test& a)
    
39.                 {
    
40.                         out<<a.a<<endl;
    
41.                         out<<a.b<<endl;
    
42.                         cout<<a.myc;
    
43.                         return out;
    
44.                 }
    
45.                 ~test()
    
46.                 {
    
47.                         if(myc != NULL)
    
48.                         {
    
49.                                 free(myc);
    
50.                                 myc = NULL;
    
51.                         }
    
52.                 }
    
53. 
    
54.                 test& operator=(const test& a)
    
55.                 {
    
56.                         if(this->myc != NULL)
    
57.                         {
    
58.                                 free(this->myc);
    
59.                                 this->myc = NULL;
    
60.                         }
    
61.                         this->a = a.a;
    
62.                         this->b = a.b;
    
63.                         this->myc = (char*)calloc(strlen(a.myc)+1,0);
    
64.                         strcpy(this->myc,a.myc);
    
65.                         return *this;
    
66.                 }
    
67. 
    
68.                 test& operator=(const char* a)
    
69.                 {
    
70.                         if(this->myc != NULL)
    
71.                         {
    
72.                                 free(this->myc);
    
73.                                 this->myc = NULL;
    
74.                         }
    
75.                         if(a == NULL)
    
76.                         {
    
77.                                 this->myc = (char*)calloc(1,0);
    
78.                                 return *this;
    
79.                         }
    
80. 
    
81.                         this->myc = (char*)calloc(strlen(a)+1,0);
    
82.                         strcpy(this->myc,a);
    
83.                         return *this;
    
84.                 }
    
85. 
    
86. };
    
87. 
    
88. 
    
89. 
    
90. int main()
    
91. {
    
92.         myarray<test> a(3); //测试class类数组
    
93.         a[0] = "asdasd";
    
94.         a[1] = "test";
    
95.         a[2] = "kkkk";
    
96. 
    
97.         myarray<int> b(3); //测试int数组
    
98. 
    
99.         b[0] = 1;
    
100.         b[1] = 2;
     
101.         b[2] = 3;
     
102. 
     
103.         myarray<char> c(3); //测试char数组
     
104. 
     
105.         c[0] = 'a';
     
106.         c[1] = 'b';
     
107.         c[2] = 'c';
     
108. 
     
109.         myarray<test> d = a;//测试myarray拷贝构造函数
     
110. 
     
111.         for(int i=0;i<3;i++)
     
112.         {
     
113.                 cout<<a[i]<<endl;
     
114.                 cout<<d[i]<<endl;
     
115.         }
     
116. 
     
117.         for(int i=0;i<3;i++)
     
118.         {
     
119.                 cout<<b[i]<<endl;
     
120.         }
     
121.         for(int i=0;i<3;i++)
     
122.         {
     
123.                  cout<<c[i]<<endl;
     
124.         }
     
125. 
     
126. }