【问题标题】:C - pointer to pointer arrayC - 指向指针数组的指针
【发布时间】:2017-08-25 23:19:39
【问题描述】:

我正在学习 C,因为我被困在指针章节。特别是指向指针(**p)部分的指针,用于处理二维数组。

以下函数生成一个所有元素都等于 0 的 2 维数组。

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 指向的内存部分的数组元素?

有人可以解释一下这一切是如何工作的吗?或者建议我写一篇文章或一本书的章节?

【问题讨论】:

  • example 返回指向第一个元素的双指针。您可以以与函数中相同的方式访问它的元素,即tr[0][1]
  • 扔掉这本书,它在教你垃圾。请参阅下面的弗拉德的回答。 double ** 不是返回二维数组的正确类型。

标签: c arrays pointers memory-management types


【解决方案1】:

提供的程序完全不正确。可变长度数组可能没有静态存储持续时间/根据 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 处的内存。

【讨论】:

    【解决方案2】:

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

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

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

    【讨论】:

    • 问题是tr的类型不是 double **,是double (*)[cols]。
    【解决方案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 或一元&amp; 运算符的操作数,或者是用于在声明中初始化字符数组的字符串文字,否则表达式 类型为“N- “T”的元素数组将被转换(“衰减”)为“指向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
    }
    

    您可以使用多重间接来创建一个看起来和行为都类似于二维数组的结构,但它与二维数组不同:

    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]) 访问元素,但该结构的内存不会像二维数组那样连续分配:

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

    【讨论】:

      猜你喜欢
      • 1970-01-01
      • 1970-01-01
      • 2013-04-19
      • 2023-03-11
      • 2017-06-11
      • 1970-01-01
      • 1970-01-01
      • 2010-10-25
      相关资源
      最近更新 更多