使用多个main（）编译C文件

我是C语言的初学者，我有一个关于编译C文件的问题。我需要为带有main的应用程序编写一个公共包代码common.c，以解析配置文件并设置几个变量。我需要将这个文件导入到另一个文件中，比如说local.c，使用include并在这里再次使用main，然后调用common.c中的某些函数。现在，当我使用gcc编译这些文件时，我得到了一个错误：main的多个声明

有没有办法先编译并运行common.c，然后在local.c中使用这个文件设置的变量？我应该使用什么makefile规则

普通的

#ifndef __DAEMON_COMMON__
#define __DAEMON_COMMON__

extern int a;
extern const char* type;
    
    
int add(int a, int b);
void print(int n);
    
#endif

#ifndef __DAEMON_COMMON__
#define __DAEMON_COMMON__

extern int a;
extern const char* type;
    
    
int add(int a, int b);
void print(int n);

/* declaration of required function in local.c */
int local_main(void);
    
#endif

普通的

int a = -1;
int main(int argc, char *argv[]){
    // parse file in arg and initialize variables declared as extern
    
    a = 10;
}
    
int add(int a, int b){
    return a + b;
}
    
void print(int n){
    printf("%d",n);
}

#include "common.h"

int a = -1;
int main(int argc, char *argv[]){
    // parse file in arg and initialize variables declared as extern
    
    a = 10;

    return local_main();
}
    
int add(int a, int b){
    return a + b;
}
    
void print(int n){
    printf("%d",n);
}

common.c和common.h位于公共目录中，使用

#include <common.h>

本地的

#include <common.h>
    
int main(){
    add(5,10);
    print(a);  // I want to access 'a' initialized in common.c here
    
    return 0;
}

#include "common.h"
    
int local_main(){
    add(5,10);
    print(a);  // I want to access 'a' initialized in common.c here
    
    return 0;
}

---

正如注释中所述以及编译器所报告的，您不能有多个主函数。您必须从编译中排除除单个主函数以外的所有函数，或者重命名其他函数并自己调用它们

common.c中的main函数的目的似乎是初始化变量。你可以用不同的方法来做

通过问题中的示例，您可以简单地执行正确的静态初始化，而无需使用函数

普通的

#ifndef __DAEMON_COMMON__
#define __DAEMON_COMMON__

extern int a;
extern const char* type;
    
    
int add(int a, int b);
void print(int n);
    
#endif

#ifndef __DAEMON_COMMON__
#define __DAEMON_COMMON__

extern int a;
extern const char* type;
    
    
int add(int a, int b);
void print(int n);

/* declaration of required function in local.c */
int local_main(void);
    
#endif

普通的

int a = -1;
int main(int argc, char *argv[]){
    // parse file in arg and initialize variables declared as extern
    
    a = 10;
}
    
int add(int a, int b){
    return a + b;
}
    
void print(int n){
    printf("%d",n);
}

#include "common.h"

int a = -1;
int main(int argc, char *argv[]){
    // parse file in arg and initialize variables declared as extern
    
    a = 10;

    return local_main();
}
    
int add(int a, int b){
    return a + b;
}
    
void print(int n){
    printf("%d",n);
}

本地的

#include <common.h>
    
int main(){
    add(5,10);
    print(a);  // I want to access 'a' initialized in common.c here
    
    return 0;
}

#include "common.h"
    
int local_main(){
    add(5,10);
    print(a);  // I want to access 'a' initialized in common.c here
    
    return 0;
}

普通的

int a = -1;
int main(int argc, char *argv[]){
    // parse file in arg and initialize variables declared as extern
    
    a = 10;
}
    
int add(int a, int b){
    return a + b;
}
    
void print(int n){
    printf("%d",n);
}

#include "common.h"

int a = -1;
int main(int argc, char *argv[]){
    // parse file in arg and initialize variables declared as extern
    
    a = 10;

    return local_main();
}
    
int add(int a, int b){
    return a + b;
}
    
void print(int n){
    printf("%d",n);
}

本地的

#include <common.h>
    
int main(){
    add(5,10);
    print(a);  // I want to access 'a' initialized in common.c here
    
    return 0;
}

#include "common.h"
    
int local_main(){
    add(5,10);
    print(a);  // I want to access 'a' initialized in common.c here
    
    return 0;
}

此解决方案的缺点是，任何使用公共模块的程序都必须显式调用初始化

您可以通过几种方式来改进这一点。您可以将初始化状态保存在common.c中，并使您的函数在之前未初始化的情况下返回错误。如果初始化不依赖于输入值，则函数可以在必要时隐式运行初始化

普通的

int a = -1;
int main(int argc, char *argv[]){
    // parse file in arg and initialize variables declared as extern
    
    a = 10;
}
    
int add(int a, int b){
    return a + b;
}
    
void print(int n){
    printf("%d",n);
}

#include "common.h"

int a = -1;
int main(int argc, char *argv[]){
    // parse file in arg and initialize variables declared as extern
    
    a = 10;

    return local_main();
}
    
