La asignación en myPtr = &(x[100]); es incorrecto: hace que myPtr apunte al final de la matriz, lo que provoca un comportamiento indefinido cuando escribe allí y más allá.

Cambie la asignación a myPtr = x; o myPtr = &x[0]; y cambie la última instrucción a printf("%d", *x);

Aquí hay una versión modificada:

 #include <stdio.h> int main(void) { int x[100]; int *myPtr; int j; myPtr = x; for (j = 0; j < 100; j++) { *myPtr = j; myPtr++; } printf("x contains numbers from %d to %d\n", x[0], x[99]); return 0; }

Obtener x[100] es un comportamiento indefinido.

 myPtr = x; for (j=0; j<100; j++) *myPtr++ = j;

Para obtener la dirección de un arreglo basta con evaluar x , que es lo mismo que &x , lo mismo que &x[0] , lo mismo que &0[x] , lo mismo que &*(x+0) .

x[100] es un elemento inexistente de la matriz x porque el rango válido de índices es [0, 100) .

Así que esta declaración

 myPtr = &(x[100]);

establece el puntero myPtr en la dirección de la memoria después del último elemento de la matriz. La desreferenciación de un puntero de este tipo invoca un comportamiento indefinido.

En el ciclo for que llena los elementos de la matriz, necesita un puntero que apunte al primer elemento de la matriz x .

Puedes escribir

 myPtr = &x[0];

Aunque es más sencillo escribir

 myPtr = x;

porque el designador de matriz x utilizado como inicializador se convierte implícitamente en un puntero a su primer elemento.

Su programa puede verse de la siguiente manera

 #include <stdio.h> int main(void) { enum { N = 100 }; int x[N]; int value = 0; // fill the array for ( int *myPtr = x; myPtr != x + N; ++myPtr ) { *myPtr = value++; } // output the array in the ascending order for ( const int *myPtr = x; myPtr != x + N; ++myPtr ) { printf( "%d ", *myPtr ); } putchar( '\n' ); // print the array in the descending order for ( const int *myPtr = x + N; myPtr != x; ) { printf( "%d ", *--myPtr ); } putchar( '\n' ); return 0; }

En los dos últimos bucles for se utiliza un puntero del tipo const int * porque dentro de los bucles los elementos de la matriz a la que apunta el puntero no se modifican.