加载中…
个人资料
微博
  • 博客等级：
  • 博客积分：
  • 博客访问：
  • 关注人气：
  • 获赠金笔：0支
  • 赠出金笔：0支
  • 荣誉徽章：
正文 字体大小：大 中 小

在C和c++中如何使函数返回数组

(2014-04-12 16:20:27)
标签：

it

 分类： C语言
一.C语言中返回数组
 
Java语言的函数可以轻易的返回一个数组，而C/C++却不能直接返回一个数组。这是由于在C/C++中，数组不是一种类型，因此不能被直接返回。
    在C/C++中，一般有两种方法来返回一个数组。
第一种方法：
返回一个指向数组的指针，例如char (*retArray)[10]声明了一个函数retArray，该函数可以返回指向具有10个char元素的数组
例子如下：

#include stdio.h>

#include stdlib.h>

int (*retArray())[10]
{
    int (*a)[10];
    int i=0;
   
    a=(int(*)[10])calloc(10,sizeof(int));//注意类型的转换
   
    for(i=0;i<10;i++)
    {
        (*a)[i]=i;
    }
    return a;

}

int main()
{
    int (*b)[10];
   
    b=retArray();
   
    printf("%d/n",(*b)[0]);
   
    free(b);
    return 0;
}


第二种方法：
如果你不喜欢用指针的形式返回数组，那么可以采用返回一个结构的形式。这种形式相对较安全，可以避免忘记释放指针而造成内存泄露，
也可以避免访问悬挂指针造成的错误。但缺点是由于结构是先拷贝再返回，因此如果结构较大时，会影响效率和占用较大内存。
例子如下：

#include

 

typedef struct
{
    int a[10];
}RETA;


RETA retArray()
{
     RETA x;
    int i=0;
    for(i=0;i<10;i++)
         x.a[i]=i;
    return x;
}


int main()
{
    int b[10];
     b=retArray().a;
     printf("%d\n",b[5]);
   
    return 0;
}

注意：
(1) 在返回指针时要切记要避免内存泄露和访问悬挂指针
(2) 很多人认为指针和数组等价的，这是错误的。int (*a)[10]和int b[10]两者是不能直接用a=b来赋值的。在数组和指针作为函数参数传递时，二者可以认为等价，这是因为数组会被转化为指针来传递。
(3) 返回多维数组方法类似。

 

二.C++中返回数组

 

这个问题属于非常初级的问题，但是对于初学不知道的人可能会比较头疼。C++中函数是不能直接返回一个数组的，但是数组其实就是指针，所以可以让函数返回指针来实现。比如一个矩阵相乘的函数，很容易地我们就写成：
 1 #include
 2
 3 using namespace std;
 4
 5 float* MultMatrix(float A[4], float B[4])
 6 {
 7     float M[4];
 8     M[0] = A[0]*B[0] + A[1]*B[2];
 9     M[1] = A[0]*B[1] + A[1]*B[3];
10     M[2] = A[2]*B[0] + A[3]*B[2];
11     M[3] = A[2]*B[1] + A[3]*B[3];
12
13     return M;
14 }
15
16 int main()
17 {
18     float A[4] = { 1.75, 0.66, 0, 1.75 };
19     float B[4] = {1, 1, 0, 0};
20     float *M = MultMatrix(A, B);
21     cout << M[0] << " " << M[1] << endl;
22     cout << M[2] << " " << M[3] << endl;
23
24     return 0;
25 }
但是运行后发现结果是：1.75 1.75
                               6.51468e-039 3.76489e-039