int add(int a, int b){
    return a + b;
}
    
void print(int n){
    printf("%d",n);
}

本地的

#include <common.h>
    
int main(){
    add(5,10);
    print(a);  // I want to access 'a' initialized in common.c here
    
    return 0;
}

#include "common.h"
    
int local_main(){
    add(5,10);
    print(a);  // I want to access 'a' initialized in common.c here
    
    return 0;
}

编辑作为对评论的答复

这是嵌入式软件项目的一部分[…] c中的main解析文件并初始化变量，而在我的local.c中，我有一个main，在那里我调用函数&使用common.c和common.h中声明和定义的变量

必须重命名其中一个函数

而不是上面所示的解决方案，其中，local.c中的函数main调用common_init函数或common.c中的类似函数。您可以采用另一种方法，要求您的特定本地应用程序代码具有名为local_main的函数，或由common.c中的函数调用定义的任何您选择的名称，并具有将在中从main调用的特定签名和行为普通的

例如：

普通的

#ifndef __DAEMON_COMMON__
#define __DAEMON_COMMON__

extern int a;
extern const char* type;
    
    
int add(int a, int b);
void print(int n);
    
#endif

#ifndef __DAEMON_COMMON__
#define __DAEMON_COMMON__

extern int a;
extern const char* type;
    
    
int add(int a, int b);
void print(int n);

/* declaration of required function in local.c */
int local_main(void);
    
#endif

普通的

int a = -1;
int main(int argc, char *argv[]){
    // parse file in arg and initialize variables declared as extern
    
    a = 10;
}
    
int add(int a, int b){
    return a + b;
}
    
void print(int n){
    printf("%d",n);
}

#include "common.h"

int a = -1;
int main(int argc, char *argv[]){
    // parse file in arg and initialize variables declared as extern
    
    a = 10;

    return local_main();
}
    
int add(int a, int b){
    return a + b;
}
    
void print(int n){
    printf("%d",n);
}

本地的

#include <common.h>
    
int main(){
    add(5,10);
    print(a);  // I want to access 'a' initialized in common.c here
    
    return 0;
}

#include "common.h"
    
int local_main(){
    add(5,10);
    print(a);  // I want to access 'a' initialized in common.c here
    
    return 0;
}

---

正如注释中所述以及编译器所报告的，您不能有多个主函数。您必须从编译中排除除单个主函数以外的所有函数，或者重命名其他函数并自己调用它们

common.c中的main函数的目的似乎是初始化变量。你可以用不同的方法来做

通过问题中的示例，您可以简单地执行正确的静态初始化，而无需使用函数

普通的

#ifndef __DAEMON_COMMON__
#define __DAEMON_COMMON__

extern int a;
extern const char* type;
    
    
int add(int a, int b);
void print(int n);
    
#endif

#ifndef __DAEMON_COMMON__
#define __DAEMON_COMMON__

extern int a;
extern const char* type;
    
    
int add(int a, int b);
void print(int n);

/* declaration of required function in local.c */
int local_main(void);
    
#endif

普通的

int a = -1;
int main(int argc, char *argv[]){
    // parse file in arg and initialize variables declared as extern
    
    a = 10;
}
    
int add(int a, int b){
    return a + b;
}
    
void print(int n){
    printf("%d",n);
}

#include "common.h"

int a = -1;
int main(int argc, char *argv[]){
    // parse file in arg and initialize variables declared as extern
    
    a = 10;

    return local_main();
}
    
int add(int a, int b){
    return a + b;
}
    
void print(int n){
    printf("%d",n);
}

本地的

#include <common.h>
    
int main(){
    add(5,10);
    print(a);  // I want to access 'a' initialized in common.c here
    
    return 0;
}

#include "common.h"
    
int local_main(){
    add(5,10);
    print(a);  // I want to access 'a' initialized in common.c here
    
    return 0;
}

普通的

int a = -1;
int main(int argc, char *argv[]){
    // parse file in arg and initialize variables declared as extern
    
    a = 10;
}
    
int add(int a, int b){
    return a + b;
}
    
void print(int n){
    printf("%d",n);
}

#include "common.h"

int a = -1;
int main(int argc, char *argv[]){
    // parse file in arg and initialize variables declared as extern
    
    a = 10;

    return local_main();
}
    
int add(int a, int b){
    return a + b;
}
    
void print(int n){
    printf("%d",n);
}

本地的

#include <common.h>
    
int main(){
    add(5,10);
    print(a);  // I want to access 'a' initialized in common.c here
    
    return 0;
}

#include "common.h"
    
int local_main(){
    add(5,10);
    print(a);  // I want to access 'a' initialized in common.c here
    
    return 0;
}

此解决方案的缺点是，任何使用公共模块的程序都必须显式调用初始化

您可以通过几种方式来改进这一点。您可以将初始化状态保存在common.c中，并使您的函数在之前未初始化的情况下返回错误。如果初始化不依赖于输入值，则函数可以在必要时隐式运行初始化

