我们可以有多少级别的指针？

Question

单个变量中允许有多少个指针 (*)？

让我们考虑下面的例子。

int a = 10;
int *p = &a;

同样我们可以有

int **q = &p;
int ***r = &q;

等等。

例如，

int ****************zz;

Answer 1

C 标准规定了下限：

5.2.4.1 Translation limits

276 实现应能够翻译和执行至少一个程序，该程序至少包含以下每个限制的一个实例：[...]

279 — 12 个指针、数组和函数声明符（任意组合）修改 声明中的算术、结构、联合或 void 类型

上限是特定于实现的。

Answer 2

实际上，C 程序通常使用无限指针间接寻址。一到两个静态级别是常见的。三重间接很少见。但无限是很常见的。

无限指针间接是在结构的帮助下实现的，当然，不是直接的声明符，这是不可能的。并且需要一个结构，以便您可以在此结构中包含可以终止的不同级别的其他数据。

struct list { struct list *next; ... };

现在您可以拥有list->next->next->next->...->next。这实际上只是多指针间接：*(*(..(*(*(*list).next).next).next...).next).next。而.next 作为结构的第一个成员时基本上是一个 noop，所以我们可以把它想象成***..***ptr。

实际上没有限制，因为链接可以通过循环而不是像这样的巨型表达式来遍历，而且结构可以很容易地做成圆形。

因此，换句话说，链表可能是添加另一个间接级别来解决问题的终极示例，因为您在每次推送操作时都动态地执行此操作。 :)

Answer 3

理论上：

您可以拥有任意多级的间接。

实际上：

当然，任何消耗内存的东西都不是无限期的，由于主机环境上的可用资源会有所限制。所以实际上，实现可以支持的内容有一个最大限制，并且实现应该适当地记录它。因此，在所有此类工件中，标准并未指定最大限制，但确实指定了下限。

这是参考：

C99 标准 5.2.4.1 翻译限制：

——12 个指针、数组和函数声明符（任意组合）修改一个 声明中的算术、结构、联合或 void 类型。

这指定了每个实现必须支持的下限。请注意，该标准在脚注中进一步说明：

18) 实施应尽可能避免施加固定的翻译限制。

Answer 4

正如人们所说，“理论上”没有限制。但是，出于兴趣，我使用 g++ 4.1.2 运行它，它的大小可达 20,000。编译虽然很慢，所以我没有尝试更高。所以我猜 g++ 也没有施加任何限制。 （尝试设置 size = 10 并在 ptr.cpp 中查看，如果不是很明显。）

g++ create.cpp -o create ; ./create > ptr.cpp ; g++ ptr.cpp -o ptr ; ./ptr

创建.cpp

#include <iostream>

int main()
{
    const int size = 200;
    std::cout << "#include <iostream>\n\n";
    std::cout << "int main()\n{\n";
    std::cout << "    int i0 = " << size << ";";
    for (int i = 1; i < size; ++i)
    {
        std::cout << "    int ";
        for (int j = 0; j < i; ++j) std::cout << "*";
        std::cout << " i" << i << " = &i" << i-1 << ";\n";
    }
    std::cout << "    std::cout << ";
    for (int i = 1; i < size; ++i) std::cout << "*";
    std::cout << "i" << size-1 << " << \"\\n\";\n";
    std::cout << "    return 0;\n}\n";
    return 0;
}

Answer 5

检查起来很有趣。

• Visual Studio 2010（在 Windows 7 上），在出现此错误之前，您可以有 1011 个级别：

  致命错误 C1026：解析器堆栈溢出，程序太复杂

• gcc (Ubuntu), 100k+ * 没有崩溃！我猜硬件是这里的限制。

（仅使用变量声明进行测试）

Answer 6

没有限制，查看示例here。

答案取决于您所说的“指针级别”是什么意思。如果您的意思是“在单个声明中可以有多少级间接性？”答案是“至少 12 个”。

int i = 0;

int *ip01 = & i;

int **ip02 = & ip01;

int ***ip03 = & ip02;

int ****ip04 = & ip03;

int *****ip05 = & ip04;

int ******ip06 = & ip05;

int *******ip07 = & ip06;

int ********ip08 = & ip07;

int *********ip09 = & ip08;

int **********ip10 = & ip09;

int ***********ip11 = & ip10;

int ************ip12 = & ip11;

************ip12 = 1; /* i = 1 */

如果您的意思是“在程序变得难以阅读之前，您可以使用多少级指针”，这是一个口味问题，但有一个限制。具有两个间接级别（指向某物的指针的指针）很常见。再多的事情就更难想了。除非替代方案更糟，否则不要这样做。

如果您的意思是“在运行时可以有多少级指针间接”，则没有限制。这一点对于循环列表尤其重要，其中每个节点都指向下一个节点。你的程序可以永远跟随指针。