根本不是想要的结果。于是我们在函数中也加上显示代码，看看是不是计算的问题，得到结果：
1.75 1.75
0 0
1.75 1.75
1.96875 1.75
发现计算的结果是正确的，但返回后就变了，而且跟上次的结果不一样。这是为什么呢？
因为在函数中定义的数组M在函数执行完后已经被系统释放掉了，所以在调用函数中得到的结果当然不是计算后的结果。有一个解决办法就是动态分配内存，在函数中new一个数组，这样就不会被释放掉了。
于是就应该将
7 　　 float M[4];
改为：
7　　float *M = new float[4];
修改运行后得到结果：
1.75 1.75
0 0
1.75 1.75
0 0
正确。但是我们这样并没有将自己申请的空间释放掉，如果我们在函数内释放的话结果就会跟开始时的一样了。
看看我们的调用代码：
20 　　 float *M = MultMatrix(A, B);
这样其实是将M指针指向了函数中M数组的首地址，我们可以将M指针释放，效果和释放申请的M数组是一样的，因为它们指向的是同一片内存空间。于是代码就修改为：
 1 #include
 2
 3 using namespace std;
 4
 5 float* MultMatrix(float A[4], float B[4])
 6 {
 7     float *M = new float[4];
 8     M[0] = A[0]*B[0] + A[1]*B[2];
 9     M[1] = A[0]*B[1] + A[1]*B[3];
10     M[2] = A[2]*B[0] + A[3]*B[2];
11     M[3] = A[2]*B[1] + A[3]*B[3];
12     cout << M[0] << " " << M[1] << endl;
13     cout << M[2] << " " << M[3] << endl;
14
15     return M;
16 }
17
18 int main()
19 {
20     float A[4] = { 1.75, 0.66, 0, 1.75 };
21     float B[4] = {1, 1, 0, 0};
22     float *M = MultMatrix(A, B);
23     cout << M[0] << " " << M[1] << endl;
24     cout << M[2] << " " << M[3] << endl;
25     delete[] M;
26
27     return 0;
28 }
运行结果：
1.75 1.75
0 0
1.75 1.75
0 0
没有问题，new的空间也delete掉了。
鉴于下面大牛们的建议，我将程序修改如下，大家看可否：
 1 #include
 2
 3 using namespace std;
 4
 5 void MultMatrix(float M[4], float A[4], float B[4])
 6 {
 7     M[0] = A[0]*B[0] + A[1]*B[2];
 8     M[1] = A[0]*B[1] + A[1]*B[3];
 9     M[2] = A[2]*B[0] + A[3]*B[2];
10     M[3] = A[2]*B[1] + A[3]*B[3];
11
12     cout << M[0] << " " << M[1] << endl;
13     cout << M[2] << " " << M[3] << endl;
14 }
15
16 int main()
17 {
18     float A[4] = { 1.75, 0.66, 0, 1.75 };
19     float B[4] = {1, 1, 0, 0};
20
21     float *M = new float[4];
22     MultMatrix(M, A, B);
23
24     cout << M[0] << " " << M[1] << endl;
25     cout << M[2] << " " << M[3] << endl;
26     delete[] M;
27
28     return 0;
29 }

http://www.2cto.com/kf/201109/104717.html

 

http://blog.163.com/guan123long@126/blog/static/131337312200993095721539/

 

 

转自：http://www.cnblogs.com/wuqi1003/archive/2013/01/09/2853657.html

（3）C语言函数返回数组的问题

有些时候需要子函数将一个数组返回出来，通常是两种方法，一种是靠指针，另一种是结构体。

一、先来看依靠指针怎么做

例程1：

 1 #include "stdio.h"
 2 
 3 char *test(char *tmp)
 4 {
 5     return tmp;
 6 }
 7 
 8 void main(void)
 9 {
10     printf("%s",test("第一个测试例子\n"));
11 }

 

例程1中的test函数如果写成下面的形式，就无法顺利编译。

例程2：

 1 #include "stdio.h"
 2 
 3 char *test()
 4 {
 5     //char tmp[30]="第一个测试例子\n";//写成这样编译时弹出警告，最后的结果也是乱码
 6     char *tmp="第一个测试例子";//写成这样可以用指针返回数组首地址
 7     return tmp;
 8 }
 9 
10 void main(void)
11 {
12     printf("%s",test());
13 }

之所以*tmp可以而tmp[30]不可以，是因为tmp[30]是个局部变量，子函数结束时该数组地址虽然没变，但是里面的值已经无意义了，而*tmp是定义了一个全局变量。

但是有些时候我们必须用到类似tmp[30]而不是*tmp，这时就要用到static这个关键字：

例程3：

按 Ctrl+C 复制代码
按 Ctrl+C 复制代码

 在数组tmp[30]前面加入了static关键字,它就使得tmp[30]存放在内存中的静态存储区中,所占用的存储单元一直不释放直到整个程序运行结束.所以当主函数调用完print()函数后,该空间依然存在.所以main()函数中接到首地值后可以访问数组中的元素.

二、使用结构体作为返回值来传递数组：

 1 #include "stdio.h"
 2 #include "string.h"
 3 
 4 struct ret
 5 {
 6     char buf[30];
 7 };//定义结构体时不要忘了分号
 8 
 9 struct ret test(char *tmp)
