C++ 如何在C+中引用二维数组（矩阵）的列+；

我已经用以下方式声明了一个2D数组（请注意，我是一个非常初学者！）

---

但问题是，如何引用？像[][i]这样的东西

二维数组看起来像这样

如果ur 2d数组是[i][j] 然后我将是你的行，j将是你的列

如果你想访问第一行的列，你可以这样做 a[0][1]a[0][2]a[0][3]

查看链接，它将为您清除更多信息

---

< P>行和列有点抽象，如果你想（10列，或者5列，如果你明白我的意思），你可以考虑空间方向。但显然，你需要保持你的使用一致

---

将“outer”数组保留在列中可能是有意义的，因此[x][y]在笛卡尔坐标类型中是有意义的。从您的示例中，您希望像[i][]一样进行索引（即，您的i索引是列或X坐标）。

您不能以这种方式引用列。这是因为你没有真正的矩阵，你指定了一个数组数组。数组是您的行，但列不是直接存储的。如果想要得到一整列，必须遍历所有行，接收存储在该列中的值并将其存储在不同的数组中

auto column = new double[10];
for(int i = 0; i < 10; i++){
    column[i] = A[i][2] //if you want to get the 2nd column
}

auto列=新的双精度[10]；
对于（int i=0；i<10；i++）{
column[i]=A[i][2]//如果要获取第二列
}

您不能直接访问列

您可以通过[i]（数组本身）或元素a[i][j]（在本例中为单双精度）访问行

如果你想得到一个列，你必须迭代抛出数组

for(unsigned int i = 0; i < 10; i++) 
{
    A[i][2] // do something
}

for（无符号整数i=0；i<10；i++）
{
A[i][2]//做点什么
}

访问第三列

因此，如果您想创建10x5或5x10矩阵，考虑一下这一点很有用。如果经常只需要处理一行或一列，则最好反转阵列布局（此处切换列和行）

编辑： 以下是一些简单的解释： 想象一下下面的代码

int** A = new int*[2];

for(int i=0;i<2;i++)
     A[i]=new int[3];
// more init code

int**A=新的int*[2]；
对于（int i=0；i任何行的元素都可以由
arr[row_num][i]
引用

类似地，任何列的元素都可以由
arr[i][col\u num]
引用

请注意，索引在C/C++中是以零为基础的。因此，如果列/行大小为
x
，
i
可以从
0
到
x-1

由于您是初学者，我还想告诉您更多关于C/C++中的数组的信息。首先，如果您不熟悉指针，我建议您阅读有关指针的内容

当您声明数组时，例如int arr[10]，arr[0]表示第一个元素。此外，arr+0（或简称arr）表示第一个元素的地址。类似地，arr[i]表示第i个元素，arr+i表示第i个元素的地址。要在地址打印值，在c/c++中，您可以使用运算符处的值，表示为（*），例如*（arr+i）将等同于arr[i]，即第i个元素。此外，运算符（&）的地址赋予元素的地址，&arr[i]等同于（arr+i）

如果arr是一个二维数组，arr[i][j]表示第i行的第j个元素。arr[i]表示第i行第一个元素的地址。c/c++是行主元素，表示第一行先填充，然后再填充，依此类推。在声明二维数组时，我们必须始终指定行大小

注意：在指针算法中，arr+i和arr+i+1等不是按1递增，而是按它所指向的元素的大小递增

因此，要引用行，我们可以执行以下操作：

//note that arr[row_num] is an address
int * new_1d_arr = arr[row_num];
for(int i = 0; i < row_size; i++)
    cout << new_1d_arr[i] << endl;

//注意arr[row_num]是一个地址
int*new_1d_arr=arr[row_num]；
对于（int i=0；i不能用其他方法使用指针

    // Matrix dimentions

    int n_rows = 10;
    int n_cols = 5;

    // create rows as pointers to columns 

    double **A = new double*[n_rows];

    // create columns 

    for (int i = 0; i < n_rows; i++)
    {
        A[i] = new double[n_cols];
    }

    // Fill our matrix

    int count=0;

    for (int i = 0; i < n_rows; i++)
    {
        for (int j = 0; j < n_cols; j++)
        {
            A[i][j]=count;
            ++count;
        }
    }   

    // Create pointers columns

    double ***A_t = new double**[n_cols];

    // create matrix pointers rows

    for (int i = 0; i < n_cols; i++)
    {
        A_t[i] = new double*[n_rows];
    }

    // And fill it with pointers to transposed main matrix elements
    for (int i = 0; i < n_rows; i++)
    {
        for (int j = 0; j < n_cols; j++)
        {
            A_t[j][i]=&A[i][j];
        }
    }

    // output first row/column for each case 

    for (int i = 0; i < n_cols; i++)
    {
          cout << *(A[0]+i) << endl;
    }

    cout << "-------------"<< endl;

    for (int i = 0; i < n_rows; i++)
    {
          cout << **(A_t[0]+i) << endl;
    } 

// Work with matrices here

// Don't forget to clean everything.

//矩阵尺寸
int n_行=10；
int n_cols=5；
//创建行作为指向列的指针
双精度**A=新的双精度*[n_行]；
//创建列
对于（int i=0；i这就是问题所在，我想去掉这个for循环迭代。@Ehsan我添加了一个小解释，为什么需要循环。除非你存储矩阵两次（正常和转置）
//note that arr[row_num] is an address
int * new_1d_arr = arr[row_num];
for(int i = 0; i < row_size; i++)
    cout << new_1d_arr[i] << endl;

    // Matrix dimentions

    int n_rows = 10;
    int n_cols = 5;

    // create rows as pointers to columns 

    double **A = new double*[n_rows];

    // create columns 

    for (int i = 0; i < n_rows; i++)
    {
        A[i] = new double[n_cols];
    }

    // Fill our matrix

    int count=0;

    for (int i = 0; i < n_rows; i++)
    {
        for (int j = 0; j < n_cols; j++)
        {
            A[i][j]=count;
            ++count;
        }
    }   

    // Create pointers columns

    double ***A_t = new double**[n_cols];

    // create matrix pointers rows

    for (int i = 0; i < n_cols; i++)
    {
        A_t[i] = new double*[n_rows];
    }

    // And fill it with pointers to transposed main matrix elements
    for (int i = 0; i < n_rows; i++)
    {
        for (int j = 0; j < n_cols; j++)
        {
            A_t[j][i]=&A[i][j];
        }
    }

    // output first row/column for each case 

    for (int i = 0; i < n_cols; i++)
    {
          cout << *(A[0]+i) << endl;
    }

    cout << "-------------"<< endl;

    for (int i = 0; i < n_rows; i++)
    {
          cout << **(A_t[0]+i) << endl;
    } 

// Work with matrices here

// Don't forget to clean everything.