Question

如果C（char * names []）中有指针和指针指针（char ** cur_name = names）;可以有指向指针指针的指针吗？

或者是一个指向指针的指针只是一个链表？也许这是一个愚蠢的问题，但我想知道答案。

Answer 1

是的，您可以拥有任意数量的指针级别。

int x = 5;
int *a = &x;
int **b = &a;
int ***c = &b;

printf("%d %d %d %d\n", x, *a, **b, ***c);

指向指针指针的指针不是链表。链表是一种结构类型，包含指向其自己类型的指针：

struct list
{
   int data;
   struct list *next;
};

这样你就可以将它们链接在一个列表中：

struct list three = { 3, NULL };
struct list two = { 2, &three };
struct list one = { 1, &two };
struct list head = { 0, &one };

迭代它们：

for (struct list *node = &head; node->next; node = node->next)
{
    printf("%d\n", node->data);
}

Answer 2

让我们用更简单的术语来表达。

声明一个变量 - 对于什么类型来说并不重要 - 它代表了内存中的一个位置。

int foo=1;

然后，您可以声明另一个指向变量的变量。

int *bar;
bar = &foo;

再次扩展它 - 声明指向变量的指针......等等。

int *baz;
baz = &bar;

关键是对任何给定指针可能使用或声明的间接级别没有限制。从语法上讲，你可以做到

int ****nthLevelPointer;

现在，以其他人可能必须维护的方式在代码中保留 track 完全是另一个问题：）

Answer 3

一个简单的例子：

struct List
{
    struct List* next ;
}

struct List a ;
struct List* p = &a ;
p->next = p ;
p = p->next ;
p = p->next->next ;
p = p->next->next->next ;
p = p->next->next->next->next ;
p = p->next->next->next->next->next ;
p = p->next->next->, ... ,next->next->next ;

表明指针间接深度没有理论上的限制。

Answer 4

你的答案是肯定的。指针只是对memory的引用。如果我们可以引用内存，我们也可以引用指针。你可以在你的进程堆中获取它们的大小。你也可以通过局部变量来定义它们。请使用这个模式：

指针a -----＆gt;指针b -----＆gt;指针c ------＆gt;（局部变量或在堆中定义变量）

Answer 5

简短回答：指针指向内存中的地址，这些地址本身可能包含更多指针。限制是可用的地址数。

答案较短：是的，可以有一个指针指针指针。

Answer 6

指向指针的指针是可能的。

如果你声明一个这样的变量：

int ***ptr;

然后：

->    ptr will be a pointer to a pointer to a pointer to an int variable
->   *ptr will be a pointer to a pointer to an int variable
->  **ptr will be a pointer to an int variable
-> ***ptr will be a int variable

因此：

highest pointer level:    ptr
     ...                 *ptr
     ...                **ptr
int variable           ***ptr

可以有指向指针指针的指针吗？

6 个答案: