Array of Pointers in C how is the operator [ ] used

Like already explained by dbush, your first example is wrong. A more practical use case to demonstrate the pointer part with a string:

 #include <stdio.h>

 int main(int argc, char** argv) {
     char *str = "abc"; //string literal - constant!
     printf("%p address of str[0] - str[0] = %c \n", str, *str);
     printf("%p address of str[1] - str[1] = %c \n", str+1, *(str+1));
     printf("%p addredd of str[2] - str[2] = %c \n", &str[2], str[2]); //alternative notation
 return 0;
 } 

Also there are several similarities between arrays and pointers, for the string example you can not change the string (the string literal is constant), but you can change the pointer to another string. Other with an array, where you can change the content, but you can not iterate over the array with ++arr, like you can do with the pointer notation, nor can you change the address of arr. Another fact, the array name is the address of the array. And yeah its the same address as the first array element.

With time you will find several useful cases for arrays of pointers, because you already know, that switching the pointer (the adresses of the object the pointer points to) often provide a more performant method than using the objects themselves...

I would expect that my normal array gives me the values. And the array that holds of pointers gives me the addresse of the values.

You put the same data into each array, so it's not surprising that you got the same data out of them. Specifically:

char *array[] = {'a','b','c','d'};

In this case, you created an array containing four values, and you told the compiler that those values are of type char *. But whatever their type, they're still the same values, 'a', 'b', and so on. You might as well have written:

char *array[] = {97, 98, 99, 100);

because that's exactly the same thing. Specifying the type of the contents of the array as char * doesn't make the compiler treat the values in the array differently -- it doesn't say "oh, I guess in this case I should take the addresses of those values instead of using the values themselves" just because the type is char *. If you want an array of pointers to some set of values, you'll need to get those pointers yourself using other means, such as the & operator, allocating space for each one, etc.

Note: In a comment below, M.M. points out that using values of type char to initialize an array of type char * isn't allowed by the C standard. In my experience, compilers typically warn about this kind of thing (you should've gotten several warnings like warning: incompatible integer to pointer conversion initializing 'char *' with an expression of type 'int' when you compiled your code), but they'll still soldier on and compile the code. In summary: 1) Don't do that, and 2) different compilers may do different things in this situation.

I know that '[]' is used to dereference and get the value of the address the pointer is pointing at but it is also used to access array elements and the only reasonable explanation here is that it does both at the same time.

An array in C is a single contiguous piece of memory in which a number of values, all of the same type and size, are arranged one after another. The [] operator accesses individual values within the array by calculating an offset from the array's base address and using that to get the value. I think the thing that's confusing in your example is that you've created an array of char *, but with values that look like char. As far as the compiler is concerned, though, 'a' (a.k.a. 97, a.k.a. 0x61) is an acceptable value for a pointer to a character, and you could dereference that and get whatever character is stored at location 0x61. (In reality, doing that might cause an exception; the lowest region of memory is reserved on many machines.)

I know that [] is used to dereference and get the value of the adress the pointer is pointing at but it is also used to access array elements and the only reasonable explanation here is that it does both at the same time. Is this how I should think about it?

No. [] is used (in the place you use it) to indicate an array in which the initializer will state the number of elements the array has. Derreferencing a pointer is done with the * left unary operator.

The expression

char *array[] = ...

is used to declare an array of pointers to chars, that will be initialized (normally) with a list of string literals, like these:

char *array[] = { "First string", "Second string", "third string" };

and

char array[] = { 'a', 'b', 'c', 'd' };

making use of the information given above, declares an array of characters with space for four characters, and initialized with array[0] = 'a', array[1] = 'b', array[2] = 'c', array[3] = 'd'.

So the first example will give you an error when trying to initialize an array cell (of pointer to char type) with an integer value (a char is a type of integer) and the second example will compile and execute fine.

The reason you get the same output in both case is unknown(Undefined Behaviour) (well I have some idea) because you have assigned to a pointer variable an integer value (this is probably the thing as the value stored is small enough that can be reinterpreted back without losing information) but the thing is that you have stored the same thing in the array cells, so why do you ask why the output is the same..... what did you expect? You store a char value in a pointer variable and then get it back and print in both samples with exactly the same format specifier, why do you expect (except for conversion errors back to an integer) both codes printing different things? (well, it's undefined behaviour, so you can expect anything and the computer can do otherwise)

There are two compiler warnings you elegantly skip:

 warning: initialization of 'char *' from 'int' makes pointer from 
integer without a cast [-Wint-conversion]
    6 | char *array[] = {'a','b','c','d'};
      |                  ^~~

And the second warning:

warning: format '%c' expects argument of type 'int', but argument 2
 has type 'char *' [-Wformat=]
    8 |         printf("%c\n", array[i]);
      |                 ~^     ~~~~~~~~
      |                  |          |
      |                  int        char *
      |                 %s

The suggested %s of course would not help. To get valid char-pointers into array[] it would take a "..." string literal, a malloc or a & adress-of on char variable.