Keeping variables global to the library scope in C

Question

Is there any way to keep global variables visible only from inside a library while inaccessible from programs that access that library in C?

It's not that it is vital to keep the variable protected, but I would rather it if programs couldn't import it as it is nothing of their business.

I don't care about solutions involving macros.

Answer 1

If you use g++, you can use the linker facilities for that using attributes.

__attribute__((visibility("hidden"))) int whatever;

You can also mark everything as hidden and mark explicitly what is visible with this flag: -fvisibility=hidden

And then mark the visible variables with:

__attribute__((visibility("default"))) int whatever;

Answer 2

static int somelocalvar = 0;

that makes somelocalvar visible only from whithin the source file where it is declared (reference and example).

Answer 3

You can use another header file for exporting functionality to outside modules than you have for the internal functionality and thus you don't have to declare globals that doesn't have to be accessible from outside the module.

Edit: There is only linker problems if you declare things more than once. There is no need to keep all global data in one header file, in fact, there may be a wise reason top split it up into several smaller pieces for maintainability and different areas of responisiblity. Splitting up into header files for external data and internal data is one such reason and this should not be a problem since it is possible to include more than one header file into the same source file. And don't forget the guards in the header files, this way, collision in linking is mostly avoided.

#ifndef XXX_HEADER_FILE
#define XXX_HEADER_FILE
code
#endif

Answer 4

Inside the library implementation, declare your variables like that:

struct my_lib_variables
{
  int var1;
  char var2;
};

Now in the header for end-users, declare it like that:

struct my_lib_variables;

It declares the structure as an incomplete type. People who will use the header will be able to create a pointer to the struct, but that's all. The goal is that they have to write something like that:

#include "my_lib.h"

struct my_lib_variables* p = my_lib_init();
my_lib_do_something(p);
my_lib_destroy(p);

The libray code is able to modify the variables, but the library can't do it directly.

---

Or you can use global variables, but put the extern declarations inside a header which will not be used by the end-user.