普通的

int a = -1;
int main(int argc, char *argv[]){
    // parse file in arg and initialize variables declared as extern
    
    a = 10;
}
    
int add(int a, int b){
    return a + b;
}
    
void print(int n){
    printf("%d",n);
}

#include "common.h"

int a = -1;
int main(int argc, char *argv[]){
    // parse file in arg and initialize variables declared as extern
    
    a = 10;

    return local_main();
}
    
int add(int a, int b){
    return a + b;
}
    
void print(int n){
    printf("%d",n);
}

本地的

#include <common.h>
    
int main(){
    add(5,10);
    print(a);  // I want to access 'a' initialized in common.c here
    
    return 0;
}

#include "common.h"
    
int local_main(){
    add(5,10);
    print(a);  // I want to access 'a' initialized in common.c here
    
    return 0;
}

编辑作为对评论的答复

这是嵌入式软件项目的一部分[…] c中的main解析文件并初始化变量，而在我的local.c中，我有一个main，在那里我调用函数&使用common.c和common.h中声明和定义的变量

必须重命名其中一个函数

而不是上面所示的解决方案，其中，local.c中的函数main调用common_init函数或common.c中的类似函数。您可以采用另一种方法，要求您的特定本地应用程序代码具有名为local_main的函数，或由common.c中的函数调用定义的任何您选择的名称，并具有将在中从main调用的特定签名和行为普通的

例如：

普通的

#ifndef __DAEMON_COMMON__
#define __DAEMON_COMMON__

extern int a;
extern const char* type;
    
    
int add(int a, int b);
void print(int n);
    
#endif

#ifndef __DAEMON_COMMON__
#define __DAEMON_COMMON__

extern int a;
extern const char* type;
    
    
int add(int a, int b);
void print(int n);

/* declaration of required function in local.c */
int local_main(void);
    
#endif

普通的

int a = -1;
int main(int argc, char *argv[]){
    // parse file in arg and initialize variables declared as extern
    
    a = 10;
}
    
int add(int a, int b){
    return a + b;
}
    
void print(int n){
    printf("%d",n);
}

#include "common.h"

int a = -1;
int main(int argc, char *argv[]){
    // parse file in arg and initialize variables declared as extern
    
    a = 10;

    return local_main();
}
    
int add(int a, int b){
    return a + b;
}
    
void print(int n){
    printf("%d",n);
}

本地的

#include <common.h>
    
int main(){
    add(5,10);
    print(a);  // I want to access 'a' initialized in common.c here
    
    return 0;
}

#include "common.h"
    
int local_main(){
    add(5,10);
    print(a);  // I want to access 'a' initialized in common.c here
    
    return 0;
}

---

通常包括.h文件，而不是.c文件。在大多数情况下，包含.c文件是错误的。当然，也有例外。h文件通常包含相应的.c文件中函数和变量的声明，以使其他文件中的代码知道它们。不能有多个主功能。请回答您的问题并说明为什么有两个主要功能。显示您的代码。如果您的源文件很大，请简化它们以创建一个。@Bodo其中一个c文件位于不同的目录中—要包含在本地代码中的公共目录。我已经分享了代码。我认为不同的di

---

通过使用编译器选项-I some_include_dir，文件的目录位置只影响include目录的所需规范。如果您对此有任何问题，请在问题中添加有关所有示例文件的位置以及运行编译器的当前工作目录的详细信息。另一个问题：主函数的预期用途是否相同。c变量的初始化？为什么不直接使用int a=10；这不是int a=-1？@Bodo，而是嵌入式软件项目的一部分，common.c和common.h是系统头文件include目录的一部分，因此我将把include放在local.c中。common.c中的main解析文件并初始化变量，而在我的local.c中，我有一个main，在其中调用函数并使用common.c和common.h中声明和定义的变量。通常，您包括.h文件，而不是.c文件。在大多数情况下，包含.c文件是错误的。当然，也有例外。h文件通常包含相应的.c文件中函数和变量的声明，以使其他文件中的代码知道它们。不能有多个主功能。请回答您的问题并说明为什么有两个主要功能。显示您的代码。如果您的源文件很大，请简化它们以创建一个。@Bodo其中一个c文件位于不同的目录中—要包含在本地代码中的公共目录。我已经共享了代码。我认为文件的不同目录位置只会通过使用编译器选项-I some_include_dir影响include目录的所需规范。如果您对此有任何问题，请在问题中添加有关所有示例文件的位置以及运行编译器的当前工作目录的详细信息。另一个问题：主函数的预期用途是否相同。c变量的初始化？为什么不直接使用int a=10；这不是int a=-1？@Bodo，而是嵌入式软件项目的一部分，common.c和common.h是系统头文件include目录的一部分，因此我将把include放在local.c中。c中的main解析文件并初始化变量，而在我的local.c中，我有一个main，在那里我调用函数&使用common.c和common.h中声明和定义的变量