C 指针所需的基本帮助（双间接）

不久前，我问了一个我不记得如何操作基本指针的帐户，有人给了我一个非常好的演示

比如说

char *ptr = "hello" (hello = a char array)

所以现在ptr指向“h”

ptr++

意味着将

ptr

移动到下一个元素，以获取其值I do

*ptr

，从而得到

e

---

好的，到目前为止一切都如我所愿：D，但现在我需要操纵一个

char**ptr

，我想知道我是如何模仿2d数组的效果来实现这一点的

我需要做一个作业，这个作业有一个

**ptr

来模拟一个2d数组，如果我不知道它是如何做的，那么我甚至无法在纸上解决它（例如，如何取消引用

**ptr

，如何获得

[x][y]

值等），我会非常感激一些基本的技巧

---

谢谢

指向指针的指针就是这样。例如：

// Declare our double-indirection pointer.
char** ptr;
// And initialize it:
char s1[] = "hello";
char s2[] = "world";
ptr = malloc(sizeof(char*) * 2);
ptr[0] = s1;
ptr[1] = s2;
// ptr now points to a pointer that points to 'h'.
char* ptr2 = *ptr;
// ptr2 points to 'h'.
char* ptr3 = *(ptr + 1);
// ptr3 points to "w".
char c = **ptr; // could be written as *(*ptr)
// c = 'h'.
char c2 = *(*(ptr + 1));
// c2 = 'w'.
char c3 = *(*(ptr) + 1);
// c3 = 'e'.

---

您可以像使用普通二维数组一样使用它们。（事实上，他们就是这样）

这是因为：

int *a;
//...
int i = a[6];
int j = *(a + 6); //Same as previous line!

干杯

---

Amit Ron--

如果所有地址都已正确设置，则可以使用与为数组下标相同的方法为指针下标

假设声明如下：

char **ptr;

以下是各种表达式的类型：

Expression Type Equivalent expressions (yield same value) ---------- ---- ----------------------------------------- ptr char ** &ptr[0] *ptr char * ptr[0] *(ptr+i) char * ptr[i]; &ptr[i][0] **ptr char ptr[0][0] *(*(ptr+i)) char ptr[i][0]; *ptr[i] *(*(ptr+i)+j) char ptr[i][j] 或

通常，当您将指针当作数组使用时，您将使用

malloc

或类似的方法来分配缓冲区：

char **ptr = malloc(sizeof *ptr * N);
if (ptr)
{
  ptr[0] = "foo";    // ptr[i] gets address of
  ptr[1] = "bar";    // string literal
  ptr[2] = "bletch";
  ...
}

或

char**ptr=malloc（sizeof*ptr*N）；
如果（ptr）
{
尺寸i；
对于（i=0；i

gcc在第一行抛出wome警告（从不兼容的指针类型初始化，标量初始化器中的元素过多）。您正在非数组类型上使用数组初始值设定项。+1，但是“

ptr

和

ptr[0]

都指向列表中第一个字符串的开头”不正确。与2D数组（在所有维度上都是连续的）不同，

ptr

不指向与

ptr[0]

相同的位置；字符**ptr=&ary[0]这将

ptr

声明为“指向数组的指针”，并且由于每个数组元素都是字符串（本身就是数组），

ptr

本质上是“指向数组的指针”。使用这种类型的

char**

指针进行双解引用时要小心；由于字符串的长度不同，您需要确保执行了所有必要的边界检查。@Max-您是正确的（出于某种原因，大脑中有数组）。我已经删除了那个声明。谢谢你的关注。双间接是如何保存在内存中的？

char **ptr = {"foo", "bar", "bletch"}; // using aggregate initializer on 
                                       // non-aggregate type; bad juju,
                                       // a.k.a undefined behavior

char **ptr;          // ptr has not been initialized to point anywhere 
ptr[0] = "foo";      // dereferencing ptr via subscript invokes undefined
ptr[1] = "bar";      // behavior
ptr[2] = "bletch";

char **ptr = malloc(sizeof *ptr * N);
if (ptr)
{
  ptr[0] = "foo";    // ptr[i] gets address of
  ptr[1] = "bar";    // string literal
  ptr[2] = "bletch";
  ...
}

char **ptr = malloc(sizeof *ptr * N);
if (ptr)
{
  size_t i;
  for (i = 0; i < N; i++)
  {
    ptr[i] = malloc(sizeof *ptr[i] * M); // strictly speaking, the sizeof
    if (ptr[i])                          // is not necessary here
    {
      //initialize ptr[i]
    }
  }
}