C/C++从函数返回指针是常规操作，本文针对返回二维数组指针做了一些研究，并给出二维数组指针返回double **类型指针的结论。

常规C/C++函数返回二维数组指针

返回目录

返回值返回二维数组指针

首先看通过返回值返回二维指针的简单情况：

double** returnPointer2D(int n) {
    double* data = new double[n*n];
    double** ptr = new double*[n];
    for (int i = 0; i < n; ++i) {
        ptr[i] = data + i*n;
    }

    // 一些初始化代码

    return ptr;
}

上述代码中，数据内存从堆(heap)分配，因此函数结束后分配的存储空间依然可用。调用方式：

double** A = returnPointer2D(n);

传参返回二维数组指针

一些情况下，我们希望传入一个指针，其在函数内完成内存分配。这个要求稍微复杂点，其代码为：

void fromArgPointer2D(int n, double*** p) {
    double* data = new double[n*n];
    double** ptr = new double*[n];
    for (int i = 0; i < n; ++i) {
        ptr[i] = data + i*n;
    }

    // 一些初始化代码

    *p = ptr;
}

因为要改变二维指针的指向，传参方式需要引用方式传递二维数组指针，于是参数为double***类型。代码调用方式：

double** A;
fromArgPointer2D(n, A);

相对于返回值方式，参数方式理解上稍微难点，也还容易理解。

返回二维静态数组的double**指针

返回目录

接着来到本文的重点：返回二维静态数组的double**指针。

一眼看过去，这个需求很好实现：

#define N 10
double** staticPointer2D() {
    static double A[N][N];
    // 一些初始化代码
    return A;
}

遗憾的是，上面的代码无法编译通过，会出现如下错误：

error: cannot initialize return object of type 'double **' with an lvalue of type 'double [10][10]'

错误意思大概为A指向double [10][10]，但返回值要求double**，无法转换。

编译器不知道怎么转换，试试强制转换？

double** staticPointer2D() {
    static double A[N][N];
    // 一些初始化代码
    return (double**)A;
}

OK，编译没问题了，但问题转到了调用上：

double** A = staticPointer2D();
std::cout << "A[0][0]: " << A[0][0] << std::endl;

## 上面的代码不能按预期运行，会出现 Segment Fault(段错误)

问题出在了A的转换上：A[N][N]中的A其实是一维数组，每个值保存一个指针。

用下面代码验证我们的想法：

// 定义一维指针类型别名
// using定义类型是c++11中新增的语法
using Pointer1D double (*);
// 也可以用typedef定义
// typedef double* Pointer1D;

Pointer1D* staticPointer2D() {
    static double A[N][N];
    // 一些初始化代码
    
    // 下面转换成Pointer1D*返回
    // 必须用static，避免dangling指针
    static Pointer1D AA[N];
    for (int i = 0; i < N; ++ i) AA[i] = A[i];
    return AA;
}

调用上面的代码重新运行程序，完美，一切按照预期运行！

通过引入Pointer1D我们成功让程序运行了，但我们知道Pointer1D是double*的别名，因此实际上可以直接用double*的方式写代码：

double** staticPointer2D() {
    static double A[N][N];
    // 一些初始化代码
    
    // 转换成double*返回
    static double* AA[N];
    for (int i = 0; i < N; ++ i) AA[i] = A[i];
    return AA;
}

运行程序，也完全没毛病。至此我们顺利实现了从二维静态数组返回double**指针的目的。

但有个问题仍然没绕开：一定要引入新变量并初始化，不能直接(或通过类型转换)返回A吗？

答案是不能，因为直接(或通过类型转换)返回A存在信息丢失。

以3维方阵为例，double A[3][3]其实保存了12个数据信息：9个保存矩阵的值，这个很好理解；此外还需要额外3个double*数据，分别指向A的每一行起始位置。有了这12个数据，A[i][j]实际中会转换成如下方式取值：

*(*(A+i) + j)

即：根据i得到行的指针，再根据j偏移得到A[i][j]的指针，最后取值得到A[i][j]。

A[N][N]中的A本质上是一维数组，只保存了三个double*指针的值。将其强制转换成double**：double** a = (double**)A，a的值与A确实一样，但a[i] = A[i]！

可以通过下面代码验证：

double A[3][3] {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
std::cout << "A: " << A << std::endl;
std::cout << "A[0]: " << A[0] << std::endl;

double** a = (double**)A;
std::cout << "a: " << a << std::endl;
std::cout << "a[0]: " << a[0] << std::endl;

其输出结果为：

A: 0x7ffeeaf9b890
A[0]: 0x7ffeeaf9b890
a: 0x7ffeeaf9b890
a[0]: 0x3ff0000000000000

a确实和A相等，但是A[0]不等于a[0]！因为a[0]未赋值，取值a[0][0]程序直接就会挂掉！。

这就是为什么上面可正常运行的代码要引入一个额外数组，并初始化才能正常运行的原因。

其实，常规返回二维数组指针的代码已经透露了原因：生成二维数组，不仅需要double**的数据，还需要生成包含n个double*的数组并初始化：

double* data = new double[n*n];

double** ptr = new double*[n];

for (int i = 0; i < n; ++ i) ptr[i] = data + i*n;

而直接从A[N][N]直接转化，只对ptr赋值了，ptr[i]并没有初始化，出现Segment Fault也就在预料之中了。

总结

返回目录

本文介绍了三种C/C++函数返回二维数组指针的方式，并深入剖析了二维静态数组转换成double**存在的问题及解决方案。实际上，静态二维数组返回double**等同于该问题：如何将二维数组转换成double**指针?

通过上面的分析，我们知道直接转换的做法是行不通的，需要引入一个额外数组并初始化才能正确转换。

参考

返回目录

How to return a 2D array from a function in C?

C++在指定内存构造对象

分享