Question

我前段时间在一个帐户上问过我不记得如何操纵基本指针而有人给了我一个非常好的演示

例如

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

所以现在* ptr指向h

ptr++ =将ptr移动到指向下一个元素，得到它的值，我做* ptr，这给了我一个

好到目前为止我希望：D但是现在我需要操纵一个char **ptr并想知道我是如何以一种模仿二维数组影响的方式做到这一点的？

一些基本提示将非常受欢迎，因为我需要做一个**ptr模仿二维数组的任务，而不知道它是如何做的第一个意味着我甚至无法在纸上解决它（例如，你如何取消引用** ptr，你如何获得[x] [y]值等）

谢谢

Answer 1

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

假设以下声明：

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]

因此：

ptr可以被视为，好像它是一个字符串数组（二维数组的char）
ptr[i]指向列表中第i个字符串的开头
ptr[i][j]是列表中第i个字符串的第j个字符的值
表达式ptr++和++ptr会使ptr提前指向下一个字符串
表达式(*ptr)++和++(*ptr)会使*ptr提前指向下一个字符

至于设置指针，这种安排假定所有内容都已分配为静态数组或通过malloc动态分配。你不能只写

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";

通常，当您使用指针时，就像它是一个数组一样，您将使用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);
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]
    }
  }
}

Answer 2

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

// 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'.

Answer 3

您可以像使用普通的二维数组一样使用它们。（因为有效，这就是它们）

char** ptr = {"lorem", "ipsum", "dolor"};
char* s1 = ptr[0]; //Points to the beginning of "lorem"
char* s2 = ptr[1]; //Points to the beginning of "ipsum"
char c = ptr[2][4]; //Contains 'r'

这是因为：

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

干杯，

阿米特罗恩 -

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

3 个答案: