Question

是否可以在c？

中的main()函数内调用main()

Answer 1

是的，C允许您调用主函数（而C ++ does not）

Answer 2

确实允许从自身调用main()，甚至可以使用与任何其他递归代码相同的方法避免堆栈溢出，终止条件如：

#include <stdio.h>
int main (int argc, char *argv[]) {
    printf ("Running main with argc = %d, last = '%s'\n",
        argc, argv[argc-1]);
    if (argc > 1)
        return main(argc - 1, argv);
    return 0;
}

，当以testprog 1 2 3运行时，输出：

Running main with argc = 4, last = '3'
Running main with argc = 3, last = '2'
Running main with argc = 2, last = '1'
Running main with argc = 1, last = 'testprog'

但是，由于这只是轶事证据，我们应该转向标准。 ISO C11部分4 Conformance声明：

1 /在本国际标准中，＆＃34;＆＃34;＆＃34;应被解释为对实施或计划的要求;相反，＆＃34;不得＆＃34;被解释为禁止。

2 /如果＆＃34;将＆＃34;或＆＃34;不得＆＃34;违反约束或运行时约束之外的要求，行为未定义。未定义的行为在本国际标准中以“未定义的行为”字样表示。或遗漏任何明确的行为定义。这三者之间的重点没有区别;他们都描述了未定义的行为＆＃34;。

3 /在所有其他方面都正确的程序，对正确的数据进行操作，包含未指明的行为，应该是正确的程序，并按照5.1.2.3行事。

现在，由于main()调用自身的标准中没有明确的禁止，因此上述第3条是控制方面。

可以在两个地方（我的粗体）看到进一步的支持，首先是5.1.2.2.3 Program termination部分：

1 /如果main函数的返回类型是与int兼容的类型，则从初始调用返回到main函数等效于使用exit函数返回的值作为参数调用main函数;

然后在7.21.3 Files部分：

5 /该文件随后可以通过相同或另一个程序执行重新打开，并且其内容被回收或修改（如果它可以在其开始时重新定位）。如果main函数返回其原始调用方，或者调用了exit函数，则会关闭所有打开的文件（因此所有输出流）在程序终止之前刷新。

这两个子部分都支持在初始/原始版本之上可能有对main()的其他调用的可能性。

Answer 3

是的，我们可以在main（）函数中调用main（）。

函数本身调用函数的过程称为递归。

好吧，你可以在main（）函数中调用main（），但你应该有一个不调用main（）函数来终止程序的条件。

否则，程序永远不会返回并无限运行。

Answer 4

是的，你可以。

简单程序：

int main()
{
    printf("Anything");
    main();
    return 0;
}

<强>解释

call stack或function stack用于几个相关的目的，但有一个的主要原因是跟踪每个活动子程序在完成执行时应该返回控制的点。 / p>

当调用堆栈上使用了太多内存时，会发生stack overflow。

这里重复调用函数main()，并将其返回地址存储在堆栈中。堆栈内存已满。它显示stack overflow error。

Answer 5

是，可以在C和C ++中调用main（）中的main（）。这是一个递归＆＃39;递归的概念。函数调用自身的地方。例如：

在C：

#include<stdio.h>
int main()
{
    static int i=1;  // *
    printf("%d\n",i++);
    if(i==6)
    {
        return 0;
    }
    main(); // recursive call of main() 
}

在C ++中：

#include<iostream>
using namespace std;
int main()
{
    static int i=1;  // *
    cout<<i<<endl;
    i++;
    if(i==6)
    {
        return 0;
    }
    main(); // recursive call of main() 
}

两个程序的

OUTPUT ：

*此处，静态关键字用作结束程序的基本检查，否则main（）将继续无限地调用自身。例如

1
1
1
1
1
1
1
1
1
1
1.. program ends abnormally.

这里main（）无限地调用自己，因为新的整数＆＃39; i＆＃39;如果我们不使用静态关键字，则每次在新的main（）中创建初始值 1 。所以，

if(i==6)

在递归调用的每个main（）中都为true，程序永远不会正常结束。

但是使用静态关键字会创建整数＆＃39; i＆＃39;只有一次（当第一次执行main（）时）和＆＃39; i＆＃39;在main（）的每次递归调用期间递增。因此，递归在＆＃39; i＆＃39;变为6，因为 返回0; 执行。

更多信息。关于static关键字： Recursive function with static variable

Answer 6

是的，可以自己调用main函数。它可以作为递归函数使用，但是可以无限期地使用（直到发生堆栈溢出）。sample code

Answer 7

int static val;
main()
{ 
  if(val==0)
  { clrscr(); }
  while(val<3)
  { val++; 
    printf("calld main\n",main());
  } 
getch();
}

Answer 8

是的，可以在C和C ++中使main函数成为递归函数。我通过提交UVa问题（编号10071）对其进行测试并接受了。这里的代码为：Screenshot 1，Screenshot 2

#include<stdio.h>
int main(void)
{
    int v,t,s;
    if(scanf("%d%d",&v,&t)==2)
    {
        s=2*(v*t);
        printf("%d\n",s);
        main();
    }
    else
        return 0;
}

for C ++，

#include<iostream>
using namespace std;
int main(void)
{
    int v,t,s;
    if(cin>>v>>t)
    {
        cout<<2*v*t<<endl;
        main();
    }
    else
        return 0;
}

Answer 9

这取决于您使用的编译器，我已经在c中编写了一个程序来查找自然数的总和而不使用任何函数或仅仅帮助在MAIN函数内编写MAIN函数（我使用了condn来终止）它有在turbo c编译器中给出了我的req答案，但在devc ++中它允许我编译程序并给出req输出。

在c中的main（）中调用main（）

9 个答案: