是否有可能在C语言中实现无限的编译时间（即没有模板）？

所以，标题。众所周知，编写C++程序是可能的，这将需要无限的时间来编译（理论上）。但是有可能用普通的C语言编写这样的程序吗？或者，有没有办法用一个小程序将编译时间至少降低到几分钟？

下面是您要求的例子，宏以指数级增长

#define FOO  i++  // Substitute any statement here for i++
#define FOO1 FOO ; FOO
#define FOO2 FOO1 ; FOO1
#define FOO3 FOO2 ; FOO2
#define FOO4 FOO3 ; FOO3
#define FOO5 FOO4 ; FOO4
#define FOO6 FOO5 ; FOO5
// Keep going however much you want
...
#define FOO40 FOO39 ; FOO39

volatile int i;

int main(void)
{
    FOO40;  // This expands to 2^40 statements.
}

我使用

FOO18

进行计时测试，看看会发生什么。我分别测试了预处理器时间和编译时间：

（预处理器阶段）
时间gcc-E foo.c-o foo.i
1.7秒
（汇编阶段）
时间gcc foo.i-o foo
21秒

出于好奇，我一直在尝试越来越大的价值观。不幸的是，编译器在某个时候耗尽了内存（预处理器很好）。我得到了这个错误：

cc1:内存不足，在总共403505152字节之后分配16842751字节

在使用

-O2

的

FOO16

上，我能够在不耗尽内存的情况下获得2:23的编译时间。因此，如果您想获得更长的编译时间，请首先找出许多可以放入单个函数而不会耗尽内存的语句（

FOO16

）。然后做几个函数，如下所示：

int main(void)
{
    FOO16;
}

void bar1(void)
{
    FOO16;
}

void bar2(void)
{
    FOO16;
}

// etc...

---

这是您要求的示例，宏呈指数增长

#define FOO  i++  // Substitute any statement here for i++
#define FOO1 FOO ; FOO
#define FOO2 FOO1 ; FOO1
#define FOO3 FOO2 ; FOO2
#define FOO4 FOO3 ; FOO3
#define FOO5 FOO4 ; FOO4
#define FOO6 FOO5 ; FOO5
// Keep going however much you want
...
#define FOO40 FOO39 ; FOO39

volatile int i;

int main(void)
{
    FOO40;  // This expands to 2^40 statements.
}

我使用

FOO18

进行计时测试，看看会发生什么。我分别测试了预处理器时间和编译时间：

（预处理器阶段）
时间gcc-E foo.c-o foo.i
1.7秒
（汇编阶段）
时间gcc foo.i-o foo
21秒

出于好奇，我一直在尝试越来越大的价值观。不幸的是，编译器在某个时候耗尽了内存（预处理器很好）。我得到了这个错误：

cc1:内存不足，在总共403505152字节之后分配16842751字节

在使用

-O2

的

FOO16

上，我能够在不耗尽内存的情况下获得2:23的编译时间。因此，如果您想获得更长的编译时间，请首先找出许多可以放入单个函数而不会耗尽内存的语句（

FOO16

）。然后做几个函数，如下所示：

int main(void)
{
    FOO16;
}

void bar1(void)
{
    FOO16;
}

void bar2(void)
{
    FOO16;
}

// etc...

---

这是您要求的示例，宏呈指数增长

#define FOO  i++  // Substitute any statement here for i++
#define FOO1 FOO ; FOO
#define FOO2 FOO1 ; FOO1
#define FOO3 FOO2 ; FOO2
#define FOO4 FOO3 ; FOO3
#define FOO5 FOO4 ; FOO4
#define FOO6 FOO5 ; FOO5
// Keep going however much you want
...
#define FOO40 FOO39 ; FOO39

volatile int i;

int main(void)
{
    FOO40;  // This expands to 2^40 statements.
}

我使用

FOO18

进行计时测试，看看会发生什么。我分别测试了预处理器时间和编译时间：

（预处理器阶段）
时间gcc-E foo.c-o foo.i
1.7秒
（汇编阶段）
时间gcc foo.i-o foo
21秒

出于好奇，我一直在尝试越来越大的价值观。不幸的是，编译器在某个时候耗尽了内存（预处理器很好）。我得到了这个错误：

cc1:内存不足，在总共403505152字节之后分配16842751字节

在使用

-O2

的

FOO16

上，我能够在不耗尽内存的情况下获得2:23的编译时间。因此，如果您想获得更长的编译时间，请首先找出许多可以放入单个函数而不会耗尽内存的语句（

FOO16

）。然后做几个函数，如下所示：

int main(void)
{
    FOO16;
}

void bar1(void)
{
    FOO16;
}

void bar2(void)
{
    FOO16;
}

// etc...

---

这是您要求的示例，宏呈指数增长

#define FOO  i++  // Substitute any statement here for i++
#define FOO1 FOO ; FOO
#define FOO2 FOO1 ; FOO1
#define FOO3 FOO2 ; FOO2
#define FOO4 FOO3 ; FOO3
#define FOO5 FOO4 ; FOO4
#define FOO6 FOO5 ; FOO5
// Keep going however much you want
...
#define FOO40 FOO39 ; FOO39

volatile int i;

int main(void)
{
    FOO40;  // This expands to 2^40 statements.
}

我使用

FOO18

进行计时测试，看看会发生什么。我分别测试了预处理器时间和编译时间：

（预处理器阶段）
时间gcc-E foo.c-o foo.i
1.7秒
（汇编阶段）
时间gcc foo.i-o foo
21秒

出于好奇，我一直在尝试越来越大的价值观。不幸的是，编译器在某个时候耗尽了内存（预处理器很好）。我得到了这个错误：

cc1:内存不足，在总共403505152字节之后分配16842751字节

在使用

-O2

的

FOO16

上，我能够在不耗尽内存的情况下获得2:23的编译时间。因此，如果您想获得更长的编译时间，请首先找出许多可以放入单个函数而不会耗尽内存的语句（

FOO16

）。然后做几个函数，如下所示：

int main(void)
{
    FOO16;
}

void bar1(void)
{
    FOO16;
}

void bar2(void)
{
    FOO16;
}

// etc...

---

从实验上看，如果你要求一个最近的或是一个包含数千条语句的单个（或极少数）C函数的C代码进行编译，编译时间会增长很多

根据经验，使用

gcc-O2

编译单个函数和数千条C语句需要一个与语句数的平方成比例的时间（预处理和GIMPLIZATION后更准确的语句数）

直觉解释是，寄存器分配、指令调度和中间端优化的算法通常比O（n）差；像，

8cc

等简单的非优化C编译器没有这样的时间行为（但生成的代码比

gcc-O2

更糟糕）

顺便说一句，你可以（在Linux上）玩我的程序（它生成一些或多或少的随机C代码，然后编译它并

dlopen

it，以显示你可以

dlopen

数十万个共享对象）。阅读它的源代码，它将说明我的观点

更严重的是，我以前做过同样的实验，在旧版本中，它生成适合于扩展GCC的C++代码。我不得不将一些庞大的顺序初始化代码分成几个例程

您可以使用

gcc-ftime report-O2

这样一个庞大的函数进行编译，以便更准确地理解编译器在哪一个优化过程中花费时间

---

最后，如果你想要一个小的源代码，你可以通过要求它包含“一些大文件.c”来欺骗它，但我相信这不算数。

如果你要求一个最近的或使用一些包含单个（或v）的c代码编译