DEV Community: Khaled Mustafa

Scope and lifetime of variables

Khaled Mustafa — Sat, 21 May 2022 07:22:43 +0000

Memory layout of a program in C
1. RAM
2. ROM
3. What is the difference between a statically defined variable and a dynamically defined variable?
Scope of a variable
1. Block scope
2. File scope
3. Program scope
What is the difference between a variable definition and declaration?
Storage classes
1. auto
2. static
3. extern
4. register

Memory layout of a program in C

Before jumping into exploring the scope and lifetime of a variable in C we first need to define the memory layout of a common program.
As we know we, have two types of memories RAM (Random Access Memory) which is used for storing the data generated by a program, and ROM (Read Only Memory) which is used for storing the instructions of a program.

RAM

+---------------------+
|    Memory Mapped    |
|    Peripherals      |
+---------------------+
|    Initialized      |
|    Data Segment     |
+---------------------+
|    Uninitialized    |
|    Data Segment     |
+-----+---------------+
|     | Heap          |
|     |               |
|     v               |
|                     |
|                     |
|                     |
|                     |
|     ^               |
|     |               |
|     | Stack         |
+-----+---------------+

RAM is divided into mainly four portions:
1. Memory Mapped Peripherals
2. Initialized Data Segment: This segment contains all variables that have been initialized with a value.
3. Uninitialized Data Segment (bss) Contains all uninitialized variables (those that have been defined but not assigned any value)
4. Heap
5. Stack

ROM

+---------------------+
| Interrupt Vector    |
| Table (IVT)         |
+---------------------+
| Text Segment        |
|                     |
+---------------------+
| Constant data       |
| Segment (.ro data)  |
+---------------------+
| Boot loader         |
|                     |
|                     |
+---------------------+

What we are concerned with here is the text segment which is used for storing the instruction (code) of the program, and the constant data segment which is used for the storage of every statically defined constant.

What is the difference between a statically defined variable and a dynamically defined variable?

Variables that have a value before the run-time of the program are called statically defined variables while variables that don't have a value before the runtime of the program and are assigned a value during the runtime and will get its value from elsewhere are known as dynamically defined variables.

Scope of a variable

The scope of a variable is the region in which we can use a variable.
There are three different variable scopes in C:

Block scope (Function scope)
File scope
Program scope

Block scope

Variables having this type of scope are limited in their usage to the region (block) in which they were defined, we can not use it outside the code block.
A block (code block) is the whole region starting with { and ending with }.

File scope

Variables that we could refer to in any location in the file in which they have been declared.
There are two storage classes that we are concerned with regarding the file scope, static and extern.
static storage class has two completely different consequences on a variable (depending on the type of the variable it's used on), if the variable is local then it increases its lifetime to the whole program, and if the variable is global it limits its scope to the module (file) it was defined in, in other words, we can't use the keyword extern on such variables.

Program scope

These are all non-static global variables, such that they could be accessed from anywhere in the program, but to use a global variable that has been defined in a file (module) elsewhere from where we intend to use we must first declare it.
The lifetime of a global variable is the whole lifetime of the program.

What is the difference between a variable definition and declaration?

Declaration is informing the compiler of the existence of a variable, so that compiler could ignore it for the time being and later the linker comes and links a value to that variable, we can never use a variable that has not been first declared.
Declaration involves specifying the variable with a symbol and a data type. Example for this the keyword extern int k is just informing the compiler that there is a variable called k and it's of data type int that has been defined somewhere else in the program, use it for now and the linker will handle its value.
Only functions and constants could be only declared, rather than defined and declared.
A definition provides the compiler with all the information it needs to generate machine code when the entity is used later in the program, (the linker doesn't have a job when the compiler can see the definition of a variable).
Since constant variables are static variables (i.e. They must have a value before the run-time of the program) a definition must be provided by the programmer before the compilation process.
A declaration of a built-in type such as int is automatically a definition because the compiler knows how much space to allocate for it.
Examples:

/* Delcare and define int variables i and j. */
int i = 0;
int j;

/* Decleration without definition. */
extern int k;

int main()
{
  /* This results in an error because there is no declaration instance for the variable l.
      error: ld returned 1 exit status */
  i = k + l;
}

Storage classes

C provides different types of storage classes, the most commonly used ones are:

auto
static
extern
register

Let's take everything and know what it does.

auto

This specifier class is rarely used as it's the default storage class for block-scoped variables.
Each time a block is entered storage for auto variables defined in that block is made available and ceases to exist as soon as we exit the block.
The allocation and de-allocation of the variable in memory are done automatically, hence the name.
All uninitialized auto variables have garbage values so we must initialize them before we use them.
Example:

/* Both these variables are similar to each other. */
int x;
auto int x;

static

It has two different effects on a variable depending on its scope whether is local or global.
If the variable is local, the static specifier extends its lifetime to be the whole program, but it doesn't extend its scope, its scope is limited to the function it was defined in.
static in block scope (local variable) with an initializer will only be initialized one time on program startup, not each time the function is called.
Since its lifetime has been extended its storage location has changed from a normal local variable stored on the stack to a constant variable stored in the program memory.
Example:

void myFunc(int i)
{
  int x = 2;
  static int result = 0;
  result += x;
  printf("The result is %d on the %d iteration.\n", result, i);
}

int main(void)
{
  for (int i = 0; i < 4; i++)
  {
    myFunc(i);
  }
}

In essence, the static specifier transfers the value of the variable from one function call to another.
When used on a global variable the static specifier limits the scope of this variable to only the file (module) it has been defined in (i.e. In other words we can't use the keyword extern on such variables).
The static specifier could also be used on function limiting its usage the same way it does to global variables.

extern

It's used for informing the compiler (declaring) that a variable of a specific name and data type exists somewhere in the program and for now just use it as it's and the linker will handle the assignation of a value to it.
In essence, it's used to extend the scope of a global variable.
Example, if we have two files file1.c and file2.c:
file1.c

/*Decleration and defintion of a global variable x.*/
int x = 8;

file2.c

#include "file1.c"

int main(void)
{
  extern int x;

  printf("The value of x %d.\n", x);

  return 0;
}

Notice that including a C file into another file is a legal, but not advisable thing to do, what we rather would do in a real program is define our variables in a header file and then include it, this example is for illustration only.

register

This specifier is used for storing the variable in a register, this is done to decrease the time the program is required to access the memory we know that this variable will be accessed multiple times throughout the lifetime of the program.
The compiler doesn't guarantee that it will store the specified variable in the register, if no freely available register this specifier would be ignored.

Endianness

Khaled Mustafa — Sat, 21 May 2022 07:21:15 +0000

What is Endianness?

It refers to how the bytes of our data are ordered inside the memory.
There are two types of endianness a processor could come with (technically they are three):
1. Big Endian
2. Little Endian
3. Biendian (From its name these types of processors could be configured as any type.)
Note that two hex numbers are of size one byte.

Most significant bit and Least significant bit

Consider taking a variable of data type int (ie. size of 4 bytes) having a value of 0x12345678 the Most Significant Bit (MSB) would be 0x1 and the Least Significant Bit (LSB) would be 0x8, similarly, the most significant byte would be 0x1234 and the least significant byte would be 0x5678.

What is the difference between Big Endian and Little Endian?

Big Endian

Stores the most significant bytes first and then stores the least significant byte, so the most significant byte occupies the lower address of the memory while the least significant byte occupies the higher address memory.

Little Endian

Store the least significant byte first and then stores the most significant byte, so the least significant byte is stored in the lowest memory address while the most significant byte is stored in the higher address.

Example

Consider the hex value of 0x03E8:
Note that 0x00 and 0x01 are the address of the byte of the memory (as memory is byte-addressable).

     Big Endian       Little Endian
     +--------+        +--------+
     |        |        |        |
 0x00|  0x03  |    0x00|  0xE8  |
     +--------+        +--------+
     |        |        |        |
 0x01|  0xE8  |    0x01|  0x03  |
     +--------+        +--------+

Why is it important?

Endianness is important when two computers (processors) are communicating with each other, take for an example is processor #A is little-endian while processor #B is big-endian, when processor #A sends out data it's going to send the least significant byte first and since processor #B is of big-endian it's going to interpret it as the most significant byte, thus all the data will be flipped.

How to determine the type of endianness your processor is running?

Note that we will have to perform pointer downcast and the reason for that is the length modifier %x is of integer type. Check the man pages
If we didn't do this conversion the result would be the same integer regardless of the architecture of our processor.

printf("The size of data type long long is %d.\n", sizeof(long long));
printf("The size of data type int is %d.\n", sizeof(int));

/* Assign an 8 byte value to x. */
unsigned long long x = 0x0000000000000004;

/*Assign the address of variable x to x_ptr. */
unsigned long long *x_ptr = &x;

/* Both x_ptr and y_ptr have the same value which is the address of variable x.
   What are doing here is just telling the processor is variable y_ptr is pointing at an integer, rather than the data type long long.
*/
unsigned int *y_ptr = (unsigned int *)x_ptr;

/* Derefrence the value of y_ptr. */
unsigned int y = *y_ptr;

/* Just printing out the value of y with 0s leading as padding. */
printf("The value of y is %#.8x", y);

The result will vary from one architecture to another, the value of y would be 0x00000003 if we are running a little-endian processor (which we are, since x86 processors are little-endian), and the value of y would be 0x00000000 if we were running a big-endian architecture.
Try out this code

Fun fact: Origin of the name

The naming Big Endian and Little Endian comes from Jonathan Swift's satire Gulliver's Travels, in his book a big-endian refers to a person who cracks an egg from the large end and a little-endian refers to the one who cracks an egg from the little end.

Stack implementation using C

Khaled Mustafa — Sat, 14 Aug 2021 16:57:38 +0000

Stack

What is a stack?

A stack is a data structure in which the insertion or deletion of an element is done only to its topmost element called the top.

A good analogy for stacks is a stack of cafeteria trays in which trays are stacked on top of each other, and because the last tray is at the top of this stack it's going to be the first one to be removed from the stack.

This type of data structure is called Last In First Out (LIFO).

The act of add or inserting an item to a stack is called Pushing, and the act of removing an item is called Popping.

Specifications of a stack

(These are only the specifications and by no means an algorithm of implementation)

The first step we must perform in working with any stack is to create it.

Initialization

Precondition: None
Post-condition: Created and initialized an empty stack. We initialized our stack to be empty as we don't want to work with a stack filled with garbage values from whatever values existed at that address before we reclaimed it to ourselves.
In other words, we are initializing the value of top to be 0.

Status

We want to always check the status of our stack as we don't want to push an item to a full stack and similarly we don't want to pop from an empty stack.
StackFull
- Precondition: The stack has been created and initialized.
- Post-condition: Returns True if the stack is full and False otherwise.
StackEmpty
- Precondition: The stack has been created and initialized.
- Post-condition: Returns True if the stack is empty, and False otherwise.

Basic operations on the stack

The two basic operations done on any type of a stack are pushing or pulling an item, so let's define those.
Push
- Precondition: The stack should be created and not Full.
- Post-condition: The item that we want to add (Argument passed to Push) is added to the top of the stack, thus the top of the stack has increased.
Pull
- Precondition: The stack should be created and not empty.
- Post-condition: The top of the stack is removed and returned to us, thus decreasing the top of the stack.

Other operations

Other operations could be performed on a stack but they are not essential for its operation, nevertheless, they are useful.

Clearing the stack

Precondition: The stack exists and is initialized.
Postcondition: The stack is empty.

Determining the stack size

Precondition: The stack exists and is initialized.
Postcondition: Returns the number of entries (items) in the stack.

Determining the top item on the stack

Precondition: The stack exists and is not empty.
Postcondition: The top item on the stack is returned, but not removed.

Implementation of the stack using arrays (in C)

There are two types of implementation of an array Contiguous and Linked, we are going to focus for now on the first type.

If we wanted our stack to be represented as an array, what do we need to accomplish this?

We will need an array of type "whatever elements" we are going to store them in it, and we are going to need a pointer to keep track of the topmost element in our array (stack).

So basically a stack is just an array and a pointer to the top element, let's start with those.

We will create a structure of those two, and call it Stack.

Since they are of different types (Top of type int, and an array of whatever we are going to store) that we want to combine into one form, we will use a structure.

Definition of our stack

typedef struct stack {
int top;
char entry[10];
}Stack;

This code contains a lot of constants, that if we wanted to change the type of the item we want to store, or for example wanted more than 10 elements, we will have to change the core definition of the stack, and this contradicts with the principle of information hiding.

// If we wanted to change the type or the number of elements we could do it from here and leave
// the core definition of the stack alone.
#define MAXSTACK 10
typedef char StackEntry;

typedef struct stack {
int top;
StackEntry entry[MAXSTACK];
}Stack;

So that's it for our initial definition of the stack, pretty ain't :P.
Now let's implement the basic operations.

Notice that, for the basic operations to operate there is a pre-condition that must be fulfilled, and that is checking the status of the stack, so we have to implement those too.

Pushing

To push an item to the stack, what do we need?

We need the item that we are going to push item and the struct we just defined.

When specifying any data type, we use call-by-reference when a subprogram (function) may change the parameter.

That is why we passed the address of structure Stack to the pointer S, and to access any element we want in the Stack we use the -> arrow operator.

Bringing into focus that the value of top indicates how many items there are in our stack meaning that before assigning our item the value of top will be pointing to the position to be filled.

For clarification, since the array starts from 0, the value of Top will indicate the number of elements that exists until we reach the end of the array, this means that by the end of filling our stack the value of Top will be the value of MAXSTACK .

Don't try to print the content of the array at MAXSTACK as it's an uninitialized memory location and will contain whatever garbage value there is in that location.

As you can see in the diagram below when there exist two items the Top is of value 2.

push(StackEntry item, Stack *s)
{
    if (StackFull(s))
        ERROR("Stack is full");
    else
        s->entry[s->top++] = item;
}

Now let's analyze our code, as stated to push an item we first need to perform our stack status check, so we call our function StackFull() which we will implement later, if the stack is full, it prevents us from pushing our item, and prints an error message stating that our stack is full, else it allows us to push it.

So what we codded is "Access the array that is called entry at index top and add the item to the array, then increment the value of top, to point to the next value to be filled"

We want to increment the value of top after we have pushed our element, to point on the next location to fill, that is why we used the postfix increment top++.

Popping

Similarly, we implement the pop function by tweaking some differences, that is instead of writing to the Stack we are going to read from it and write the value stored there to a variable called item outside the function (We will pass that value's address) as it is outside the pop function's scope, but before reading remember that Top is pointing to an empty location and that's if the stack was not full, and it could be pointing to a garbage value and that's if it was full, so first we have to decrement it and then read the value, that why we use the pre-decrement operator.

pop(StackEntry *item, Stack *s)
{
    if (StackEmpty(s))
        ERROR("Stack is empty");
    else
        *item = s->entry[--s->top];
}

Note that the expression s->top is evaluated to top that resides in the Stack, so --s->top is similar to --top if and only if we are within the scope of the Stack. In other words s->--top is a syntax error.

Other operations

Checking if the stack is empty and if the stack is full

This implementation is rather simple all we have to do is writing a simple if condition, and return a non-zero value if the stack is empty and full.

Stack is empty

_Bool StackEmpy(Stack *s)
{
    return (s->top <= 0);
}

The return of this function will always be either 1 if the condition applies and 0 if the condition doesn't apply.

Stack is full

Bool StackFull(Stack *S)
{
    return (s->top > MAXSTACK);
}

Note that we used a pointer to the stack (Call by reference) even though we are not changing anything in the stack and only reading, and the reason for this is efficiency as if we passed by the value we would have copied the whole stack into both functions. i.e. It could be Bool StackFull(Stack s), meaning we pass the whole stack (Pass by value), but as stated it is a waste of memory space and time.

Initialization of the stack

Initialization of the stack means moving the top back to the zero position and not clearing the values of the stack.

This is a critical function as without it the top will have a garbage value.

void CreateStack (Stack *s)
{
    s->top = 0;
}

Getting the topmost element

So what we want to do is to print out the topmost item of our stack, in other words, we want to pop it, but at the same time, we don't want to change our stack so we will have to re-pop it again.

void StackTop(StackEntry *item, Stack *s)
{
    *item = s->entry[s->top-1];
}

Remember that top is pointing to an empty location if the stack is not full and a garbage value it's full.

Finding the stack size

To find the size of the stack we just print out the value of top.

int StackSize(Stack *s)
{
    return s->top;
}

Clearing the stack

Clearing the stack is just re-pointing the top to 0.

You are going to say that we have already implemented this in a function called CreateStack()and that's correct but we will reimplement just for the sake of the concept of information hiding (abstraction).

In the case of our current implementation (using an array) the elements are not destroyed, they still exist in the memory, it's just the value of top that changed, but in the other implementation (using linked stack) the elements are going to be destroyed (kind of).

void ClearStack(Stack *s)
{
    s->top = 0;
}

Traverse Stack

What we want to accomplish is to pass on every element of the stack and display it to the user but we have a little problem here, we want to accomplish this using abstraction concept, the problem lies in that the user has a piece of information that is hidden from us and that is the type of the element stored in the array, similarly the user doesn't know how the stack is implemented, he only uses the function that we have provided so to overcome this problem the user is going to define a function that displays only one element, then we are going to take this function and pass on every element thus displaying all the elements of the stack.

// User implemented function
void Display(StackEntry item)
{
    printf("The stack item is: %d\\n", item); // The data type is known only by the user.
}

Now notice that we are going to pass the address of the Display() function.

So the traverse function will take first the address of the stack and then the address of the Display()function. i.e. TraverseStack(&s, &Display).

void TraverseStack(Stack *s, void (*pDisplay) (StackEntry))
{
    for(int i = s->top; i>0; i--)
        (*pDisplay)(*s->entry[i-1]);
}

To pass a function as a parameter to another function we need to know its address in memory, its return type, and the type of argument it takes. So basically what we have codded is: The parameter pDispalay will be a pointer to a function that has a void return type and which takes a single StackEntry parameter.

User level implementation

An example of how a user will use our implementation of the Stack.

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

void Display(StackEntry item) {

    {
      printf("  ----- \\n");
      printf("|   %d   |\\n", item);
    }
}
void main(void) {
    Stack myStack;
    int item = 0;
    StackCreate(&myStack);

  for (int count = 0; count < MAXSTACK; count++)
    {
      printf("Please enter the value you want to enter in the stack:");
      scanf("%d", &item);
      Push(item, &myStack);
    }
  TraverseStack(&myStack, &Display);
}

DEV Community: Khaled Mustafa

Scope and lifetime of variables

Table of Contents

Memory layout of a program in C

RAM

ROM

What is the difference between a statically defined variable and a dynamically defined variable?

Scope of a variable

Block scope

File scope

Program scope

What is the difference between a variable definition and declaration?

Storage classes

auto

static

extern

register

Endianness

What is Endianness?

Most significant bit and Least significant bit

What is the difference between Big Endian and Little Endian?

Big Endian

Little Endian

Example

Why is it important?

How to determine the type of endianness your processor is running?

Fun fact: Origin of the name

Stack implementation using C

Stack

What is a stack?

Specifications of a stack

Initialization

Status

Basic operations on the stack

Other operations

Clearing the stack

Determining the stack size

Determining the top item on the stack

Implementation of the stack using arrays (in C)

Definition of our stack

Pushing

Popping

Other operations

Checking if the stack is empty and if the stack is full

Stack is empty

Stack is full

Initialization of the stack

Getting the topmost element

Finding the stack size

Clearing the stack

Traverse Stack

User level implementation