1. The role of the header file
Most C programming enthusiasts know that in our .h files, we often see function declarations, variable declarations, and various macros, etc., and I also mentioned in my previous article In the modular design of C language, it is often said that the corresponding .h and .c files are considered as an object, then the .h file is mainly some external interfaces, some private data and other implementations will be encapsulated in our .c , if we explain our .h more vividly, it is equivalent to the box composed of recommended article links under the article, click in and you will arrive at the corresponding specific article, and the specific article is our .c file.
Come back to our program here, as shown in the following code:
#include <stdio.h>
#include <stdlib.h>
int sAdd(int a,int b);
int sSub(int a,int b);
//...
int main(int argc, char *argv[]) {
printf("Add: %d\n",sAdd(1 , 1));
printf("Sub: %d\n",sSub(1 , 1));
printf("公众号:最后一个bug\n");
return 0;
}
/***************************************
* Fuction：sAdd
* Author : （公众号:最后一个bug）
***************************************/
int sAdd(int a,int b)
{
return (a + b);
}
/***************************************
* Fuction：sSub
* Author : （公众号:最后一个bug）
***************************************/
int sSub(int a,int b)
{
return (a - b);
}
//...
Let’s analyze it: the above is what most friends do when they first learn programming, then we put the declaration in front of the main function into a corresponding .h file, and put the specific implementation of addition and subtraction into the corresponding .c file, and then Use #include "xxx.h" in front of the main function, that's all. To put it simply, .h can be expanded directly at #include so that we can understand and analyze it.
2. Define functions or variables in the header file
Friends who read a lot of code should have seen the practice of defining functions or variables directly in the header file, so here we directly modify the above to get the following code:
//Filename: main.c
#include <stdio.h>
#include <stdlib.h>
#include "Add.h"
int main(int argc, char *argv[]) {
printf("Add: %d\n",sAdd(global_Var1 , global_Var2));
printf("Sub: %d\n",sSub(global_Var1 , global_Var2));
printf("公众号:最后一个bug\n");
return 0;
}
//Filename : Add.h
/***************************************
* Fuction：sAdd
* Author : （公众号:最后一个bug）
***************************************/
int global_Var1 = 2;
int global_Var2 = 2;
/***************************************
* Fuction：sAdd
* Author : （公众号:最后一个bug）
***************************************/
int sAdd(int a,int b)
{
return (a + b);
}
/***************************************
* Fuction：sSub
* Author : （公众号:最后一个bug）
***************************************/
int sSub(int a,int b)
{
return (a - b);
}
Let's analyze it: the above program can also be compiled and run successfully, and the correct result can be obtained, which further proves that it is understandable to directly expand #include "xxx.h".
3. Why not choose to define variables or functions in the header file
1) Multiple source file declarations.h will be defined repeatedly
If we explain it according to the above expansion method, it is actually easy to understand that multiple source file declarations #include "xxx.h" will result in multiple identical global variables and functions, which will inevitably lead to repeated definition failures. If you don’t believe me Type the code directly to see the result:
#include <stdio.h>
#include <stdlib.h>
#include "APP1.h"
#include "APP2.h"
/*********************************************
* Fuction：main
* Author : (公众号:最后一个bug)
********************************************/
int main(int argc, char *argv[]) {
printf("%d\n",add_APP1(1,1));
printf("%d\n",add_APP2(1,1));
return 0;
}
//Filename:Add.h
/*********************************************
* Fuction：add
* Author : (公众号:最后一个bug)
********************************************/
int add(int a,int b)
{
return (a + b);
}
//Filename:App1.h
int add_APP1(int a,int b);
//Filename:App1.c
#include "Add.h"
/*********************************************
* Fuction：add_APP1
* Author : (公众号:最后一个bug)
********************************************/
int add_APP1(int a,int b)
{
return add(a,b);
}
Analysis: I will not paste the .c and .h corresponding to APP2, after all, the code is relatively simple. The last picture is the compilation result, and the second line shows that the add function is repeatedly defined. Similarly, the author also performed the same method for variables, and it also showed repeated definitions of related variables, so it also verified our previous theory.
2) Add conditional compilation #ifndef
Most of our friends may think that we can directly add conditional compilation #ifndef to the function and variable definitions of the header file to avoid repeated inclusion? Well, the author also conducted this experiment. Let’s take a look at the code and results. , I will explain later:
//Filename:Add.h
/*********************************************
* Fuction：add
* Author : (公众号:最后一个bug)
********************************************/
#ifndef __ADD_H__
#define __ADD_H__
int add(int a,int b)
{
return (a + b);
}
#endif
Let's analyze it: After adding the precompiler, the result is consistent with the result in the previous section, and it still prompts to define the function repeatedly. Why is that? I described a generation process from C program to machine code in the previous "Embedded Programming - C Language (1)". App1.c and App2.c are compiled separately, and then #include are expanded separately , a function and variable with the same name was found in the final linking process, so the compilation will still fail.
3) static can help us get rid of this dilemma
We all know that static means static, and it can also be said to restrict the text of variables and functions. There can be static functions and variables with the same name in multiple files, but they represent different functions and variables. Pay special attention to this point. If the header file uses a large number of variables and functions in different files, it will also cause the increase of the program and the increase of memory. The following author will use the program to prove these points:
//Filename：Add.h
#ifndef __ADD_H__
#define __ADD_H__
static int add(int a,int b)
{
return (a + b);
}
#endif
//filename：App1.c
#include <stdio.h>
#include "Add.h"
/*********************************************
* Fuction：add_APP1
* Author : (公众号:最后一个bug)
********************************************/
int add_APP1(int a,int b)
{
printf("add_APP1_addFuc:0x%x\n",(int*)add);
return add(a,b);
}
Let’s analyze it: only two important paragraphs are posted above, and the code is relatively simple. We found that both of them call add, but their addresses are different, indicating that they are not a function. So you can also divide the Add.h file into a .c and a .h form with our modular design idea, and the final printed address is the same, so I won’t post the code for you to see the result. The address is the same, which means that they are the same function. Similarly, everyone can modify variables with static, and get similar results.
4. Section
In the last section, in fact, there are many reasons why people generally do not define variables or functions in .h files. The most important one is that they do not meet the relevant design requirements. For example, if the code is changed, the compilation will cause a chain reaction and cause the compilation time to restart. There are problems such as long compilation time, and the analysis of the code is more troublesome, so you can actually study this kind of problem in your spare time, and you will gain a lot of unexpected knowledge points in it. Know why", in fact, defining functions or variables in the header file is not without such design requirements. You can consider that the use of static defined in the header file has disadvantages, and will there be any advantages? Haha, here I am I won’t reveal the secret, please listen to the next chapter to break it down!
Resource exchange and gain attention Official account: Qiniu Programming