可以在c中重新定义主函数吗

我在c中看到使用宏重新定义函数。所以我很感兴趣，有可能重新定义主函数吗

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char **argv)
{
    printf("Original main function\n");
    return 0;
}

int _main(int argc, char **argv)
{
    printf("New Original main function\n");
    return main(argc, argv);
}

#ifdef DEBUG
#define main(argc, argv) _main(argc, argv)
#endif

所以我想知道为什么它不起作用？当我对

malloc

和

free

函数使用相同的技术时，它工作得非常完美。那怎么了

为什么我想做这样的事？我想在执行

main

函数之前执行一些代码。这样可能吗？如果没有，还有别的办法吗

p.S.：对不起，我没有提到这个问题。我在Ubuntu操作系统中使用gcc如果你投了反对票，请在评论中给出理由。您的评论对我的进一步发展非常有用。

您的#define根本没有改变主要功能-它是一个宏预处理器

您的#define的唯一效果是将对#main中main的调用更改为对#main（）的递归调用。但是因为没有调用_main，所以这是死代码。这是预处理器运行后代码的外观

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char **argv)
{
    printf("Original main function\n");
    return 0;
}

int _main(int argc, char **argv)
{
    printf("New Original main function\n");
    return _main(argc, argv); /* recursive call due to macro replace */
}

#包括
#包括
#包括
int main（int argc，字符**argv）
{
printf（“原始主函数”）；
返回0；
}
int _main（int argc，char**argv）
{
printf（“新的原始主函数”）；
由于宏替换，返回_main（argc，argv）；/*递归调用*/
}

这就引出了下一个问题——这就是为什么要重新定义main？如果您希望在调试上运行一些完全不同的代码，只需将main声明为

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char **argv)
{
#ifdef DEBUG
    return debugApp( argc, argv);
#else
    return productionApp( argc, argv);
#endif
}

#包括
#包括
#包括
int main（int argc，字符**argv）
{
#ifdef调试
返回debugApp（argc，argv）；
#否则
返回生产应用程序（argc、argv）；
#恩迪夫
}

N.B仅仅因为你能做某事并不意味着你应该做它。：-）

您的#define根本不会更改主函数-它是一个宏预处理器

您的#define的唯一效果是将对#main中main的调用更改为对#main（）的递归调用。但是因为没有调用_main，所以这是死代码。这是预处理器运行后代码的外观

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char **argv)
{
    printf("Original main function\n");
    return 0;
}

int _main(int argc, char **argv)
{
    printf("New Original main function\n");
    return _main(argc, argv); /* recursive call due to macro replace */
}

#包括
#包括
#包括
int main（int argc，字符**argv）
{
printf（“原始主函数”）；
返回0；
}
int _main（int argc，char**argv）
{
printf（“新的原始主函数”）；
由于宏替换，返回_main（argc，argv）；/*递归调用*/
}

这就引出了下一个问题——这就是为什么要重新定义main？如果您希望在调试上运行一些完全不同的代码，只需将main声明为

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char **argv)
{
#ifdef DEBUG
    return debugApp( argc, argv);
#else
    return productionApp( argc, argv);
#endif
}

#包括
#包括
#包括
int main（int argc，字符**argv）
{
#ifdef调试
返回debugApp（argc，argv）；
#否则
返回生产应用程序（argc、argv）；
#恩迪夫
}

N.B仅仅因为你能做某事并不意味着你应该做它。：-）

您的#define根本不会更改主函数-它是一个宏预处理器

您的#define的唯一效果是将对#main中main的调用更改为对#main（）的递归调用。但是因为没有调用_main，所以这是死代码。这是预处理器运行后代码的外观

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char **argv)
{
    printf("Original main function\n");
    return 0;
}

int _main(int argc, char **argv)
{
    printf("New Original main function\n");
    return _main(argc, argv); /* recursive call due to macro replace */
}

#包括
#包括
#包括
int main（int argc，字符**argv）
{
printf（“原始主函数”）；
返回0；
}
int _main（int argc，char**argv）
{
printf（“新的原始主函数”）；
由于宏替换，返回_main（argc，argv）；/*递归调用*/
}

这就引出了下一个问题——这就是为什么要重新定义main？如果您希望在调试上运行一些完全不同的代码，只需将main声明为

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char **argv)
{
#ifdef DEBUG
    return debugApp( argc, argv);
#else
    return productionApp( argc, argv);
#endif
}

#包括
#包括
#包括
int main（int argc，字符**argv）
{
#ifdef调试
返回debugApp（argc，argv）；
#否则
返回生产应用程序（argc、argv）；
#恩迪夫
}

N.B仅仅因为你能做某事并不意味着你应该做它。：-）

您的#define根本不会更改主函数-它是一个宏预处理器

您的#define的唯一效果是将对#main中main的调用更改为对#main（）的递归调用。但是因为没有调用_main，所以这是死代码。这是预处理器运行后代码的外观

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char **argv)
{
    printf("Original main function\n");
    return 0;
}

int _main(int argc, char **argv)
{
    printf("New Original main function\n");
    return _main(argc, argv); /* recursive call due to macro replace */
}

#包括
#包括
#包括
int main（int argc，字符**argv）
{
printf（“原始主函数”）；
返回0；
}
int _main（int argc，char**argv）
{
printf（“新的原始主函数”）；
由于宏替换，返回_main（argc，argv）；/*递归调用*/
}

这就引出了下一个问题——这就是为什么要重新定义main？如果您希望在调试上运行一些完全不同的代码，只需将main声明为

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char **argv)
{
#ifdef DEBUG
    return debugApp( argc, argv);
#else
    return productionApp( argc, argv);
#endif
}

#包括
#包括
#包括
int main（int argc，字符**argv）
{
#ifdef调试
返回debugApp（argc，argv）；
#否则
返回生产应用程序（argc、argv）；
#恩迪夫
}

---

N.B仅仅因为你能做某事并不意味着你应该做它。：-）

如果要更改程序的入口点，不需要使用定义。您可以使用链接器的

-e

选项：

gcc -Wl,-e,__main ...

---

请注意额外的下划线。根据某些选项，符号名称可能会有所不同。

如果要更改程序的入口点，则无需使用定义。您可以使用链接器的

-e

选项：

gcc -Wl,-e,__main ...

---

请注意额外的下划线。根据某些选项，符号名称可能会有所不同。

如果要更改程序的入口点，则无需使用定义。您可以使用链接器的

-e

选项：

gcc -Wl,-e,__main ...

---

请注意额外的下划线。根据某些选项，符号名称可能会有所不同。

如果要更改程序的入口点，则无需使用定义。您可以使用链接器的

-e

选项：

gcc -Wl,-e,__main ...

---

请注意额外的下划线。根据某些选项，符号名称可能不同。

如果您的问题是：