C-指向指针数组的指针

Question

我正在学习C，因为我陷入了指针章节。 指向指针（** p）的指针的部分，用于处理2维数组。

以下函数生成一个2维数组，其所有元素均等于0。

double** example(int rows, int cols){
    static double tr[rows][cols];
    for(int i = 0; i < rows; i++)
       for(int j = 0; j < cols; j++)
            tr[j][i] = 0;
    return tr;
    }
int main(void){

    double **tr;
    int m = 2 ;
    int n = 2 ;

    tr = transpose(m, n);
    return 0;}

函数返回的tr是指向tr数组第一个元素的“双指针”吗？ 还是要其价值？ 另外，现在（在调用函数之后）如何在** tr指向的内存部分访问数组的元素？

有人可以解释一下这一切如何运作吗？ 还是建议我在其中写一篇文章或一章呢？

Answer 1

在C语言中，函数必须返回与函数类型相同的值/变量。 在此示例中，tr将是一个双指针，它指向第一行。

当使用双指针创建2D数组时，实际上是在创建一个指向指针数组的指针，该数组内的指针指向存储在每一行中的字符串/值。 双指针将指向指针数组中的第一个指针，该指针数组将指向第一行中的第一个元素。

您可以使用括号符号（例如tr[row][column]或*(*(tr + row) + column)来访问2D数组中的值。 对于第二种表示法， *(tr + row)将访问指向所需行的指针，然后可以使用*(found_row + column)引用该值，从而在所需列中提供元素。

Answer 2

提出的程序是完全不正确的。 可变长度数组可能没有静态存储持续时间/根据C标准（6.7.6.2数组声明符）

2如果一个标识符被声明为具有可变修改的类型，则它应该是一个普通标识符（如6.2.3中所定义），没有链接，并且具有块范围或函数原型范围。 如果一个标识符被声明为具有静态或线程存储持续时间的对象，则该标识符不得具有可变长度的数组类型。

此外，指针类型double **和double ( * )[cols] （假定正确声明的数组将在表达式中转换为指针类型）不兼容。 所以功能是错误的。

double** example(int rows, int cols){
    static double tr[rows][cols];
    for(int i = 0; i < rows; i++)
       for(int j = 0; j < cols; j++)
            tr[j][i] = 0;
    return tr;
    }

这是一个演示程序，显示了如何处理可变长度数组。

#include <stdio.h>

void init( size_t rows, size_t cols, double a[rows][cols] )
//  or
//  void init( size_t rows, size_t cols, double a[][cols] )
//  or
//  void init( size_t rows, size_t cols, double ( *a )[cols] )
{
    for ( size_t i = 0; i < rows; i++ )
    {
        for ( size_t j = 0; j < cols; j++ ) a[i][j] = 0.0;
    }
}

void display( size_t rows, size_t cols, double a[rows][cols] )
//  or
//  void display( size_t rows, size_t cols, double a[][cols] )
//  or
//  void display( size_t rows, size_t cols, double ( *a )[cols] )
{
    for ( size_t i = 0; i < rows; i++ )
    {
        for ( size_t j = 0; j < cols; j++ ) printf( "%lf", a[i][j] );
        putchar( '\n' );
    }
}

int main(void) 
{
    while ( 1 )
    {
        size_t m, n;

        printf( "Enter numbers of rows and columns (0 - exit): " );

        if ( scanf( "%zu%zu", &m, &n ) != 2 || m == 0 || n == 0 ) break;

        double a[m][n];

        putchar( '\n' );

        init( m, n, a );
        display( m, n, a );

        putchar( '\n' );
    }

    return 0;
}

它的输出可能看起来像

Enter numbers of rows and columns (0 - exit): 2 3

0.0000000.0000000.000000
0.0000000.0000000.000000

Enter numbers of rows and columns (0 - exit): 3 4

0.0000000.0000000.0000000.000000
0.0000000.0000000.0000000.000000
0.0000000.0000000.0000000.000000

Enter numbers of rows and columns (0 - exit): 0 0

在这两个函数中，第三个参数被调整为指针类型double ( *a )[cols] 。 它与double **a 。

例如，如果您要编写以下程序

#include <stdio.h>

#define M   2
#define N   3

int main(void) 
{
    int a[M][N] =
    {
        { 1, 2, 3 },
        { 4, 5, 6 }
    };

    int **p = ( int ** )a;

    p[0][0] = 10;

    return 0;
}

那么它将具有未定义的行为，因为p[0]考虑存储在元素a[0][0]的值（或存储在元素a[0][0]和a[0][1]的组合值，具体取决于指针的大小）（即指针的值1）作为指针值，并尝试访问表达式p[0][0]中地址1的内存。

Answer 3

扔掉包含此代码的书-它甚至无法正确编译 。 我收到以下错误：

[fbgo448@n9dvap997]~/prototypes/buf: gcc -o stack -std=c99 -pedantic-errors -Wall stack.c
stack.c: In function âexampleâ:
stack.c:2: error: storage size of âtrâ isnât constant
stack.c:6: error: return from incompatible pointer type

您不能创建具有static存储持续时间的可变长度数组。 具有static存储持续时间的对象是在程序启动时分配的，因此需要在编译时知道它们的大小。 除非您在运行时知道其尺寸大小，否则无法实例化VLA。

除非它是sizeof或一元&运算符的操作数，或者是用于在声明中初始化字符数组的字符串文字，否则类型“ T N元素数组”的表达式将被转换（“ decay”）为类型为“指向T指针”的表达式，该表达式的值将是数组第一个元素的地址。

表达 tr具有类型“ rows的阵列-元素cols的-元素阵列double ”; 在return语句，这种表达将“衰变”输入“指针cols的-元素阵列double ”，或double (*)[cols] 这是与double ** 完全不同的类型 。

多重间接显示了很多东西，但这不是一个有效的例子。

当您希望函数写入指针类型的参数时，通常会看到多个间接寻址：

void bar( T **p ) // for any type T
{
  *p = new_pointer_value();  // write a new value to the thing p points to
}

void foo( void )
{
   T *ptr;

   bar( &ptr ); // bar writes a value to ptr
}

您可以使用多种间接创建一种有点像2D数组的外观和行为的结构，但这与2D数组不同：

double **arr;
size_t rows = some_number_of_rows();
size_t cols = sime_number_of_cols();

arr = malloc( sizeof *arr * rows ); // allocates an array of pointers to double
if ( arr )
{
  for ( size_t i = 0; i < rows; i++ )
  {
    arr[i] = malloc( sizeof *arr[i] * cols ); // allocates an array of double
  }
}

完成后，您将具有如下结构：

   +---+       +---+      +---+---+---+     +---+
a: |   |  ---> |   | ---> |   |   |   | ... |   |
   +---+       +---+      +---+---+---+     +---+
               |   | -+
               +---+  |   +---+---+---+     +---+
                ...   +-> |   |   |   | ... |   |
               +---+      +---+---+---+     +---+
               |   | -+
               +---+  |   +---+---+---+     +---+
                      +-> |   |   |   | ... |   |
                          +---+---+---+     +---+

您可以使用常规下标符号（ a[i][j] ）来访问元素，例如2D数组，但是此结构的内存不会像2D数组那样连续分配：

   +---+---+---+---+---+ 
a: |   |   |   |   |   |
   +---+---+---+---+---+
   |   |   |   |   |   |
   +---+---+---+---+---+
   |   |   |   |   |   |
   +---+---+---+---+---+
   ...