Access of static variable from one file to another file

Question

I recently came across the question like how to access a variable which declared static in file1.c to another file2.c?

Is it possible to access static variable?

My understanding about static keyword in C is,

static is "internal linkage", so they are accessible only from one compilation unit - the one where they were defined. Objects declared with internal linkage are private to single module.

As one of my friend suggest me below solution.

In file1.c

   #include <stdio.h>

   int main()
   {
          int b=foo();
          printf("%d",b);
          return 0;
   }

in file2.c

   static int a=25;

   int foo()
   {
        return a;
   }

compiled by gcc file1.c file2.c -o file

If I do above I can access the variable.

So my questions are:

1. Does the above program violate static variable rules?

2. If not, why is this so, and is there any other way to access static variable except including file (#include <…>) not like this.

   How am I able to access a static variable from another file?

   In C, how do I restrict the scope of a global variable to the file in which it's declared?

3. Correct me if I'm wrong with static variable concept and if any better solutions are available to access static variable?

Answer 1

1) does the above program violate static variable rules?

No you are not vailoting any rules. Here foo function create copy of value of that static variable and used in other file. Its fine.

2) If not why is this so, and is there any other way to access static variable except including file (#include<>) not like this How am I able to access a static variable from another file?

Static variable are only mean to use in that file only.

You can not use that variable making them extern in other files.

Another dirty hack is to get pointer of that static variable and make that as global pointer and making that as extern in another file you can use that static variable.

file1.c

 #include<stdio.h>
  static int a=25;
  int* ptr = &a;

file2.c

#include<stdio.h>
extern int *ptr;

   int main()
   {
          printf("%d",*ptr);
          return 0;
   }

Correct me if I'm wrong with static variable concept and if any better solutions are available?

1. A static variable has a lifetime extends across the entire run of the program

2. If you do not initialize static variable with some value then its default value would be 0.

3. A static variable has scope limited to its file only. You can not access it by name from a different file.

4. You have temp1.c and temp2.c both are getting compiled together then also you can have static variable of same name in both files — and they are separate variables.

In C, how do I restrict the scope of a global variable to the file in which it's declared?

By making that global variable as static.

Answer 2

With the static int a=25; the variable a will have internal linkage; meaning the linker cannot see a anywhere outside of the file2.c TU.

When you're calling foo() in file2.c, you get a copy of a, it's the copy that you print; but this doesn't mean you have access to the actual a defined in file2.c When you need such an access where the same variable is visible across different TUs, you could do this

Defining file

This file both declares and defines the variable; additionally initializes it to 1 too, without which it'll be default initialized to 0.

// (non-static) global variable with external linkage and thus visible across TUs
int var_across = 0;
void use()
{
   var_across = 1;
}

Using file

// just a declaration to tell that it's defined elsewhere; not a definition
extern int var_across;
void use_here()
{
   var_across = 2;
}

Answer 3

What we commonly call a variable in C is actually two things: an object, the memory allocated for the variable interpreted with a certain type, and an identifier, one way to access that object.

There is no problem in accessing a static object or its value from another compilation unit. Your function foo promotes the value to another unit, that is fine, but it could even promote the address of a without problems.

Having internal linkage only concerns the identifer, the name a. This one is only visible inside file2.c.

Answer 4

Assigning address of static variable to pointer will make static variable available to subfiles.

In subfiles we have to use extern keyword to the pointer.

But it is not necessary to do that.