C - Scope of C Functions

Question

I apologize if this is a beginner's question, but after working in C for a bit, I finally would like a bit of clarification on exactly what kind of files/functions are available to a function.

I understand we can explicitly include other files with the #include macro like so:

#include bar.c

But what about files that are in the same directory? Let's say we have the following file structure:

src-
   |
   a.c
   b.c

And let's say a.c has the function "foo()" and b.c has "bar()"

Would I be able to call bar() within a.c even without explicitly including b.c in the header file?

And what about in sub-directories such as the following:

src-
   |
   a.c
   |
   someFolder-
             |
             b.c

Would I still be able to access bar() in a.c?

Basically, how exactly is the scope of functions (without including them in headers) defined?

Answer 1

You are confusing scope with linkage.

The term scope descibes if an identifier is visible to the compiler in a given context. The broadest scope known to the C language is file scope which means that the identifier is visible from the point it is declared to the end of the translation unit after preprocessing. You can make any identifier visible/known by declaring it, but making an identifier visible does not mean that refering to the identifier refers to the thing it refers to in another file.

The term linkage describes how two identifiers refer to the same thing. There are three levels of linkage: with no linkage, each identifier with the name refers to a different thing. With internal linkage, each identifier within the same translation unit refers to the same thing. With external linkage, each identifier in the whol program refers to the same thing. For two identifiers in two translation units to refer to the same thing, you need to declare both of them to have external linkage.

This is independent of how the declaration is obtained. There is no difference in writing int foo() in a common header file to writing the same line in both source files. In either case, all identifiers refer to the same foo() as functions have external linkage unless explicitly declared to have internal linkage with the static type specifier.

It is also independent of how your source code is laid out. As long as all translation units are linked into the same binary, you can call all functions with external linkage in each translation unit.