How are functions declared in header files accessed by a program in C

Question

There are three files - mainfile.c, helper.c and helper.h. in the same directory. helper.h contains function prototypes of foo1 and foo2, a struct declaration and some typedefs.

header.h is included in both helper.c and in mainfile.c (helper.h also has include guards, so double declarations aren't a problem.). The functions foo1 and foo2 are defined in helper.c

If I include helper.h in any .c file, my understanding is that the contents of helper.h are literally pasted (word for word) in the .c file at run time. Is my understanding correct?

I used to think that if I call foo1 in mainfile.c the control transfers to the start of foo1, and that foo1 can't interact with anything else defined in helper.c. But there is something wrong with that line of thinking because when I declare a global variable in helper.c, both functions are able to access it. So what does happen when mainfile.c calls foo1 or foo2?

My understanding of the static storage class is that it converts a local variable into a global variable, as all the functions are able to access it. So if I declare a static array in foo1 and then call foo2 in mainfile.c, will foo2 be able to access this static array?

The content of dictionary.c should be something like this

void foo1 (void)
{
    static int array[10] = {1,2,3,4,5,6,7,8,9,10}
    //more code 
}

void foo2 (void)
{
    array[7] = 4;
    // more code
}

When foo2 is called from mainfile , will it be able to access the static array.

Answer 1

Both mainfile.c and helper.c are separate translation units, that yields into individual object files (that are subject to linker). An an ilustration you can compile them seperatetly producing .o files (or .obj on Windows platform):

gcc -c helper.c
gcc -c mainfile.c

then examine their symbols e.g. by nm command. In order to link them use the following:

gcc helper.o mainfile.o

When foo1 is called from mainfile.c, that function has access to its own "global variable" (that is defined in helper.c) and it doesn't matter if that variable has internal or external linkage (note that local variables have no linkage). The real thing is that mainfile.c might have (direct) access to it as well (that is, beside foo1 function) only if such variable has external linkage (it's defined outside any function and doesn't have static storage class). This also requires proper declaration, advisable way is to declare it in helper.h using extern storage class, without inializer, e.g.:

extern int global_variable;

Note that this checks declaration againt definition (as you include "helper.h" header inside helper.c source file).

Update:

As pointed by @jweyrich there is possibility to "bypass" internal linkage of global variable, so it's available (with their address) to "consumer" file source. Here is an short example:

b.h:

int *get_secret(void);

b.c:

#include "b.h"

static int secret = 999;

int *get_secret(void) {
    return &secret;
}

a.c:

#include <stdio.h>
#include "b.h"

int main(void)
{
    int *a;

    a = get_secret();
    printf("%d\n", *a);

    return 0;
}

Even secret global variable has internal linkage (as it has static storage class) it can be accessed in a.c. The same technique applies to functions, when some function returns pointer of function declared with static.

Answer 2

If I include helper.h in any .c file, my understanding is that the contents of helper.h are literally pasted (word for word) in the .c file at run time. Is my understanding correct?

Partially correct. It's during compilation, not at run time.

I used to think that if I call foo1 in mainfile.c the control transfers to the start of foo1, and that foo1 can't interact with anything else defined in helper.c. But there is something wrong with that line of thinking because when I declare a global variable in helper.c, both functions are able to access it.

Yeah, it's wrong. A compilation unit can reference symbols from other compilation units given that those symbols are exported, e.g: non-static functions, non-static global variables, etc.

Even if a non-static variable is not exposed via header (helper.h), it may gain visibility by declaring it with extern in your compilation unit.

So what does happen when mainfile.c calls foo1 or foo2?

Nothing special. The only difference is that foo1 and foo2 (implemented in helper.c) can see all functions and global variables with static storage from their own compilation unit.

My understanding of the static storage class is that it converts a local variable into a global variable, as all the functions are able to access it. So if I declare a static array in foo1 and then call foo2 in mainfile.c, will foo2 be able to access this static array?

If that static array is global, all functions from the same compilation unit can access it, regardless of who's calling them.

UPDATE:

So if I declare a static array in foo1 and then call foo2 in mainfile.c, will foo2 be able to access this static array?

Nope. The array you're trying to reference is declared within foo1, whose scope foo2 has no access to.

Answer 3

The key thing you're missing is the so called "compilation unit scope". Each .c file is compiled separately. The result is a object file that exposes all the symbols defined on the global scope.

After compilation comes linking. The linker collects all the compilation units and throws them all into a single large bucket. From there it makes the connection between all the symbols of all the compilation units used by the program (this also means libraries).

My understanding of the static storage class is that it converts a local variable into a global variable

Actually it's exactly the opposite. A global scope variable declared static will not be exposed by the compilation unit and hence will not be used by the linker for program wide symbol resolution.