II.18: What is the benefit of using const for declaring constants?

Answer:
The benefit of using the const keyword is that the compiler might be able to make optimizations based on the knowledge that the value of the variable will not change. In addition, the compiler will try to ensure that the values won’t be changed inadvertently.
Of course, the same benefits apply to #defined constants. The reason to use const rather than #define to define a constant is that a const variable can be of any type (such as a struct, which can’t be represented by a #defined constant). Also, because a const variable is a real variable, it has an address that can be used, if needed, and it resides in only one place in memory (some compilers make a new copy of a #defined character string each time it is used—see IX.9).

Reference:
II.7: Can a variable be both const and volatile?
II.8: When should the const modifier be used?
II.14: When should a type cast not be used?
IX.9: What is the difference between a string and an array?

II.17: Can static variables be declared in a header file?

Answer:
You can’t declare a static variable without defining it as well (this is because the storage class modifiers static and extern are mutually exclusive). A static variable can be defined in a header file, but this would cause each source file that included the header file to have its own private copy of the variable, which is probably not what was intended.

Reference:
II.16: What is the difference between declaring a variable and defining a variable?

II.16: What is the difference between declaring a variable and

Answer:
Declaring a variable means describing its type to the compiler but not allocating any space for it. Defining a variable means declaring it and also allocating space to hold the variable. You can also initialize a variable at the time it is defined. Here is a declaration of a variable and a structure, and two variable definitions, one with initialization:

extern int decl1; /* this is a declaration */
struct decl2 {
int member;
}; /* this just declares the type--no variable mentioned */
int def1 = 8; /* this is a definition */
int def2; /* this is a definition */

To put it another way, a declaration says to the compiler, “Somewhere in my program will be a variable with this name, and this is what type it is.” A definition says, “Right here is this variable with this name and this type.”

NOTE
One way to remember what each term means is to remember that the Declaration of Independence didn’t actually make the United States independent (the Revolutionary War did that); it just stated that it was independent.
A variable can be declared many times, but it must be defined exactly once. For this reason, definitions do not belong in header files, where they might get #included into more than one place in your program.

Reference:
II.17: Can static variables be declared in a header file?

II.15: Is it acceptable to declare/define a variable in a C header?

Answer:
A global variable that must be accessed from more than one file can and should be declared in a header file.
In addition, such a variable must be defined in one source file. Variables should not be defined in header files, because the header file can be included in multiple source files, which would cause multiple definitions of the variable. The ANSI C standard will allow multiple external definitions, provided that there is only one initialization. But because there’s really no advantage to using this feature, it’s probably best to avoid it and maintain a higher level of portability.

NOTE
Don’t confuse declaring and defining variables. II.16 states the differences between these
two actions.
“Global” variables that do not have to be accessed from more than one file should be declared static and should not appear in a header file.

Reference:
II.16: What is the difference between declaring a variable and defining a variable?
II.17: Can static variables be declared in a header file?

II.14: When should a type cast not be used?

Answer:
A type cast should not be used to override a const or volatile declaration. Overriding these type modifiers can cause the program to fail to run correctly.
A type cast should not be used to turn a pointer to one type of structure or data type into another. In the rare events in which this action is beneficial, using a union to hold the values makes the programmer’s intentions clearer.
Reference:
II.6: When should the volatile modifier be used?
II.8: When should the const modifier be used?