- Call Us: +91 9188262375
- Email Us: info@conlinecourse.com
External Storage Class in C Programming
Table of contents
-
Introduction
-
Turbo C++ IDE
-
A Basic C Program
-
Fundamentals
-
Input/Output Functions
-
Control Statements
-
Arrays
-
Strings
-
Functions
-
Storage Classes
-
Structure
-
Union
-
Pointers
-
Dynamic memory allocation
-
File
-
Graphics
-
The C Preprocessor
-
Standard Library Functions
-
ASCII Table
-
Examples
-
Questions and Answers
External Storage class or Global variable
External variables are global to the file in which they are defined. External variables are used only when all functions needed a particular variable. It retains the assigned value within the scope. In the following program variable i is an external variable.
Example:
In C programming, the `extern` storage class specifier is used to declare variables or functions that are defined in other files or translation units. It allows these variables or functions to be used across multiple files, enabling modularity and separation of concerns in larger programs. Here's a detailed overview of the external storage class in C:
Characteristics of External Variables:
- 1. Declaration: Variables or functions declared with the `extern` keyword are declared without allocating memory for them. They serve as references to symbols defined elsewhere.
- 2. Linkage: External variables or functions have external linkage, meaning they can be accessed by other translation units in the same program.
- 3. Scope: The scope of external variables is global, allowing them to be accessed from any part of the program.
- 4. Memory Allocation: Memory for external variables is allocated in a separate translation unit where they are defined. The `extern` declaration informs the compiler about the existence of these symbols without allocating memory for them.
Syntax for Declaring External Variables:
extern data_type variable_name;
Syntax for Declaring External Functions:
extern return_type function_name(parameters);
Example of External Variables:
File 1: main.c
#include <stdio.h>
extern int count; // Declaration of external variable
int main() {
printf("Count: %d\n", count); // Accessing external variable
return 0;
}
int count = 10; // Definition of external variable
In this example, the external variable `count` is declared in `main.c` using the `extern` keyword, and its definition is provided in `other.c`. The `main` function in `main.c` can access the value of `count` defined in `other.c`.
Example of External Functions:
File 1: main.c
#include <stdio.h>
extern void greet(); // Declaration of external function
int main() {
greet(); // Calling external function
return 0;
}
#include <stdio.h>
void greet() {
printf("Hello, world!\n");
}
In this example, the external function `greet` is declared in `main.c` using the `extern` keyword, and its definition is provided in `other.c`. The `main` function in `main.c` can call the `greet` function, which is defined in `other.c`.
Use Cases for External Storage Class:
- 1. Modular Programming: External variables and functions allow for modular programming by separating different parts of the program into separate files.
- 2. Shared Resources: External variables can be used to share resources or data between different parts of the program.
- 3. Library Interfaces: External functions are commonly used in library interfaces to provide access to functions defined in library files.
Considerations:
- 1. Avoid Excessive Use: Excessive use of external variables can lead to tight coupling between different parts of the program, making it harder to maintain and understand.
- 2. Global State: External variables introduce global state, which can make the program more difficult to reason about and debug.
- 3. Name Clashes: Care should be taken to avoid naming conflicts between external variables or functions defined in different files.
Summary:
The `extern` storage class specifier in C is used to declare variables or functions that are defined in other files or translation units. It enables modularity and separation of concerns by allowing symbols to be shared across multiple files. While useful for certain scenarios, excessive use of external variables and functions should be avoided to maintain code readability and understandability.