在一个变量中允许有多少个指针(*)?
让我们考虑下面的例子。
int a = 10;
int *p = &a;
类似地,我们可以有
int **q = &p;
int ***r = &q;
等等。
例如,
int ****************zz;
在一个变量中允许有多少个指针(*)?
让我们考虑下面的例子。
int a = 10;
int *p = &a;
类似地,我们可以有
int **q = &p;
int ***r = &q;
等等。
例如,
int ****************zz;
当前回答
没有限制,查看例子在指针::C面试问题和答案。
答案取决于您对“指针级别”的定义。如果你的意思是“在一个声明中可以有多少层间接层?”答案是“至少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 */
如果你的意思是“在程序变得难以阅读之前,你可以使用多少层指针”,这是一个品味的问题,但有一个限制。有两层间接(一个指针指向另一个指向某物的指针)是很常见的。再多一点就很难想象了;除非另一种选择会更糟,否则不要做。
如果您的意思是“在运行时可以有多少层指针间接”,则没有限制。这一点对于循环列表尤其重要,因为循环列表中的每个节点都指向下一个节点。您的程序可以永远跟随指针。
其他回答
这取决于你存储指针的位置。如果它们是堆叠的,极限就会很低。如果你把它存储在堆里,你的极限会非常非常高。
看看这个程序:
#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个指针,并在显示什么指向什么时很容易注意到链到第一个变量数。
顺便说一句。它使用92K的RAM,所以想象一下你能走多深。
正如人们所说,“理论上”没有限制。然而,出于兴趣,我用g++ 4.1.2运行了这个程序,它可以在大小为20,000的情况下工作。编译非常慢,所以我没有尝试更高的编译。所以我猜g++也没有施加任何限制。(尝试设置size = 10,如果不是很明显,可以在ptr.cpp中查看。)
g++ create.cpp -o create ; ./create > ptr.cpp ;G++ PTR.cpp -optr ; ./PTR
create.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;
}
请注意,这里可能存在两个问题:在C类型中可以实现多少层指针间接,以及在单个声明器中可以填充多少层指针间接。
C标准允许对前者施加一个最大值(并给出一个最小值)。但这可以通过多个typedef声明来避免:
typedef int *type0;
typedef type0 *type1;
typedef type1 *type2; /* etc */
因此,最终,这是一个实现问题,与C程序在被拒绝之前可以做出多大/多复杂的想法有关,这是非常特定于编译器的。
实际上,使用指向函数的指针更有趣。
#include <cstdio>
typedef void (*FuncType)();
static void Print() { std::printf("%s", "Hello, World!\n"); }
int main() {
FuncType const ft = &Print;
ft();
(*ft)();
(**ft)();
/* ... */
}
如下图所示:
你好,世界! 你好,世界! 你好,世界!
而且它不涉及任何运行时开销,所以你可以尽可能多地堆叠它们……直到编译器被文件阻塞。
2004 MISRA C标准的17.5规则禁止超过2级的指针间接。