指向数组的指针和指向数组的指针

Question

有人可以给我一个简短的解释，在下面的函数中发生了什么不同？

    void f1(data_t **d)
    {
        for (int i=0; i<MAXSIZE; i++)
        {
            (*d)[i].ival = i;
        }
    }

    void f2(data_t **d)
    {
        for (int i=0; i<MAXSIZE; i++)
        {
            (*d)->ival = i;
            (*d)++
        }
    }

    void f3(data_t *d)
    {
        for (int i = 0; i<MAXSIZE; i++)
        {
            d->ival = i;
            d++;
        }
    }

    void f4(data_t *d)
    {
        for (int i = 0; i<MAXSIZE; i++)
        {
            d[i].ival = i;
        }
    }

特别是在f2中发生的不同情况。但很明显，每种情况都在发生不同的事情。

f1和f3做同样的事情(但不同)。f2完全失败，并且f4有错误(在本例中是有效的，但当我尝试将其他值放入其他指针(char *)时，字符串最终变得奇怪)。

Answer 1

void f1(data_t **d)
{
    for (int i=0; i<MAXSIZE; i++)
    {
        (*d)[i].ival = i;
    }
}

D似乎是指向data_t数组的指针(或者是data_t数组的1元素数组)。它被解除引用以恢复data_t数组，然后修改此数组的第i个元素。

void f2(data_t **d)
{
    for (int i=0; i<MAXSIZE; i++)
    {
        (*d)->ival = i;
        (*d)++
    }
}

这有点棘手，确实做了一些与第一种情况不同的事情。有一个指向data _t数组的指针。这里我们有一个指向data_t的指针数组。指向第一个元素的指针被解除引用，以检索指向数据的指针。然后使用->访问数据并修改值( x->y = (*x).y )。最后，指针移动到主数组的下一个元素。

void f3(data_t *d)
{
    for (int i = 0; i<MAXSIZE; i++)
    {
        d->ival = i;
        d++;
    }
}

这里我们有一个更简单的例子，d只是一个由指针访问的data_t数组。在循环中，->访问一个元素，然后d递增以指向数组的下一个元素。

void f4(data_t *d)
{
    for (int i = 0; i<MAXSIZE; i++)
    {
        d[i].ival = i;
    }
}

与f3类似，元素由[]运算符修改。

请注意以下事实：

int[] =(def) int *

如果a是int *类型，而i是任何整数类型，则：

*(a + i) =(def) a[i]

此外，如果指向数组的第一个元素，则

*a =(def) a[0]

然后，在"a++“之后

*a =(def) a[1]

...and等等。

Answer 2

让我们一次只看一个：

// f1
(*d)[i].ival = i;

首先，(*d)取消了对d的引用，它似乎是指向data_t变量数组的指针。这允许访问实际的数组，这样[i]就可以访问数组的i-th元素，并将i分配给它。

// f2
(*d)->ival = i;
(*d)++;

(*d)正在取消对d的引用，就像第一个一样。然而，在继续学习之前，有一点关于数组的关键信息是您应该了解的……

int j[2] = { 42, 50 };
int j0 = *j; // j0 is now 42
j += 1;
int j1 = *j; // j1 is now 50

数组被实现为在内存中的“槽”中顺序定向的单个变量，而数组实际上只是指向第一个槽的指针。因此，*j将取消引用当前指向第一个元素的j，从而产生42。执行j += 1会使指针前进一个“槽”，这样*j现在就会产生50。

现在，回到f2。(*d)->ival和做(**d).ival完全一样。这与我上面给出的简单示例非常相似。下一行，(*d)++，将指针移到下一个“槽”。考虑一下内存中“发生了什么”的简单图表：

      +------+------+
      |*(j+0)|*(j+1)|
j --->|------|------|
      |  42  |  50  |
      +------+------+

j指向第一个“槽”，第一行显示取消引用，第二行显示值。

f3与f2非常相似，不同之处在于它希望数组作为参数传递，而不是指向它的指针。因此，d只需要使用->操作符取消引用一次(同样，与(*d).ival完全相同)。

f4与f1非常相似，不同之处在于它希望数组作为参数传递，而不是指向它的指针。因此，d[i]直接访问数组的i-ith元素。

Answer 3

 void f1(data_t **d) 
    { 
        for (int i=0; i<MAXSIZE; i++) 
        { 
            (*d)[i].ival = i; 
        } 
    } 

你会得到一个指向数组元素的指针，这个元素是一个结构，它包含一个字段，用于逐个元素地更改索引和更新每个数组元素的ival

• Access *d

• Iterate ival，to be i，

1. **d ival
2. Access the array *d
3. Iterate所有数组元素，一个元素接一个元素地更改索引

注意:您不使用t change the pointer*d`，指向数组开头

void f2(data_t **d) 
{ 
    for (int i=0; i<MAXSIZE; i++) 
    { 
        (*d)->ival = i; 
        (*d)++ 
    } 
} 

你会得到一个指向数组元素的指针，这个元素是一个结构，它有一个字段来筛选数组的开头，这也是一个指向数组的指针(first element)

• Updating **d of (

1. )**d of (上面) element by to be i，使用指针表示法)，指向下一个数组元素(*d)++ 2. to 2.的指针*d指向“筛选过的”数组的开头。

无效f3(data_t *d)

{ for (int i= 0；iival = i；d++；}}

1.您将得到一个data_t的数组结构，其元素是sa *d，它有一个字段ival。

2.也可以认为你得到了一个指向数组第一个元素的指针。访问访问并将ival更新为i，通过指针：d->ival = i;

3.将指针提升到下一个数组元素d++

无效f4(data_t *d)

{ for (int i= 0；i

与在f3.But中一样，您可以使用引用表示法(按值)提升索引和更新ival