Answer 7

使用指向函数的指针实际上更有趣。

#include <cstdio>

typedef void (*FuncType)();

static void Print() { std::printf("%s", "Hello, World!\n"); }

int main() {
  FuncType const ft = &Print;
  ft();
  (*ft)();
  (**ft)();
  /* ... */
}

如图here 所示：

你好，世界！
你好，世界！
你好世界！

而且它不涉及任何运行时开销，因此您可以随意堆叠它们...直到您的编译器阻塞文件。

Answer 8

没有限制。指针是一块内存，其内容是地址。
正如你所说的

int a = 10;
int *p = &a;

指向指针的指针也是一个变量，其中包含另一个指针的地址。

int **q = &p;

这里的q是指向持有p地址的指针的指针，该地址已经持有a的地址。

指向指针的指针并没有什么特别之处。
因此，持有另一个指针地址的指针链没有限制。
即。

 int **************************************************************************z;

是允许的。

Answer 9

每个 C++ 开发人员都应该听说过（臭名昭著的）Three star programmer

而且似乎真的有一些神奇的“指针屏障”需要伪装

来自 C2 的引述：

三星级程序员

C 程序员的评分系统。您的指针越间接（即变量前的“*”越多），您的声誉就越高。 No-star C 程序员几乎不存在，因为几乎所有重要的程序都需要使用指针。大多数是一星程序员。在过去（嗯，我还年轻，所以至少在我看来这些看起来像旧时代），人们偶尔会发现一段由三星级程序员完成的代码，并且敬畏地颤抖。 有些人甚至声称他们在不止一个间接级别上看到了包含函数指针的三星级代码。对我来说听起来像不明飞行物一样真实。

Answer 10

请注意，这里有两个可能的问题：我们可以在 C 类型中实现多少级指针间接，以及我们可以将多少级指针间接填充到单个声明符中。

C 标准允许对前者施加最大值（并为此给出最小值）。但这可以通过多个 typedef 声明来规避：

typedef int *type0;
typedef type0 *type1;
typedef type1 *type2; /* etc */

因此，归根结底，这是一个实现问题，与 C 程序在被拒绝之前可以制作多大/复杂的想法有关，这是非常特定于编译器的。

Answer 11

我想指出，生成具有任意数量 * 的类型是模板元编程可能发生的事情。我忘记了我到底在做什么，但有人建议我可以通过使用 recursive T* 类型来生成新的不同类型，这些类型在它们之间具有某种元操作。

模板元编程是一种缓慢下降到疯狂的过程，因此在生成具有数千个间接级别的类型时没有必要找借口。这只是一种将 peano 整数映射到模板扩展的便捷方式，例如，作为一种函数式语言。

Answer 12

2004 MISRA C 标准的规则 17.5 禁止超过 2 级的指针间接。

Answer 13

没有像真正的限制这样的东西，但限制是存在的。所有指针都是变量，通常存储在堆栈而不是堆中。堆栈通常很小（在某些链接期间可以更改其大小）。所以假设你有 4MB 堆栈，这是相当正常的大小。假设我们有一个 4 字节大小的指针（指针大小因架构、目标和编译器设置而异）。

在这种情况下，4 MB / 4 b = 1024 可能的最大数量为 1048576，但我们不应忽视堆栈中还有其他一些东西的事实。

然而，一些编译器可能有最大数量的指针链，但限制是堆栈大小。因此，如果您在与无穷大链接期间增加堆栈大小并拥有运行具有无穷大内存的机器来运行处理该内存的操作系统，那么您将拥有无限的指针链。

如果您使用int *ptr = new int; 并将您的指针放入堆中，那么通常方式限制将是堆大小，而不是堆栈。

编辑只要意识到infinity / 2 = infinity。如果机器有更多内存，则指针大小会增加。所以如果内存是无穷大并且指针的大小是无穷大，那么这是个坏消息...... :)

Answer 14

这取决于您存储指针的位置。如果它们在堆栈中，则您的限制相当低。如果将其存储在堆中，则限制要高得多。

看看这个程序：

#include <iostream>

const int CBlockSize = 1048576;

int main() 
{
    int number = 0;
    int** ptr = new int*[CBlockSize];

    ptr[0] = &number;

    for (int i = 1; i < CBlockSize; ++i)
        ptr[i] = reinterpret_cast<int *> (&ptr[i - 1]);

    for (int i = CBlockSize-1; i >= 0; --i)
        std::cout << i << " " << (int)ptr[i] << "->" << *ptr[i] << std::endl;

    return 0;
}

它创建 1M 指针，并在显示什么指向什么时很容易注意到链指向第一个变量 number。

顺便说一句。它使用92K 的 RAM，所以想象一下你能走多深。