How do I share variables between different .c files? [duplicate]

Question

This question already has answers here:

How do I use extern to share variables between source files? (19 answers)

Closed 9 years ago.

How can I use a variable in one .c file when it has been previously defined in another .c file?

• Stack Overflow is garbage: I changed your title. Try to make the title more descriptive, so that 1) people who're able to answer it can see easily what you're asking, and 2) so others who have the same question, will be able to find this so they don't have to ask it again. When looking at the list of questions, we don't need to know that it's a beginner question, but we do need to know what the question is about. Just a tip for future questions. :)

Answer 1

In fileA.c:

int myGlobal = 0;

In fileA.h

extern int myGlobal;

In fileB.c:

#include "fileA.h"
myGlobal = 1;

So this is how it works:

• the variable lives in fileA.c
• fileA.h tells the world that it exists, and what its type is (int)
• fileB.c includes fileA.h so that the compiler knows about myGlobal before fileB.c tries to use it.

• user53670: when the variables are static ,it gives me a link error,"unresolvable symbol ",How to deal with that?
• rmeador: @jfq: "static" in non-class context means "confined to this translation unit". it's essentially the opposite of "extern". You can't have both at the same time.
• jdepypere: Just a remark - what if the owner of the variable is the main.c file, and there is no main.h?
• RichieHindle: @arbitter: With no header file, you can't share the variable (unless you put extern int myGlobal; directly into the source file that wants to access myGlobal, but that's a nasty violation of DRY). If you need to share a global from main.c, create main.h!
• jdepypere: @RichieHindle: Not sure if I'm allowed to make a main.h, but I'll just put it in another file then, thanks!

Answer 2

In 99.9% of all cases it is bad program design to share non-constant, global variables between files. There are very few cases when you actually need to do this: they are so rare that I cannot come up with any valid cases. Declarations of hardware registers perhaps.

In most of the cases, you should either use (possibly inlined) setter/getter functions ("public"), static variables at file scope ("private"), or incomplete type implementations ("private") instead.

In those few rare cases when you need to share a variable between files, do like this:

// file.h
extern int my_var;
// file.c
#include "file.h"
int my_var = something;
// main.c
#include "file.h"
use(my_var);

Never put any form of variable definition in a h-file.

• Lundin: I posted this as an answer to an exact duplicate of this post. I feel that some advise regarding the use of global variables was necessary, rather than just blindly teaching bad practice to others without raising a warning first.
• Anthony: Your post is too opinionated considering you've overstated how rare it is to have a valid case for a global variable. Off the top of my head, binary semaphores that govern resource availability in an embedded system have to be global. Any RTOS-based firmware that shares resources will be littered with global semaphores. Similarly, when a global represents something that truly should be available everywhere, it can be simpler and faster in terms of both speed and development. Also, singletons are basically global variables with some syntactic sugar. Oversimplified? Yes, but conceptually valid.
• Lundin: @Anthony There is a difference between global variables, that are accessible from anywhere in the program (hence global) and file scope variables that are static and only accessible from inside the file they are declared in. The latter is not really bad practice, save for in some multi-threaded scenarios. The examples from your comment should all be implemented with file scope variables.
• Anthony: So now you're trying to say every global should be a file scope variable, which is incorrect especially in the embedded world unless you think all code should be in one file. How could you know the scope of the variables in code you've never seen? It's extremely common to implement RTOS tasks that share resources and you would never put multiple, completely unrelated tasks in the same file. I'd love to see a way to control access to that resource without global semaphores. This is just a single example of when a global is extremely useful; there are many others.
• Anthony: All of your "probably" and "should" and "should not" statements while calling anyone who uses a global inexperienced and uneducated puts your opinion in context. Tons of people on SO disagree and tons of "real" programmers also disagree. Globals can reduce code complexity and in a highly performance critical system they are an absolute must. You've obviously never worked on a highly constrained embedded system with nearly impossible hard-deadlines where there's literally no time to call functions from an interrupt. Inline isn't valid either because of space requirements.

Answer 3

if the variable is :

int foo;

in the 2nd C file you declare:

extern int foo;

Answer 4

1. Try to avoid globals. If you must use a global, see the other answers.
2. Pass it as an argument to a function.

• realityinabox: How do you handle interrupts then? Say an interrupt is triggered and I want to read a value on a pin, how would one return that value without writing it to a global variable?
• Thanatos: @realityinabox — That's an incredibly domain specific answer, whereas the OP's question was much more broad. In such a situation, you might very well need a global. (This is an incredibly old answer, and I omitted a lot of details about why — threading, re-entrancy, code readability — as to why a global is typically not the best choice.)
• Anthony: @Thanatos It's not 'incredibly' anything. Unless you think the extensive world of embedded development is something about which a beginner would never inquire, then your answer is too narrow and specific. There are many other reasons to use globals outside of what you apparently believe to be the normal use of C if there is such a thing. Lastly, there's absolutely no context in the OP's question, so your statement about it being broad is an assumption. The OP very well could have been asking about interrupts.
• Dávid Tóth: @realityinabox would you please elaborate on why are global variables should be avioded in generic?
• Jose V: @Thanatos it really irks me when people say that things /should/ be some way without saying why, that's completely worthless information to anyone reading it, if the feature is there then it is intended to be used.

Answer 5

Those other variables would have to be declared public (use extern, public is for C++), and you would have to include that .c file. However, I recommend creating appropriate .h files to define all of your variables.

For example, for hello.c, you would have a hello.h, and hello.h would store your variable definitions. Then another .c file, such as world.c would have this piece of code at the top:

#include "hello.h"

That will allow world.c to use variables that are defined in hello.h

It's slightly more complicated than that though. You may use <> to include library files found on your OS's path. As a beginner I would stick all of your files in the same folder and use the " " syntax.

Answer 6

The 2nd file needs to know about the existance of your variable. To do this you declare the variable again but use the keyword extern in front of it. This tells the compiler that the variable is available but declared somewhere else, thus prevent instanciating it (again, which would cause clashes when linking). While you can put the extern declaration in the C file itself it's common style to have an accompanying header (i.e. .h) file for each .c file that provides functions or variables to others which hold the extern declaration. This way you avoid copying the extern declaration, especially if it's used in multiple other files. The same applies for functions, though you don't need the keyword extern for them.

That way you would have at least three files: the source file that declares the variable, it's acompanying header that does the extern declaration and the second source file that #includes the header to gain access to the exported variable (or any other symbol exported in the header). Of course you need all source files (or the appropriate object files) when trying to link something like that, as the linker needs to resolve the symbol which is only possible if it actually exists in the files linked.