# Variables storage

## Simple explanation

**When a variable is declared**, **the process will reserve a certain amount of memory** on the stack to store the value of the variable. The process will allocate enough memory to hold the entire possible value. For example, if you declare a string with size 20, the process will allocate 20 bytes of memory on the stack for that string.

If no value is initialized, **the initial value of the variable will be undefined**. This means that it **may have any value**, and that value **may be different each time the program is executed**.

When a value is assigned to a variable, the compiler will store that value at the memory address associated with the variable.

{% hint style="danger" %}
Therefore, it is generally not recommended to rely on the initial value of a variable if it has not been explicitly initialized. This can lead to unpredictable behavior.

It is generally best practice to initialize variables to known values when they are declared.
{% endhint %}

## Code example

{% code lineNumbers="true" %}

```c
#include <stdio.h>
#include <string.h>

int main(void) {
  char string1[16]; // create an array of characters with size 16
  char string2[16]; // create a second array of characters with size 16

  printf("string1 stack address : %p\n", string1);
  printf("string2 stack address : %p\n", string2);

  printf("%s\n", string1);
  printf("%s\n", string2);

  // fill the first string with 15 'A's followed by a null character '\0'
  memset(string1, 'A', 15);
  string1[15] = '\0';

  // fill the second string with 15 'B's followed by a null character '\0'
  memset(string2, 'B', 15);
  string2[15] = '\0';

  printf("String 1: %s\n", string1); // print string 1
  printf("String 2: %s\n", string2); // print string 2

  return 0;
}

```

{% endcode %}

This code will declare two arrays of characters, `string1` and `string2`, and set them with the strings "AAAAAAAAAAAAAAA" and "BBBBBBBBBBBBBBB", respectively.

The output of this program would be : &#x20;

```
string1 stack address : 0xfff7da80
string2 stack address : 0xfff7da70

�C��
String 1: AAAAAAAAAAAAAAA
String 2: BBBBBBBBBBBBBBB
```

This code provides a basic example of how variables are treated on the stack in C.&#x20;

## Stack representation

When the `string1` variable is declared, the process reserve 16 byte onto the stack to store this variable :&#x20;

```markup
  address   |   values
------------+-------------------------------------------------------------------
            |   +------------------------- string1 --------------------------+
0xffffd280: |   | 0x01	0x00	0x00	0x00	0x54	0xd3	0xff	0xff |
0xffffd288: |   | 0x5c	0xd3	0xff	0xff	0xad	0x62	0x55	0x56 |
            |   +------------------------------------------------------------+
0xffffd290: |    0xb0	0xd2	0xff	0xff	0x00	0x00	0x00	0x00
0xffffd298: |    0x00	0x00	0x00	0x00	0x46	0xce	0xdd	0xf7
  ...       |    ...
```

{% hint style="info" %}
Note that values on the stack aren't initialized to any specific value. If there is already some data in the memory space allocated to the variable, this data will remain until it is overwritten by a new value.
{% endhint %}

When the `string2` variable is declared, the process reserve 16 byte onto the stack to store this variable

```
  address   |   values
------------+-------------------------------------------------------------------
            |   +------------------------- string2 --------------------------+
0xffffd270: |   | 0xfc	0x73	0xfa	0xf7	0x01	0x00	0x00	0x00 |
0xffffd278: |   | 0x00	0x90	0x55	0x56	0xdb	0x62	0x55	0x56 |
            |   +------------------------------------------------------------+
            |   +------------------------- string1 --------------------------+
0xffffd280: |   | 0x01	0x00	0x00	0x00	0x54	0xd3	0xff	0xff |
0xffffd288: |   | 0x5c	0xd3	0xff	0xff	0xad	0x62	0x55	0x56 |
            |   +------------------------------------------------------------+
0xffffd290: |    0xb0	0xd2	0xff	0xff	0x00	0x00	0x00	0x00
0xffffd298: |    0x00	0x00	0x00	0x00	0x46	0xce	0xdd	0xf7
  ...       |    ...
```

The variable `string2` is stored above the `string1` variable due to LIFO system

Then, the process will do a `memset()` to each  variable to set "A" and "B" 15 times respectively into `string1` and `string2` and then put a null byte `0x00` at the end of the string

```
  address   |   values
------------+-------------------------------------------------------------------
            |   +------------------------- string2 --------------------------+
0xffffd270: |   | 0x42	0x42	0x42	0x42	0x42	0x42	0x42	0x42 |
0xffffd278: |   | 0x42	0x42	0x42	0x42	0x42	0x42	0x42	0x00 |
            |   +------------------------------------------------------------+
            |   +------------------------- string1 --------------------------+
0xffffd280: |   | 0x41	0x41	0x41	0x41	0x41	0x41	0x41	0x41 |
0xffffd288: |   | 0x41	0x41	0x41	0x41	0x41	0x41	0x41	0x00 |
            |   +------------------------------------------------------------+
0xffffd290: |    0xb0	0xd2	0xff	0xff	0x00	0x00	0x00	0x00
0xffffd298: |    0x00	0x00	0x00	0x00	0x46	0xce	0xdd	0xf7
  ...       |    ...
```

{% hint style="info" %}
`string1` contains 15 `0x41` wich is the hex value of `A` following by a null byte `0x00`&#x20;

`string2` contains 15 `0x42` wich is the hex value of `B` following by a null byte `0x00`
{% endhint %}

##