C 中的每个 function 是否应该有自己的.c 文件？ 或者我可以将我程序的所有功能放在一个.c 文件中吗？

Question

I'm new to C programming and i just started studying functions. Should i put each function in a.c and.h file, or can i put all of the functions and headers in one.c and.h file? Thank you.

Answer 1

Determining where to put different parts of your code is something that comes with both your personal and the programming language experience. Considering your mention that you're currently learning about functions, let me go over a couple main factors in deciding where to put your functions.

Prototypes

---

When writing your code, before you can use a variable, you need to declare it first. The same goes for functions. The first, simple approach is defining a function before you use it.

int add(int a, int b) {
    return a + b;
}

int main(void) {
    int result = add(10, 8);
    return 0;
}

Here I defined a function add() and called in the function main() . This piece of code will simply compile and run. However, what if I placed my definition of the add() function below the main() function?

int main(void) {
    int result = add(10, 8);
    return 0;
}

int add(int a, int b) {
    return a + b;
}

This piece of code will result into a compilation error. The compiler doesn't know which add() function I'm calling in the main() function, because no add() function has been defined yet. Sometimes you can solve this problem by simply re-arranging the code. Other times that is not possible and that's why prototyping comes into play.

int add(int a, int b);

int main(void) {
    int result = add(10, 8);
    return 0;
}

int add(int a, int b) {
    return a + b;
}

This tells the compiler there is a function add() accepting two int parameters, that will be defined later in the code. The compiler is satisfied and indeed - this piece of code compiles without an issue once again.

The #include directive

---

Including headers in C is a bit troublesome. It is the method of including the definitions in header files inside your .c files, and it's done in the simplest way imaginable - every #include <my_header.h> directive in your C code gets simply replaced with all contents of the my_header.h file before the compilation. For example imagine the following files:

my_header.h

// Hello, I am the my_header.h file
// I currently have no definitions

my_program.c

#include "my_header.h"

int main(void) {
    // Do nothing
    return 0;
}

If I compile just my_program.c , the preprocessor will examine the file before the compiler does. It will find an #include directive, look for a file named my_header.h , find it and copy its contents into the .c file simply like this:

// Hello, I am the my_header.h file
// I currently have no definitions

int main(void) {
    // Do nothing
    return 0;
}

Then the resulting file will be given to the compiler.

While this approach is incredibly simple and easy to implement, it makes C very prone to errors and hard to maintain, unless great care is taken. This is for example the reason include guards exist. Imagine you include two files in your main file. Now both of those two files include one, third file. After all the replacements done, you'll end up having the third file pasted twice inside your code, which will result in naming conflicts during a compilation.

This also means you technically can put any sort of code inside the header files. However, in my whole career, I was met with only one case when such code was acceptable (in a bare metal embedded system program), so I can't stress this out enough - unless you really, really know what you're doing, never put anything other than function prototypes, variable declarations, includes and macros inside a header file. Doing otherwise is the easiest way to have your code break in the most inexplicable of ways.

The conclusion

---

The style I've seen the most often (and also personally follow) is separating sets of functions with similar functionalities into individual .c files. This .c file contains nothing, but function definitions (ie the code) and a single #include directive of the header file this .c file is associated with. This keeps all the functions in a separate translation unit .

The header file with include guards (isn't needed when you don't include the file more than once anywhere, but it's a good habit to get used to) contains all the required #include directives of system libraries, other header files in your project and function prototypes of every function in the respective .c file. Whenever you then need to use those functions elsewhere, include this header file in any other header file. System libraries are generally included using <> while your own files are included using "" .

As remarked by other answers, the .c file containing the main function can often exists without the respective header file. All other .c files should have a header file associated. This is mostly in line with the Google's C++ Style Guide .

An example

---

For any smaller project, you most likely won't need more than just two files. Take these as an example:

main.h

#ifndef _MAIN_H_
#define _MAIN_H_

#include <stdio.h>
// any other includes

int add(int a, int b);
int sub(int a, int b);

int main(int argc, char *argv[]);

#endif // _MAIN_H_

main.c

#include "main.h"

int main(int argc, char *argv[])
{
    int first = 10;
    int second = 8;
    int third, fourth;

    third = add(first, second);
    fourth = sub(third, first);

    return 0;
}

int add(int a, int b)
{
    return a + b;
}

int sub(int a, int b)
{
    return a - b;
}

If you were to add more mathematical functions, say mul() and div() , it'd be appropriate to take them all out of the main.c file and create a new pair of files - something along the way of my_math.c and my_math.h , following the same rules as the rest of your project. Then, to call the mul() function in your main function, you'd need to #include my_math.h inside main.h .

---

A lot of this comes with the experience. Feel free to explore other styles and try out what works the best for you. The most important part in all of this is staying consistent . Pick a style and stick to it. Best of luck in your studies!

Answer 2

Should every function (definition) in C have its own .c file?

No. should not, but can . It's a matter of coding-style, but it's not the preferred way to do so and unusual. It increases compilation and linking time.

---

Or can I put all the function (definitions) of my program in one .c file?

Yes, you can . Also again, matter of one's own coding-style.

If you got a lot or several functions in your code, you can also group the function definitions into own .c files and then link the files when invoking the compiler.

This way you keep clarity.

One way is also to keep all function definitions in a separate .c file, apart from main.c , which contains the main function.

---

Should I put each function in a .c and .h file?

Function definitions can't be placed inside of .h files.

.h consist only of function and other variable declarations, as well as macro definitions.

Function definitions need to be placed in .c files.

If you mean to place each function definition into an own .c file and each function declaration in an own .h , that definitely does not need to be either.

It even would confuse you all the way up.

You actually can do so, but it is definitely not recommended.

---

Or can I put all of the functions and headers in one .c and .h file?

Again here you can't put function definitions in an .h file.

But you can pack all function definitions in one .c file and all function declarations in one .h file.

Answer 3

No. There is no need to do it at all. That would be affect your performance really badly.

Usually we only tend to create new files.h to store functions/methods that we want to use repeatedly in other projects or programs I guess.

Your program should be as follows:

Let's call this prog1.c

#include <only libs that you need>

    void functionA (parameterType parameter){
        //Whatever your function needs to do
    }
    int main(){
       //this is your main function and where the program will start working.
       functionA(parameters) /*Here is how you call functionA if it's void giving it's needed parameters.*/
    }

Later on, with more knowledge you'll learn when you need to store or not the functions in others files to learn and keep it organized. There's no need for that now. You should focus the most on learning how they work and communicate with each other.

If you need to use functionA in other file, well then you will just need to include that.c file, like this:

In prog2.c you start it by calling out

#include "prog1.c"