函数参数与返回值

函数的参数为数组

int* f(int a[])

{

         return a;

}或者

int* f(int a[5])

{

         return ++a;

}

形参只为数组时，数组长度有没有都无所谓，它其实是相当于指针的；

 

函数的参数为指针

int f2(int* a)

{

         return *a;

}

int* f2(int* a)

{

         returna;

}

 

函数的参数为指针的引用

int f2(int*& a)

{

         return *a;

}

如果用指针的引用做为参数，正常定义的指针做为实参是没问题的，但是若用数组做为实参的话，是不行的，会报错：

error: invalid initialization of non-constreference of type ‘int*&’ from a temporary of type ‘int*’

“临时变量作为非const的引用参数传递”

是因为数组名是一个地址常量，非const引用不能引用一个常量，改为void func(int *const &a)才行；

 

函数的参数为数组的引用

int* f3(int (&a)[5])

{

         return a;

}

要引用数组的时候，参数中必须有数组的长度，没有长度是编译不过的；

当参数为引用时，这时a不会被降级为一个指针，它依旧是一个数组，若不是引用而是像

一开始说的直接将数组做为参数，其实就是讲指针做为了参数，而且这时a是一个拷贝。

 

函数的返回值为指针

之前几个例子已经说明了此问题；

 

函数的返回值为数组指针（不可能返回一个数组）

int (*p())[10]

{

 int(*m)[10];

 inti;

 m =(int (*)[10])calloc(10, sizeof(int));

 if(m == NULL)

 {

 printf("calloc error\n");

 exit(1);

 }

 for(i = 0; i < 10; i++)

 *(*m+i) = i+1;

 return m;

}

int main()

{

 int(*a)[10];

 inti;

 a =p();

 for(i = 0; i < 10; i++)

 printf("%d ", *(*a+i));

 printf("\ndone\n");

 return 0;

}

函数的返回值为数组指针，则返回值还是为一个指针，指针指向一个长度为5的数组，相当于一个二维数组。看下例：

int(* f(int (&s)[5]))[5]

{

         return &s;

}

int main()

{

         intc[5]={1,2,3,4,5} ;

         int(*p)[5] = f(c);

         cout<<*p[0]<<endl;//cout<<**p;

        cout<<(*p)[1];//cout<<*(*p+1);

}

函数f最后返回的是数组s的地址，所以p为s的地址，*p才是数组。

函数是不可以直接返回数组的。若想直接返回数组的本身，则用

int* f(int (&a)[5])

{

         return a;

}

相当于是将数组的首地址传过去；则可以直接用f(a)[n]来访问；

 

再多讲一下，函数指针数组指针数组函数

int (*a[])(int);

int (*p())[10];

第一种情况为数组里面是函数指针的情况,因为(int (*)(int))是一个强制转换方式, 将里面的a[]这个数组转换成了一个函数指针的数组, 并且该函数是一个带一个整型变量,并且返回一个整型的函数.

第二种情况为函数返回的为指向一个一维数组的指针的情况. 因为(int (*)[10])将其强制转换成了一个指针,而该指针则是一个指向一维数组的指针.

 

返回引用的区别在于其它的返回值为右值，返回的引用为左值；

函数的返回值为指针的引用

int*& f5(int* a)

{

         return a;

}

int main()

{

         inta[5]={1,2,3,4,5};

         *f5(a)=6;

         cout<<a[0];//可以看到a[0]等于6

}

但若你想让函数参数为数组指针引用，则上例函数形式是不可以的；

因为数组名为常量，所以得在参数上加const，同时，返回值也得是const；

但为什么上述例子中，也是以数组名为参数就可以呢？那是因为传进函数的不是引用，

而是a的拷贝；

int*const& f7(int* const & a)

{

         return a;

}

int main()

{

         inta[5]={1,2,3,4,5};

         *f7(a)=6;

         cout<<*f7(a),,endl;;//可以看到a[0]等于6

}

 

函数的返回值为数组的引用

int (&f9(int (&a)[5]))[5]

{

         return a;

}

 

int main()

{

         intc[5]={1,2,3,4,5} ;

         int(&a)[5]=f9(c);

         cout<<a<<endl;

         cout<<a[0]<<endl;

        

}

这时函数参数必须为引用，因为不是引用的话，形参将会为一个指针，并不能返回一个数组；

你若不用引用，可以在函数内构造数组；但数组必须为static，如果只是构造一个普通的数组，则数组在函数结束后会被释放掉；如下例，输出新数组内容时会有错误；

int (&f10())[5]

{

         Int static a[5] = {1,2,3,4,5};

         return a;

}

int main()

{

         int(&a)[5] = f10();

         cout<<a[0]<<''<<a[1]<<' '<<a[2]<<' '<<a[3]<<''<<a[4]<<endl;

}