C++ C++；动态/静态数组作为函数的参数

我一直试图用2D数组作为C++类中构造函数的参数。

标题：

Matrix::Matrix(double **initComponents, int rows, int columns)

如果我只是继续，对新的和初始化的子数组进行常规调用，将指针传递给构造函数，这一切都很好，但我在想，我能用初始化器创建静态2D数组并将指针传递给构造函数吗

double A[][3] = { {2.0, 3.0, 4.0} , {1.0, 3.0, 4.0} , {2.0, 3.0, 4.0} }; 
Matrix *mtx = new Matrix(A, 3, 3);

这是行不通的：(

MS Visual Studio编译器：

" error C2664: 'Matrix::Matrix(double **,int,int)' : cannot convert parameter 1 from 'double [3][3]' to 'double ** "

有人能解释为什么吗？我想它会在引用和指针之间进行自动转换

---

第二个问题是，为什么我可以将

A

声明为double

A[][]

，为什么我必须指定第二个维度，即使我指定了所有的值。

数组确实转换为指针，但它只适用于一个级别。数组不会转换为指向指针的指针

数组可以转换为指针，因为指针仍然提供了查找数组值的合理方法，但数组数组与指针数组是完全不同的。数组数组是连续存储在内存中的。例如，如果您有这样的定义：

int a[2][2] = {{1,2},{3,4}};

int a[][2] = {{1,2},{3,4}};

template<int rows, int cols>
Matrix(const double (&initComponents)[rows][cols])
{
  // initialize matrix elements here
}

然后在第一个内存位置中存储[0][0]，在第二个内存位置中存储[0][1]，在第三个内存位置中存储[1][0]，在第四个内存位置中存储[1][1]。当您要查找像[i][j]这样的特定元素时，编译器可以计算该位置，因为它知道数组的大小：

int value = ((int *)a)[i*2+j];

将其与指向指针的指针进行比较

int a0[2] = {1,2};
int a1[2] = {3,4};
int **a = {a0,a1};

现在，当您使用[i][j]时，编译器无法直接知道在哪里查找。它必须先查看[0]并查看它指向的位置，然后再查看第二次以查找值

int *ap = a[i];
int value = ap[j];

因为编译器必须使用不同的方法查找数组中的值和指向指针的指针，所以不能互换使用它们

同样，在这样的声明中：

int a[2][2] = {{1,2},{3,4}};

int a[][2] = {{1,2},{3,4}};

template<int rows, int cols>
Matrix(const double (&initComponents)[rows][cols])
{
  // initialize matrix elements here
}

省略第一个维度的大小是可以的，因为编译器将为您填充它，但这只适用于一个级别。原则上，编译器可以很好地猜测其他维度应该是什么，但这实际上是语言中的一个单独规则

如果确实希望能够传递2D数组，可以使用以下模板化构造函数：

int a[2][2] = {{1,2},{3,4}};

int a[][2] = {{1,2},{3,4}};

template<int rows, int cols>
Matrix(const double (&initComponents)[rows][cols])
{
  // initialize matrix elements here
}

---

数组确实转换为指针，但它仅适用于一个级别。数组数组不会转换为指向指针的指针

数组可以转换为指针，因为指针仍然提供了查找数组值的合理方法，但数组数组与指针数组是完全不同的。数组数组是连续存储在内存中的。例如，如果您有这样的定义：

int a[2][2] = {{1,2},{3,4}};

int a[][2] = {{1,2},{3,4}};

template<int rows, int cols>
Matrix(const double (&initComponents)[rows][cols])
{
  // initialize matrix elements here
}

然后在第一个内存位置中存储[0][0]，在第二个内存位置中存储[0][1]，在第三个内存位置中存储[1][0]，在第四个内存位置中存储[1][1]。当您要查找像[i][j]这样的特定元素时，编译器可以计算该位置，因为它知道数组的大小：

int value = ((int *)a)[i*2+j];

将其与指向指针的指针进行比较

int a0[2] = {1,2};
int a1[2] = {3,4};
int **a = {a0,a1};

现在，当您使用[i][j]时，编译器无法直接知道在哪里查找。它必须先查看[0]并查看它指向的位置，然后再查看第二次以查找值

int *ap = a[i];
int value = ap[j];

因为编译器必须使用不同的方法查找数组中的值和指向指针的指针，所以不能互换使用它们

同样，在这样的声明中：

int a[2][2] = {{1,2},{3,4}};

int a[][2] = {{1,2},{3,4}};

template<int rows, int cols>
Matrix(const double (&initComponents)[rows][cols])
{
  // initialize matrix elements here
}

省略第一个维度的大小是可以的，因为编译器将为您填充它，但这只适用于一个级别。原则上，编译器可以很好地猜测其他维度应该是什么，但这实际上是语言中的一个单独规则

如果确实希望能够传递2D数组，可以使用以下模板化构造函数：

int a[2][2] = {{1,2},{3,4}};

int a[][2] = {{1,2},{3,4}};

template<int rows, int cols>
Matrix(const double (&initComponents)[rows][cols])
{
  // initialize matrix elements here
}

---

可能的重复就其价值而言，完全避免多维数组要容易得多。它们很少值得麻烦。我看不到任何数组参数。数组不是指针。说真的。基本上与可能的重复一样，完全避免多维数组要容易得多y很少值得麻烦。我看不到任何数组参数。光线不是指针。说真的。基本上和@user1125518:不一样。有一些模板魔法可以让它工作。你愿意去吗？@user1125518:不。有一些模板魔法可以让它工作。你愿意去吗？