Extern in C


When it comes to programming in C, one of the essential concepts that developers often encounter is “Extern in C.” Understanding and utilizing external variables can significantly impact the way your C programs handle data and interact with different modules. This article is a complete guide to Extern in C, covering everything from its definition to its practical implementation.

What is Extern in C ?

Extern in C is a keyword used to declare a variable that is defined outside the current scope or module but can be accessed by multiple modules within a C program. In simpler terms, it enables the sharing of variables across different files, providing a way to utilize a single variable across multiple functions and translation units. This capability is vital in large-scale projects where modularity and code organization are essential.

Understanding Scope and Linkage

Before we dive deeper into Extern in C, let’s clarify two critical terms: scope and linkage. Scope refers to the region of a program where a variable is accessible, while linkage determines how the variable associates with other instances of the same name.

Local Scope and No Linkage

In C, variables declared within a function have local scope, meaning they are accessible only within that function. Furthermore, these variables have no linkage, which means they cannot be accessed by other functions or modules in the program.

Global Scope and External Linkage

Global variables, on the other hand, have a broader scope and are accessible throughout the entire program. When a variable is defined outside of any function, it gains global scope. Additionally, if the variable is preceded by the extern keyword, it has external linkage, making it available for use in other modules.

Advantages of Using Extern in C

Using Extern in C offers several advantages that enhance code readability, reusability, and maintainability. Let’s explore some of the key benefits of employing external variables in your C programs.

  1. Modularity and Code Organization: Extern allows you to break down your program into smaller, manageable modules. Each module can then be written and tested independently, promoting a cleaner and more organized codebase.
  2. Memory Efficiency: By sharing variables across modules, you prevent unnecessary duplication of data, leading to efficient memory usage. This can be especially crucial when working with constrained systems.
  3. Ease of Collaboration: When multiple developers work on a project, using Extern in C facilitates collaboration by providing a standardized way to share data among different parts of the program.
  4. Encapsulation: External variables allow you to control the visibility and accessibility of data, promoting the concept of encapsulation and reducing the chances of unintended variable modification.

Using Extern in C

Implementing Extern in C involves a few simple steps. Let’s go through them to understand how to utilize this feature effectively.

  1. Declaring External Variables

To declare an external variable, you need to use the extern keyword followed by the variable’s type and name. This declaration should be placed in a header file, which acts as a global reference for all modules that need access to the variable.

// external_variables.h
extern int globalCounter;
  1. Defining External Variables

In a source file (often referred to as a translation unit), you define the external variable without using the extern keyword. This creates the actual storage for the variable.

// external_variables.c
int globalCounter;
  1. Including the Header File

In each source file that requires access to the external variable, include the header file containing the extern declaration.

// main.c
#include "external_variables.h"

int main() {
    // Use the globalCounter here
    return 0;

Declaring External Functions

Much like declaring external variables, declaring external functions involves the use of the Extern keyword. This technique allows you to declare a function in a header file and then define it in a separate source file. Let’s see how this works in practice.

Step 1: Declare the Function in a Header File

Create a header file, let’s call it external_functions.h, where you declare the function using the Extern keyword.

// external_functions.h
extern void externalFunction();

Step 2: Define the Function in a Source File

In a source file, say external_functions.c, you define the function without using the Extern keyword.

// external_functions.c
#include <stdio.h>

void externalFunction() {
    printf("This is an external function.\n");

Step 3: Using the External Function

In another source file where you intend to use the external function, include the header file and call the function.

// main.c
#include "external_functions.h"

int main() {
    return 0;

Benefits of Using Extern with Functions

By utilizing the Extern keyword with functions, you can harness several advantages that contribute to better code organization and collaboration.

  1. Modularization and Reusability: Like with external variables, using Extern for functions enables you to break down your code into smaller, reusable modules. This encourages code modularity and simplifies the debugging process.
  2. Collaborative Development: When multiple programmers collaborate on a project, declaring functions as external allows each developer to work on different modules simultaneously, promoting efficient teamwork.
  3. Avoiding Code Duplication: With external functions, you can eliminate the need to duplicate code across multiple parts of your program. A single function definition can be shared and accessed wherever necessary.
  4. Enhanced Readability: By centralizing function declarations in header files, your code becomes more readable and understandable. Developers can quickly reference the functions available in different modules.