我有一个看起来像下面这样的程序：
double[4][4] startMatrix;
double[4][4] inverseMatrix;
initialize(startMatrix) //this puts the information I want in startMatrix
我现在想计算startMatrix的逆矩阵并将其放入inverseMatrix中。 我有一个用于此目的的库函数，其原型如下：
void MatrixInversion(double** A, int order, double** B)
我需要将 double[4][4] 转换为 double** 以传递给函数，该函数对 A 进行求逆并将结果放入 B 中。问题在于我不知道如何进行转换。我尝试了"显而易见的方式"：
MatrixInversion((double**)startMatrix, 4, (double**)inverseMatrix))
但这似乎不起作用。那真的是正确的做法吗？
double[4][4] 数组无法转换为 double ** 指针。这是实现2D数组的两种不兼容的选择。需要更改某些内容：要么更改函数的接口，要么更改作为参数传递的数组的结构。double[4][4] 数组与函数兼容，是创建临时的“索引”数组，类型为 double *[4]，指向每个矩阵中每行的开头。double *startRows[4] = { startMatrix[0], startMatrix[1], startMatrix[2] , startMatrix[3] };
double *inverseRows[4] = { /* same thing here */ };
并传递这些“index”数组。
MatrixInversion(startRows, 4, inverseRows);
当函数完成工作后，您可以忘记 startRows 和 inverseRows 数组，因为结果会被正确地放置到您原始的 inverseMatrix 数组中。
由于二维数组（一个连续的内存块）和指针数组（不连续）非常不同，因此您不能将二维数组传递给使用指向指针的函数。
您可以尝试使用模板。将第二个维度的大小作为模板参数。
#include <iostream>
template <unsigned N>
void print(double a[][N], unsigned order)
{
for (unsigned y = 0; y < order; ++y) {
for (unsigned x = 0; x < N; ++x) {
std::cout << a[y][x] << ' ';
}
std::cout << '\n';
}
}
int main()
{
double arr[3][3] = {{1, 2.3, 4}, {2.5, 5, -1.0}, {0, 1.1, 0}};
print(arr, 3);
}
另一种稍微笨拙的方法可能是使函数接受指向一维数组的指针，并将宽度和高度作为参数给出，并自己计算索引以转换成二维表示。
#include <iostream>
void print(double *a, unsigned height, unsigned width)
{
for (unsigned y = 0; y < height; ++y) {
for (unsigned x = 0; x < width; ++x) {
std::cout << a[y * width + x] << ' ';
}
std::cout << '\n';
}
}
int main()
{
double arr[3][3] = {{1, 2.3, 4}, {2.5, 5, -1.0}, {0, 1.1, 0}};
print(&arr[0][0], 3, 3);
}
由于您正在使用C++，处理这类问题的正确方式是使用自定义类和一些模板。以下示例比较粗糙，但它能够基本说明问题。
#include <iostream>
using namespace std;
template <int matrix_size>
class SquareMatrix
{
public:
int size(void) { return matrix_size; }
double array[matrix_size][matrix_size];
void copyInverse(const SquareMatrix<matrix_size> & src);
void print(void);
};
template <int matrix_size>
void SquareMatrix<matrix_size>::copyInverse(const SquareMatrix<matrix_size> & src)
{
int inv_x;
int inv_y;
for (int x = 0; x < matrix_size; x++)
{
inv_x = matrix_size - 1 - x;
for (int y = 0; y < matrix_size; y++)
{
inv_y = matrix_size - 1 - y;
array[x][y] = src.array[inv_x][inv_y];
}
}
}
template <int matrix_size>
void SquareMatrix<matrix_size>::print(void)
{
for (int y = 0; y < 4; y++)
{
for (int x = 0; x < 4; x++)
{
cout << array[x][y] << " ";
}
cout << endl;
}
}
template <int matrix_size>
void Initialize(SquareMatrix<matrix_size> & matrix);
int main(int argc, char * argList[])
{
SquareMatrix<4> startMatrix;
SquareMatrix<4> inverseMatrix;
Initialize(startMatrix);
inverseMatrix.copyInverse(startMatrix);
cout << "Start:" << endl;
startMatrix.print();
cout << "Inverse:" << endl;
inverseMatrix.print();
return 0;
}
template <int matrix_size>
void Initialize(SquareMatrix<matrix_size> & matrix)
{
for (int x = 0; x < matrix_size; x++)
{
for (int y = 0; y < matrix_size; y++)
{
matrix.array[x][y] = (x+1)*10+(y+1);
}
}
}
二维数组不是指向指针或类似内容的指针。您的 startMatrix 的正确类型是 double (*)[4]。对于您的函数，签名应该如下：
MatrixInversion( double (*A)[4], int order, double (*B)[4] );
有一种解决方案是使用指针通过bobobobo进行指向。
William Sherif（bobobobo）使用了C版本，我只想展示bobobobo答案的C++版本。
int numRows = 16 ;
int numCols = 5 ;
int **a ;
a = new int*[ numRows* sizeof(int*) ];
for( int row = 0 ; row < numRows ; row++ )
{
a[row] = new int[ numCols*sizeof(int) ];
}
其余的代码与bobobobo的相同。
如果你想的话，你绝对可以做像下面这样的代码。
template <typename T, int n>
class MatrixP
{
public:
MatrixP operator()(T array[][n])
{
for (auto i = 0; i < n; ++i) {
v_[i] = &array[i][0];
}
return *this;
}
operator T**()
{
return v_;
}
private:
T* v_[n] = {};
};
void foo(int** pp, int m, int n)
{
for (auto i = 0; i < m; ++i) {
for (auto j = 0; j < n; ++j) {
std::cout << pp[i][j] << std::endl;
}
}
}
int main(int argc, char** argv)
{
int array[2][2] = { { 1, 2 }, { 3, 4 } };
auto pa = MatrixP<int, 2>()(array);
foo(pa, 2, 2);
}
void MatrixInversion(double A [4] []，int order，double B [4] [])。double (&A)[4][4]，而不是 double A[][4]。至少它会保留完整的数组类型，而不是将其降级为 double (*)[4]。 - AnT stands with Russia如果使用C++，请写出漂亮的代码：
struct matrix {
double m[4][4];
};
matrix startMatrix;
matrix inverseMatrix;
因此，接口将会是：
void MatrixInversion(matrix &A, int order, matrix &B);
MatrixInversion(startMatrix, 4, inverseMatrix);
好处
或者这样
struct matrix {
void Inversion(matrix &inv, int order) {...}
protected:
double m[4][4];
};
matrix startMatrix;
matrix inverseMatrix;
...
一个丑陋的C语言方法
void MatrixInversion(void *A, int order, void *B);
MatrixInversion((void*)startMatrix, 4, (void*)inverseMatrix);
编辑：矩阵求逆的参考代码，不会崩溃：
void MatrixInversion(void *A, int order, void *B)
{
double _a[4][4];
double _b[4][4];
memcpy(_a, A, sizeof _a);
memcpy(_b, B, sizeof _b);
// processing data here
// copy back after done
memcpy(B, _b, sizeof _b);
}