Include c file in another

Question

I want to include a .c file in another. Is it possible right? It works well if I include a header file in a .c file, but doesn't work as well if I include a .c file in another .c file.
I am using Visual Studio and I get the following error:

main.obj : error LNK2005: _sayHello already defined in sayHello.obj  
/* main.c  */
#include "sayHello.c"

int main()
{
    return 0;
}  
/* sayHello.c */

#include <stdio.h>

void sayHello()
{
    printf("Hello World");
}

I don't know what this error could mean. Time to ask more advanced C coders. :)

Answer 1

I want to include a .c file in another.

No you don't. You really, really don't. Don't take any steps down this path; it only ends in pain and misery. This is bad practice even for trivial programs such as your example, much less for programs of any real complexity. A trivial, one-line change in one file will require you to rebuild both that file and anything that includes it, which is a waste of time. You lose the ability to control access to data and functions; everything in the included .c file is visible to the including file, even functions and file scope variables declared static. If you wind up including a .c file that includes another .c file that includes another .c file und so weiter, you could possibly wind up with a translation unit too large for the compiler to handle.

Separate compilation and linking is an unequivocal Good Thing. The only files you should include in your .c files are header files that describe an interface (type definitions, function prototype declarations, macro defintions, external declarations), not an implementation.

Answer 2

It works, but you need to be careful with how you build the program. Also, as folks have pointed out in comments, it's generally considered a bad idea. It's unexpected, and it creates problems like these. There are few benetfits, especially for what seems like a trivial program. You should probably re-think this approach, altogether.

After doing something like this, you should only compile main.c, and not attempt to link it with the result of compiling sayHello.c, which you seem to be doing.

You might need to tell Visual Studio to exclude the latter file from the build.

Answer 3

Yes, any '.c' file can be included into another program. As one include '.h' file like 'stdio.h' in the program. After that we can call those function written into this external file.

test.c::

#include<stdio.h>
#include<conio.h>
void xprint()
{
    printf("Hello World!");
}

main.c::

#include "test.c"
void main()
{
   xprint();
   getch();
}

Output:: Hello World!

Answer 4

This is a linker error. After compiling all your .c files to .obj files (done by the compiler) the linker "merges" them together to make your dll/exe. The linker has found that two objects declare the same function (which is obviously not allowed). In this case you would want the linker to only process main.obj and not sayhello.obj as well (as its code is already included in main.obj).

This is because in main.obj you will ALSO have the sayHello() function due to the include!

Answer 5

sayHello.h

#include <stdio.h>
void sayHello(void);

main.c

#include "sayHello.h"

int main()
{
    sayHello();
    return 0;
}  

Answer 6

You probably defined two times this function

void sayHello()
{
printf("Hello World");
}

one in your current file and one in sayhello.c

You must remove one definition.

Answer 7

The problem seems to be that sayHello.c got compiled into an object file called sayHello.obj, and main.c (also including all the source text from sayHello.c), got compiled into main.obj, and so both .obj files got a copy of all the external symbols (like non-static function definitions) from sayHello.c.

Then all the object files were supposed to get "linked" together to produce the final executable program file, but the linking breaks when any external symbols appear more than once.

If you find yourself in this situation, you need to stop linking sayHello.obj to main.obj (and then you might not want to compile sayHello.c by itself into its own object file at all).

If you manually control every step of the build (like you might when using the CLI of your compiler), this is often just a matter of excluding that object file from the invocation of the linker or compiler.

Since you are using Visual Studio, it's probably making a bunch of assumptions for you, like "every .c file should be compiled into its own object file, and all those object files should be linked together", and you have to find a way to circumvent or disable this assumption for sayHello.c.

One easy and somewhat idiomatic solution might be to rename sayHello.c into sayHello.c.inc.

Answer 8

//THIS IS THE MAIN FILE//
#include "test.c"
int main()
{
    multi(10);
}


//THIS IS THE TEST FILE//
#include<stdio.h>
void multi(int a)
{
    printf("%d",a*2);
}

POINTS TO BE NOTED:

1. Here you need to run the program which contains "main()" function.
2. You can avoid the "stdio.h" header file in main function. Because, you are including the file which already contains the "stdio.h" header file.
3. You have to call the function from the "main" file.
4. The including file should be "file_name.c" not "file_name.h". Because usually we use .h extension for the header file. Since we are including another program file and not the header file, we have to use .c. Otherwise it will give you Fatal Error and the Compilation gets terminated.

Answer 9

You can declare your function as static inline if you just want it to work. However, as people have suggested, approaching this problem with separate .h and .c files would be better.

static inline void sayHello()
{
    printf("Hello World");
}