Tukukkk

Apologies if this question has been asked before (I only found variants to this question on SO, but not the exact one)

My question is regarding scope w.r.t where the function prototype is defined.

Assume we have 3 files : test.h, test.c, main.c

main.c and test.c both includes test.h

test.c:

int f2(int b); // function prototype (local)



int x=0;

// public function

int f1(int a){

 return a*5;      

}

// local function

int f2(int b){

 return b*10;

}

test.h:

int f1(int a);

main.c:

#include "test.h"

int x=1;

int main(){

    printf("%d n", f1(5));

    printf("%d n", f2(5));

    return 0;

}

My question is:

• Can main.c access f2() which is implemented and prototype declared inside test.c
  


• Can main.c access f1()? or does it need to be declared as extern
  


• Does main.c have access to the x global variable inside test.c? Will it conflict with the global variable x (same name) defined in main.c?


• To gain local scope is it mandatory to use static keyword?


• Can static functions access global variables (static/non-static) defined in the same .c file ?

In answering your questions, I suppose that the two .c sources are compiled and linked together into one program.

• Can main.c access f2() which is implemented and prototype declared inside test2.c
  

Modern C does not permit calls to functions that have no declaration in scope, but K&R C did permit such calls, and most implementations do still allow them. Moreover, main.c could declare the function itself and then call it.

• Can main.c access f1()? or does it need to be declared as extern
  

Functions have external linkage by default. Accordingly, extern is the default for function declarations. You may explicitly specify extern, but that's redundant.

• Does main.c have access to the x global variable inside test.c? Will it conflict with the global variable x (same name) defined in
  main.c?

Yes and no. It is erroneous for one program to contain two definitions of the same identifier with external linkage, and both your declarations of x do indeed constitute definitions, and both do indeed (by default) have external linkage.

However, some implementations will merge those into one variable, others will refuse to link the program, and others might even maintain separate x variables.

The right way to declare a variable that is shared across source files, by the way, is for each file to declare it, extern, but for exactly one to initialize it. Usually, the extern declarations without initializer would go into a header file, and a single declaration with an initializer (which makes it a definition) would go into one .c file. Example:

test.h

extern int x; // _with_ extern, _without_ initializer

test.c

#include "test.h"

int x = 0;  // 'extern' is optional here

main.c

#include "test.h"

// no further declaration of x here

• To gain local scope is it mandatory to use static keyword?

The static and extern keywords are about linkage, not scope. Linkage has to do with which code can access which objects and functions. Scope is about which code can see which declarations. Although they sound similar, these are in fact quite distinct concepts, because the same object or function can be declared multiple times. In fact, that's routine -- it's one of the primary purposes served by header files.

• Can static functions access global variables (static/non-static) defined in the same .c file ?

Yes, where I interpret "global" to mean "declared at file scope". C does not have a concept of global variables per se, but objects declared outside any function exist for the whole duration of the program. Those with external linkage can be accessed from any code in the program where declarations of their identifiers are in scope. Those with internal linkage (declared by the static keyword) can be accessed only from within the same translation unit, which roughly means the same .c file.

It is also possible for an object to have no linkage. This is the case for objects declared inside functions.

1) Yes, but accidentally. A function with no declarator will default to int type, and its parameters will default to int type, and storage class will default to extern. Your function happens to already have those types. Thus, the declarator is not needed, strictly speaking (though it is a very bad practice to not use one). However, this has apparently been made illegal in C99, and if you are using C99 semantics, you should get an error; otherwise it is just a warning (-Wimplicit-function-declaration).

2) As said above, the lack of storage class specifier in the test.h declarator will implicitly declare f1 as extern. All is well.

3) The linker will raise an error regarding duplicate identifier. If you use extern int x; (with no initialisation), it works. Variables don't get implicit declarations; if you just attempt to use x in main.c without the above declaration, you will get an error regarding use of an undeclared variable.

4) static means several different things. I assume the question is about static functions. This only restricts the visibility of the function to the current compilation unit; there is no other effect.

5) As noted above, making a function static only affects what can access it, not what it can access.

Can main.c access f2() which is implemented and prototype declared inside test2.c

The function f2 will be taken as a default function which has return value of int and parameters int if any. However, if you use different parameters, it will give an error.

From C99 onwards, the default function is not applicable and this will give an error.

Can main.c access f1()? or does it need to be declared as extern

Yes, it can access f1() as you have included test.h However you also need to compile test.c and give both files to the linker.

f1() declaration in test.h does not need to be declared as extern. By default, a function declaration is extern.

Does main.c have access to the x global variable inside test.c? Will it conflict with the global variable x (same name) defined in main.c?

You need to link the variables together. Once you do you will get a linker error for this.

To gain local scope is it mandatory to use static keyword?

If the variable is declared outside a function, it is global. To make it local scope you need to specifically use the static keyword.

Can static functions access global variables (static/non-static) defined in the same .c file ?

Yes