C - void 函数(void)、参数和返回值

Question

I was given a large C-file containing several functions declared as follows:

void function_a(void);

The functions are written above the main program:

static void function_a(void) { .... }

Within the main program these functions are called as:

function_a();

Now as far as I know a function declared as written above does neither use parameters, nor have return values. However within these functions variables and arrays are used, which are not defined within these functions, but only in the main program.

Is this really correct C-Syntax? How can the functions access data from the main program, if it is not handed over as a parameter?

In addition the main program uses variables, which are calculated within the functions it calls.

Answer 1

Can you provide more context, please? In C you cannot access variables from another function but you can access global ones.

The following program is valid and will output 3, since i is a global variable and is visible everywhere.

#include <stdio.h>

int i = 2;

void plusone() {
        i = i + 1;
}

int main() {
        plusone();
        printf("i = %d\n", i);
}

On the other side, the program below won't compile because i is local to main() function and is invisible elsewhere.

#include <stdio.h>

void plusone() {
        i = i + 1;
}

int main() {
        int i = 2;
        plusone();
        printf("i = %d\n", i);
}

Said that, usage of global variables is a bad practice and should be avoided.

Answer 2

So this:

//file_a.c
void function_a(void)
{
    //...
}

Makes function_a a function that does not take any arguments and does not return any values. This function may be used by all other functions in the same file function_a was declared or in any other .c file that you tell the compiler to put together into the final program.

In other words, this function is accessible to all translation units of your program. If you have this function in a file called file_a.c , and you also have another file called file_z.c you can do this:

//file_z.c
void function_z(void)
{
    function_a();
}

And all is fine.

On the other hand, this

//file_b.c
static void function_b(void)
{
    //...
}

(and I renamed the function for clarity)

Makes function_b a function that does not take any arguments and does not return any values, just like function_a . However, it also says that function_b has static-file scope in the translation unit that begins or includes file_b.c . That means it cannot be accessed by other translation units.

So if you now tried to do this in file_z.c :

void function_z(void)
{
    function_b();
}

You would get compilation errors:

file_z.c:(.text+0xa): undefined reference to `function_b'
collect2: error: ld returned 1 exit status

Because each file_{a,b,z}.c is (or probably should be) the starting point of their own separate translation units, and function_b was declared with static-file scope in file_b.c , this function simply "does not exist" for other translation units.

Now, as to the variables declared just before function_b , I take they look somewhat like this:

//file_a.c
int array[10];
void function_a(void)
{
    //...
}

That simply declares a global variable. It can be accessed by all functions in file_a.c , provided that they appear after the declaration. It can also be used by other translation units (like file_b.c or file_z.c ) if you declare it like this:

//file_b.c
extern int array[10];

When you compile everything togheter, that declaration in the translation unit that starts with file_b.c will tell the compiler that array is not a file-scope variable within that file_b.c ; rather the compiler will have to look for that variable in another translation unit, and then link them together so that all functions do the same thing to that block of 10 integers.

Answer 3

In C it is not at all possible to access local variables of another function or even scope. Is the code compiling correctly? If yes these variables must be global defined either in the beginning or some header file. If not make them global to access from non-parametric functions.