能否定义这样一个函数，以一个整数为变量，以一个数组为返回值？
这个数组的维数大小是与变量有关的。比如说我们要定义这样的一个函数f，它以一个long int型的变量number为形参，以这个number的各个数位上的数字依次组成的数组为返回值。这个能够实现吗？尤其是，当这个数组的维数大小是不能预先得知的情况下。

如果可以的话，在C中是怎么样实现的，而在C++中又是怎么实现的？ 函数 返回值 数组
[解决办法]
需要多大的内存就申请多大的内存，返回指向该内存的指针
c用malloc
c++用new，还可以用std::vector
[解决办法]
运行时才能知道维数和大小的数组必须使用指针动态创建
[解决办法]
1、先定义个足够大的数组
2、可以得到各位上的数，按次序存放到数组中
3、再根据实际数组大小，分配空间，返回即可

===============================
没有做不到只有想不到

[解决办法]

引用:

Quote: 引用:

运行时才能知道维数和大小的数组必须使用指针动态创建

我觉得好像动态分配内存的话不能用于函数的返回值的吧。另外我觉得可以用C++的vector来实现。

为什么不能？只是调用者必须负责释放返回的指针，否则会造成内存泄漏

vector之类的封装类，事实上本质都是指针，只是类代码把你和指针隔离开，代码负责指针的申请、释放、增长缩小等操作
[解决办法]
无论几维的数组，实质上都是内存中一个连续的区域，计算机里面是没有多维的概念的，你这里可以返回一个数据内存的指针，然后使用输出变量返回根据number计算得到的维数信息，然后就封装一个函数进行多维数组的访问就可以了。
char* f(int number, int** dimension， int* dimension_len)
{
char* b = new char[number];
// 计算得到是3维，则
*dimension_len = 3;
*dimension = new int[*dimension_len];
// 填充dimension数组
return b;
}
char get_data(char * buffer, int *dimension, int x, int y, int z)
{
return buffer[(dimension[1]*dimension[2])*x + dimension[2]*y + z];
}

int main()
{
int * dimension;
int dimension_len;
char* buff = f(number, &dimension, &dimension_len);
char data = get_data(buff, dimension, 1, 0, 0);
delete [] buff;
delete [] dimension;
return 0;
}

大概就是这样了
[解决办法]
参考以下代码，改为递归即可实现动态数组维数：

//在堆中开辟一个4×5的二维int数组
#include <stdio.h>
#include <malloc.h>
int **p;
int i,j;
void main() {
    p=(int **)malloc(4*sizeof(int *));
    if (NULL==p) return;
    for (i=0;i<4;i++) {
        p[i]=(int *)malloc(5*sizeof(int));
        if (NULL==p[i]) return;
    }
    for (i=0;i<4;i++) {
        for (j=0;j<5;j++) {
            p[i][j]=i*5+j;
        }
    }
    for (i=0;i<4;i++) {
        for (j=0;j<5;j++) {
            printf(" %2d",p[i][j]);
        }
        printf("\n");
    }
    for (i=0;i<4;i++) {
        free(p[i]);
    }
    free(p);
}
//  0  1  2  3  4
//  5  6  7  8  9
// 10 11 12 13 14
// 15 16 17 18 19

//在堆中开辟一个3×4×5的3维int数组
#include <stdio.h>
#include <malloc.h>
int ***p;
int i,j,k;
void main() {
    p=(int ***)malloc(3*sizeof(int **));
    if (NULL==p) return;
    for (i=0;i<3;i++) {
        p[i]=(int **)malloc(4*sizeof(int *));
        if (NULL==p[i]) return;
        for (j=0;j<4;j++) {
            p[i][j]=(int *)malloc(5*sizeof(int));
            if (NULL==p[i][j]) return;
        }
    } 
 
    for (i=0;i<3;i++) {
        for (j=0;j<4;j++) {
            for (k=0;k<5;k++) {
                p[i][j][k]=i*20+j*5+k;
            }
        }
    }
    for (i=0;i<3;i++) {
        for (j=0;j<4;j++) {
            for (k=0;k<5;k++) {
                printf(" %2d",p[i][j][k]);
            }
            printf("\n");
        }
        printf("---------------\n");
    }
    for (i=0;i<3;i++) {
        for (j=0;j<4;j++) {
            free(p[i][j]);
        }
        free(p[i]);
    }
    free(p);
}
//  0  1  2  3  4
//  5  6  7  8  9
// 10 11 12 13 14
// 15 16 17 18 19
//---------------
// 20 21 22 23 24
// 25 26 27 28 29
// 30 31 32 33 34
// 35 36 37 38 39
//---------------
// 40 41 42 43 44
// 45 46 47 48 49
// 50 51 52 53 54
// 55 56 57 58 59
//---------------

//在堆中开辟一个2×3×4×5的4维int数组
#include <stdio.h>
#include <malloc.h>
int ****p;
int h,i,j,k;
void main() {
    p=(int ****)malloc(2*sizeof(int ***));
    if (NULL==p) return;
    for (h=0;h<2;h++) {
        p[h]=(int ***)malloc(3*sizeof(int **));
        if (NULL==p[h]) return;
        for (i=0;i<3;i++) {
            p[h][i]=(int **)malloc(4*sizeof(int *));
            if (NULL==p[h][i]) return;
            for (j=0;j<4;j++) {
                p[h][i][j]=(int *)malloc(5*sizeof(int));
                if (NULL==p[h][i][j]) return;
            }
        }
    }
    for (h=0;h<2;h++) {
        for (i=0;i<3;i++) {
            for (j=0;j<4;j++) {
                for (k=0;k<5;k++) {
                    p[h][i][j][k]=h*60+i*20+j*5+k;
                }
            }
        }
    }
    for (h=0;h<2;h++) {
        for (i=0;i<3;i++) {
            for (j=0;j<4;j++) {
                for (k=0;k<5;k++) {
                    printf(" %3d",p[h][i][j][k]);
                }
                printf("\n");
            }
            printf("--------------------\n");
        }
        printf("=======================\n");
    }
    for (h=0;h<2;h++) {
        for (i=0;i<3;i++) {
            for (j=0;j<4;j++) { 
 
                free(p[h][i][j]);
            }
            free(p[h][i]);
        }
        free(p[h]);
    }
    free(p);
}
//   0   1   2   3   4
//   5   6   7   8   9
//  10  11  12  13  14
//  15  16  17  18  19
//--------------------
//  20  21  22  23  24
//  25  26  27  28  29
//  30  31  32  33  34
//  35  36  37  38  39
//--------------------
//  40  41  42  43  44
//  45  46  47  48  49
//  50  51  52  53  54
//  55  56  57  58  59
//--------------------
//=======================
//  60  61  62  63  64
//  65  66  67  68  69
//  70  71  72  73  74
//  75  76  77  78  79
//--------------------
//  80  81  82  83  84
//  85  86  87  88  89
//  90  91  92  93  94
//  95  96  97  98  99
//--------------------
// 100 101 102 103 104
// 105 106 107 108 109
// 110 111 112 113 114
// 115 116 117 118 119
//--------------------
//=======================
//

[解决办法]
返回的是指针吧 ，另形参传进去后，就可以算出位数吧，再来分配