C - Identifiers in C

An identifier is the name given to a variable, function, array, or any other user-defined item in a C program.

Example:

int count;
float total;
void display();

1. Scope of Identifiers in C

Scope defines where an identifier can be accessed in a program.

Types of Scope in C

(a) Block Scope

• Identifier is declared inside a block { }

• Accessible only within that block

• Typically applies to local variables

Example:

void main() {
    int x = 10;   // block scope
    printf("%d", x);
}

Here, x is accessible only inside main().

(b) Function Scope

• Applies to function names

• A function is visible throughout the program once declared

Example:

void display();   // function declaration

void main() {
    display();
}

void display() {
    printf("Hello");
}

(c) File (Global) Scope

• Identifier declared outside all functions

• Accessible to all functions in the same file

Example:

int g = 20;   // global variable

void fun() {
    printf("%d", g);
}

(d) Prototype Scope

• Applies to function parameters in function prototypes

• Scope exists only within the prototype

Example:

void add(int a, int b);   // a and b have prototype scope

2. Lifetime of Identifiers in C

Lifetime defines how long an identifier exists in memory during program execution.

Types of Lifetime

(a) Automatic Lifetime

• Default for local variables

• Created when block is entered

• Destroyed when block exits

Example:

void fun() {
    int x = 5;   // automatic lifetime
}

(b) Static Lifetime

• Exists throughout the entire program execution

• Memory allocated once

• Value is retained between function calls

Example:

void fun() {
    static int count = 0;
    count++;
    printf("%d", count);
}

(c) Global Lifetime

• Global variables exist from program start to end

Example:

int total;   // global lifetime

(d) Dynamic Lifetime

• Memory allocated at runtime using malloc(), calloc()

• Exists until explicitly freed using free()

Example:

int *p = (int*)malloc(sizeof(int));
free(p);

3. Visibility of Identifiers in C

Visibility defines whether an identifier can be seen or accessed from a particular part of the program.

Visibility Rules

(a) Local Variables

• Visible only inside the block where declared

Example:

void main() {
    int a = 10;
}

a is not visible outside main().

(b) Global Variables

• Visible to all functions in the same file

• Can be accessed in other files using extern

Example:

int g = 10;

void fun() {
    printf("%d", g);
}

(c) Static Variables

• Visibility depends on where declared:

  • Inside function → visible only within that function

  • Outside function → visible only within that file

Example:

static int x = 5;   // file-level static variable