10 {
11     struct ret a;
12     strcpy(a.buf,tmp);
13     return a;
14 }
15 
16 
17 void main(void)
18 {
19     struct ret b;
20     b=test("用结构体作为返回值传递数组");
21     printf("%s",b.buf);
22 }

两点注意：

1、数组之间的赋值不要直接，即不要直接将数组A赋给数组B，而是要用strcpy（字符型数组）或者memcpy（非字符型数组）。

2、用结构体定义变量和函数时不要忘了结构体名（上面程序的ret）。

 

 

（3）源程序

  1. #include<</SPAN>stdio.h>
  2. #define N 5
  3. int *print()
  4. {
  5.     int a[N];
  6.     int i;
  7.     for(i=0;i<</SPAN>N;i )
  8.         a[i]=i;

  10.     return a;
  11. }
  12. int main()
  13. {
  14.     int *b,i;
  15.     b=print();
  16.     
  17.     for(i=0;i<</SPAN>N;i )
  18.      printf("%d\n",b[i]);

  20.     return 0;
  21. }

     这个类子就是一个函数返回数组,运行结果是错误的.原因在于: 在函数print()里面 ,数组a[N]是一个局部变量,当你函数执行完之后,会自动释放其空间,所以 return a这句只是返回了一个指向数组a[N]的地值.而在主函数中,b应该接收的是数组a[N]的地址(即数组本身的地址),而它所占用的空间随着函数的调用完毕也随之被释放掉了,所以得到的答案是不正确的.


就函数的返回值是数组而言,经过底下的两种修改,会得到正确答案,代码如下:

点击(此处)折叠或打开

  1. #include<</SPAN>stdio.h>
  2. #include<</SPAN>stdlib.h>
  3. #define N 5
  4. int *print()
  5. {
  6.     static int a[N];
  7.     int i;
  8.     for(i=0;i<</SPAN>N;i )
  9.         a[i]=i;

  11.     return a;
  12. }
  13. int *print1()
  14. {
  15.     int *a;
  16.     int i;
  17.     a=(int *)malloc(N);
  18.     for(i=0;i<</SPAN>N;i )
  19.     {
  20.         a[i]=i;
  21.     }

  23.     return a;
  24. }
  25. int main()
  26. {
  27.     int *b;
  28. //    int b[N];
  29.     int i;
  30.     b=print1();
  31.     
  32.     for(i=0;i<</SPAN>N;i )
  33.      printf("%d\n",b[i]);

  35.     return 0;
  36. }
无论是调用print()函数还是调用print1()函数都能得到正确结果.原因如下
调用print()函数:
     在数组a[N]前面加入了static关键字,它就使得a[N]存放在内存中的静态存储区中,所占用的存储单元不释放直到整个整个程序运行结束.所以当主函数调用完print()函数后,该空间依然存在.所以main()函数中b指针接收到这个数组的首地值后可以访问数组中的元素.
调用print1()函数:
     把数组a[N]换为指针*a,再给这个指针申请空间,也可以正常运行.因为当给指针a申请空间时,给指针分配的空间在堆上,堆上的空间是由程序员自动给予分配和释放的.若程序员不释放,程序结束时可能由OS释放.所以main函数中b指针也可以接收到这段空间的首地值,得到正确的答案.
     

当把main函数中的 int *b注释掉 换成int b[N] 会出现错误
test.c:30: warning: assignment makes integer from pointer without a cast
或者test.c:30: error: incompatible types when assigning to type ‘int[5]’ from type ‘int *’
都不能得到正确结果,原因如下:
main函数中 b得到的返回值是该数组的首地值,如果是*b,就是指针b指向这个数组的首地值,使指针变量向后移动就可以访问该数组中的所有元素.  而如果是b[N]的话,相当于编译器在栈上给数组b[N]分配了N个int空间,所以b指向a的首地值,不能通过这个地址,修改其自身申请的值.只能通过一个指针通过这个首地值,让指针向后移动来访问源数据.而且因为b没有进行初始化,所以得到的是随机值.

 

喜欢

0

阅读┊ 收藏 ┊ 喜欢▼ ┊打印┊举报/Report
  

新浪BLOG意见反馈留言板　欢迎批评指正

新浪简介 | About Sina | 广告服务 | 联系我们 | 招聘信息 | 网站律师 | SINA English | 产品答疑

Copyright © 1996 - 2022 SINA Corporation, All Rights Reserved

新浪公司 版权所有