Defining function in .h vs .c file - c

Question

I have the following program setup:
// main.c
#include "str.h"
...
trim("Hello");
// str.h
char* trim(char* str) {
return str;
}
// str.c
#include "str.h"
[empty]
And compiled as: $ gcc main.c str.c -o run && ./run, and I get the following error:
/tmp/ccEUb8mH.o: In function `trim':
str.c:(.text+0x0): multiple definition of `trim'
/tmp/ccCiyN5A.o:main.c:(.text+0x0): first defined here
collect2: error: ld returned 1 exit status
However, as soon as I change str.h/c to the following declration/definition it works:
// str.h
[empty]
// str.c
#include "str.h"
char* trim(char* str) {
return str;
}
What's the reason the second version works but the first one does not?
I suppose it has to do with that the following will work fine:
char * trim(char * str);
char * trim(char * str);
char * trim(char * str);
char * trim(char * str);
char * trim(char * str);
But with definitions it will not:
char * trim(char * str){return str};
char * trim(char * str){return str};
error: redefinition of ‘trim’

Answer 1

When you define a function in a header file, every source file that includes it will have a definition of that function. And for each source file you compile, it creates an object file containing the function definition. Then when you link those source files together to make an executable, you have multiple definitions of the function which gives you the error.
In your example you compiled and linked in one step, however the object files for each source file are still created as temporary files before being linked.
By putting the definition of trim in str.c, you only have a single definition for it in one file, while the header has a declaration that other modules can use to know how to call the function.

Answer 2

Apart from that it is common practice to put definitions in header files and implementations in source files, there is another way to circumvent the problem:
#ifndef HEADER_H
#define HEADER_H
// header.h contents go here ...
#endif
When the header is included the first time ,HEADER_H is not defined yet, so it will get defined, and the functions / variables will be defined. When the header is included the second time, HEADER_H is already defined, and the whole part of code that is in the ifdef - endif part will be skipped. Though you should put your definitions in the header file, and the implementations into the source file, you should put such a guard into your header files all the same. Note that HEADER_H must be replaced with a different name in each header, normally you just take the name of the header file and replace all minuses - and dots . with an underscore _ .

Answer 3

The reason is linker(ld) sees two definitions of trim function, one from main.c and other from str.c, because the header file is included in both files.
// main.c
#include "str.h"
...
trim("Hello");
the above is equal to
// main.c
char* trim(char* str) {
return str;
}
...
trim("Hello");
and in //str.c you are including str.h , so the str.c contents will be, after inclusion of header contents.
//str.c
char* trim(char* str) {
return str;
}
Now when you issue command: gcc main.c str.c -o run && ./run
str.c:(.text+0x0): multiple definition of `trim'
/tmp/ccCiyN5A.o:main.c:(.text+0x0): first defined here
In the error compiler (precisely the linker) clearly pointed out two definitions of trim.
So, defining functions in header files is not a good practice, there are few scenarios people do that but we need to take care when using, else we will be facing these multiple definitions errors.

Answer 4

Whenever you use #include with any file it's inserted at the spot where your include is. So
// foo.h
void a(char b) {
// code
}
// main.c
#include "foo.h"
// main code
Is equivelent to
// main.c
void a(char b) {
// code
}
// main code
However, nothing stops you from including foo.h multiple times. This causes redefinition errors, which you get in your case. Putting function definitions in your .c file insures it's only included the one time. You can redaclare templates though, so it's common to put something like void a(char b); in your .h file.