How is the value (pointer) of an array declared on the stack stored in memory?

how is it possible that when creating an array on the stack we (consider an example for ints) in the first eight bytes will simultaneously contain a pointer to the array (i.e. a pointer to this variable itself) and the first 2 elements from array?

It is not possible. You are misinterpreting your output. In most cases where a subexpression of array type appears in an expression, it is automatically converted to a pointer to the first array element. This is a special exception to the usual rule for lvalue conversion, with the result that

cout << "Variable value = " << automaticArray

does not, in fact, print the contents of the array. It is 100% equivalent to

cout << "Variable value = " << &automaticArray[0]

. This behavior was inherited from C at the birth of C++, and has remained unchanged since then.

My guess is that the value of the variable (the address of the first element of the array) is not stored anywhere.

Be careful. Arrays and pointers are not at all the same thing. The address of the array indeed is not stored in memory in any accessible form. But the value of the array is an aggregate composed of the values of its elements, and that certainly is stored in memory.

In C++ use std::array and std::vector. Do not get hung up on pointers to arrays if you don't have to. If you ever need a pointer you can use .data() method on both std::array, and std::vector

#include <array>
#include <vector>

// you cannot return "C" style (stack) arrays
// but you can return std::array
std::array<int,4> make_array()
{
    std::array<int,4> values{1,2,3,4};
    return values;
}

int main()
{
    std::array<int,4> array1 = make_array(); // Allocated on the stack

    std::array<int,4> array2{2,3,4,5}; // Also allocated on the stack    

    std::vector<int> vector{1,2,3,4}; // Allocatd (for you) on the heap;

    // when vector goes out of scope memory is deallocated for you
}

The difference is that dynamicArray is a pointer, while automaticArray is an array.

The easier case is dynamicArray. new int[5] {0}; allocates an array and returns a pointer to its first element. In memory you have

 ----------------             
 | dynamicArray |   ------
 ----------------        |
                         |
                         v
                        -------------
                        | 0 1 2 3 4 |
                        -------------    

That is, you have a pointer to int. Its value is the address of the first element of the newly allocated array. Hence &dynamicArray[0] == dynamicArray. The address of that pointer however, is some other remote address, because the pointer is stored separate from the actual array.

Whith automaticArray things are different. In memory you only have

                        -------------
                        | 0 1 2 3 4 |
                        -------------    

And thats it. What you are missing is array to pointer decay. In this line

cout << automaticArray << &automaticArray << &automaticArray[0] << endl;

All three addresses are the same, because automaticArray does decay to a pointer when passed to std::ostream::operator<<. That is because there is no overload that would take a reference to an array of 5 integers. You could write one yourself. For illustration, consider this:

#include <iostream>


std::ostream& operator<<(std::ostream& out, int (&arr)[5]) {
    for (int i=0;i<5;++i) out << arr[i] << " ";
    return out;
}


int main() {

    int automaticArray[5] {1, 2, 3, 4, 5};
    std::cout << automaticArray;
}

Which outputs:

1 2 3 4 5 

You wouldn't actually write code like this, but its only to demonstrate that automaticArray is not a pointer. Its an array. It potentially does decay to a pointer to the first element of the array. And thats what happens in your code, because there is no << overload that takes a reference to array. But if you pass the array via reference then no to-pointer decay happens. In the above example automaticArray is an array and arr is a reference to that array. No pointers are involved.