How to Use extern to Share Variables Between Source Files in C

By the end of this page, you will understand the difference between declaring and defining a global variable in C, what extern means, how scope and linkage affect shared variables, and how to correctly share one variable across multiple source files without causing linker errors.

In C, extern is mainly used to say:

"This variable exists somewhere else. I want to use it here, but I am not creating storage for it in this file."

That idea is the key to understanding extern.

Declaration vs definition

A global variable can appear in two important ways:

• Definition: actually creates the variable and allocates storage for it.
• Declaration: tells the compiler the variable exists and what its type is.

Example:

int counter = 0;      // definition
extern int counter;   // declaration

The definition creates one real counter variable in the program. The extern declaration does not create a second variable. It only allows another source file to refer to the existing one.

Why this matters

C programs are often split into multiple .c files. Each source file is compiled separately, so the compiler needs to know the types of names used in that file. If one file wants to use a global variable defined in another file, it needs a declaration. That is what extern is for.

Scope vs linkage

Think of a shared global variable like a company storage locker.

• The definition is the actual locker built in one location.
• An extern declaration is a note telling people: "The locker exists in building A; use that one."
• If every building creates its own locker with the same name, there is confusion.
• If everyone only has notes but no locker was ever built, nothing can be stored.

So:

• one real locker = one definition
• many references to that locker = extern declarations

This is why extern is about referring to existing storage, not creating new storage.

Core syntax

Define a global variable

int counter = 0;

This creates the variable.

Declare a global variable from another file

extern int counter;

This says the variable exists somewhere else.

Basic multi-file example

globals.h

#ifndef GLOBALS_H
#define GLOBALS_H

extern int counter;

#endif

globals.c

#include "globals.h"

int counter = 0;

main.c

  {
    (, counter);
    counter += ;
    (, counter);
     ;
}

Consider these files.

globals.h

#ifndef GLOBALS_H
#define GLOBALS_H

extern int counter;

#endif

globals.c

#include "globals.h"

int counter = 10;

main.c

#include <stdio.h>
#include "globals.h"

int main(void) {
    printf("%d\n", counter);
    counter++;
    printf("%d\n", counter);
    return 0;
}

Step-by-step

1. is included in

When shared globals are used

Although global variables should be used carefully, they do appear in real C programs.

Configuration flags

extern int debug_enabled;

Used by multiple source files to enable extra logging.

Program state counters

extern unsigned long request_count;

Useful in small tools or embedded systems to count events.

Hardware register mappings in embedded C

A shared global may represent device state or a system-wide handle used across modules.

Shared error/status values in legacy code

Older codebases sometimes expose shared status variables accessible from several files.

Better alternatives in many cases

In modern C code, developers often prefer:

• passing values through function parameters
• keeping state inside a struct
• limiting visibility with static
• exposing accessor functions instead of raw globals

These approaches reduce coupling and make code easier to test.

In real projects, extern is usually part of a small, repeatable pattern.

Common pattern: declaration in header, definition in source

app_state.h

#ifndef APP_STATE_H
#define APP_STATE_H

extern int app_mode;

#endif

app_state.c

#include "app_state.h"

int app_mode = 1;

This is the standard way to expose one global object to multiple files.

Common pattern: hide most globals with static

Developers often avoid exposing variables unless necessary.

static int internal_cache_size = 128;

This variable can only be used inside its own .c file. That is often safer.

Access through functions

1. Defining the variable in a header

This is a very common mistake.

Broken code

/* globals.h */
int counter = 0;

If several .c files include this header, each file gets its own definition, causing linker errors.

Correct version

/* globals.h */
extern int counter;

/* globals.c */
int counter = 0;

2. Using extern but never defining the variable

Broken code

/* globals.h */
extern int counter;

If no source file contains:

int counter;

then the linker cannot find the real variable.

3. Confusing scope with linkage

Beginners may think changes scope everywhere automatically. It does not.

extern declaration vs definition

External linkage vs internal linkage

Quick rules

• extern usually means: this variable is defined somewhere else
• Use extern for declarations, not for creating the variable
• Define the variable once in one .c file
• Put the extern declaration in a header if multiple files need it
• Include that header wherever the variable is used

Common pattern

/* globals.h */
extern int counter;

/* globals.c */
int counter = 0;

/* main.c */
#include "globals.h"
counter++;

Remember

• int counter = 0; → definition
• extern int counter; → declaration
• static int counter = 0; → private to that source file

Linkage summary

What does extern mean in C?

It means the variable or function is declared here but defined somewhere else, usually in another source file.

Does extern create a variable?

No. A declaration like extern int x; does not create storage for x. It only tells the compiler that x exists.

Where should I put extern declarations?

Usually in a header file, so every source file that needs the variable can include the same declaration.

Where should I define the actual global variable?

In exactly one .c file.

What is the difference between extern int x; and int x;?

extern int x; is a declaration only. int x; at file scope is typically a definition.

Can I use extern inside a function?

Yes. It declares that the name refers to an external variable, but this is less common than putting the declaration in a header.

Can extern access a variable from another file?

• declaration vs definition — extern makes the difference especially important.
• scope in C — helps explain where a name is visible.
• linkage in C — explains whether names refer to the same object across files.
• static in C — often compared with extern because it limits visibility.
• header files in C — the usual place for shared declarations.
• translation units — each .c file is compiled separately, which is why declarations matter.
• linker errors — useful for understanding multiple definitions and undefined references.
• global variables — extern is commonly used with globals.