¿Por qué los índices de matriz negativa tienen sentido?

Me he encontrado con una experiencia extraña en la programación en C. Considera este código:

int main(){
  int array1[6] = {0, 1, 2, 3, 4, 5};
  int array2[6] = {6, 7, 8, 9, 10, 11};

  printf("%d\n", array1[-1]);
  return 0;
}

Cuando compilo y ejecuto esto, no recibo ningún error o advertencia. Como dijo mi profesor, el índice de matriz -1accede a otra variable. Todavía estoy confundido, ¿por qué demonios un lenguaje de programación tiene esta capacidad? Quiero decir, ¿por qué permitir índices de matriz negativos?

La operación de indexación de matriz a[i]adquiere su significado a partir de las siguientes características de C

1. La sintaxis a[i]es equivalente a *(a + i). Por lo tanto, es válido decir 5[a]para llegar al quinto elemento de a.

2. La aritmética de puntero dice que dado un puntero py un entero i, p + i el puntero pavanza por i * sizeof(*p)bytes

3. El nombre de una matriz ase convierte rápidamente en un puntero al elemento 0 dea

En efecto, la indexación de matrices es un caso especial de indexación de puntero. Dado que un puntero puede apuntar a cualquier lugar dentro de una matriz, cualquier expresión arbitraria que parezca nop[-1] está mal por examen, por lo que los compiladores no (no pueden) considerar todas esas expresiones como errores.

Su ejemplo a[-1]donde arealmente es el nombre de una matriz es realmente inválido. IIRC, no está definido si hay un valor de puntero significativo como resultado de la expresión a - 1donde ase sabe que es un puntero al elemento 0 de una matriz. Entonces, un compilador inteligente podría detectar esto y marcarlo como un error. Otros compiladores pueden seguir cumpliendo mientras le permiten dispararse en el pie al darle un puntero a una ranura de pila aleatoria.

La respuesta informática es:

• En C, el []operador se define en punteros, no en matrices. En particular, se define en términos de aritmética de puntero y desreferencia de puntero.

• En C, un puntero es abstractamente una tupla (start, length, offset)con la condición de que 0 <= offset <= length. La aritmética del puntero es esencialmente aritmética elevada en el desplazamiento, con la advertencia de que si el resultado de la operación viola la condición del puntero, es un valor indefinido. Desreferenciar un puntero agrega una restricción adicional que offset < length.

• C tiene una noción de undefined behaviourque permite a un compilador representar concretamente esa tupla como un número único, y no tener que detectar ninguna violación de la condición del puntero. Cualquier programa que satisfaga la semántica abstracta estará seguro con la semántica concreta (con pérdida). Cualquier cosa que viole la semántica abstracta puede ser aceptada, sin comentarios, por el compilador y puede hacer cualquier cosa que quiera hacer con ella.

Las matrices se presentan simplemente como fragmentos contiguos de memoria. Un acceso a una matriz tal como una [i] se convierte en un acceso a la ubicación de memoria AddressOf (a) + i. Este código a[-1]es perfectamente comprensible, simplemente se refiere a la dirección anterior al inicio de la matriz.

Esto puede parecer una locura, pero hay muchas razones por las cuales esto está permitido:

• es costoso verificar si el índice i a a [-] está dentro de los límites de la matriz.
• Algunas técnicas de programación en realidad explotan el hecho de que a[-1]es válido. Por ejemplo, si sé que en arealidad no es el comienzo de la matriz, sino un puntero en el medio de la matriz, a[-1]simplemente obtiene el elemento de la matriz que está a la izquierda del puntero.

Como explican las otras respuestas, este es un comportamiento indefinido en C. Considere que C se definió (y se usa principalmente) como un "ensamblador de alto nivel". Los usuarios de C lo valoran por su velocidad inquebrantable, y verificar cosas en tiempo de ejecución está (en su mayoría) fuera de discusión por el mero rendimiento. Algunas construcciones de C que parecen absurdas para las personas que provienen de otros lenguajes tienen perfecto sentido en C, como estea[-1] . Sí, no siempre tiene sentido (

Se puede usar dicha función para escribir métodos de asignación de memoria que accedan a la memoria directamente. Uno de estos usos es verificar el bloque de memoria anterior utilizando un índice de matriz negativo para determinar si los dos bloques pueden fusionarse. He usado esta función cuando desarrollo un administrador de memoria no volátil.

C no está fuertemente tipado. Un compilador de C estándar no verificaría los límites de la matriz. La otra cosa es que una matriz en C no es más que un bloque contiguo de memoria y la indexación comienza en 0, por lo que un índice de -1 es la ubicación de cualquier patrón de bits anteriora[0] .

Otros idiomas explotan los índices negativos de una manera agradable. En Python, a[-1]devolverá el último elemento, a[-2]devolverá el penúltimo elemento, etc.

En palabras simples:

Todas las variables (incluidas las matrices) en C se almacenan en la memoria. Digamos que tiene 14 bytes de "memoria" e inicializa lo siguiente:

int a=0;
int array1[6] = {0, 1, 2, 3, 4, 5};

Además, considere el tamaño de un int como 2 bytes. Luego, hipotéticamente, en los primeros 2 bytes de memoria se guardará el entero a. En los siguientes 2 bytes se guardará el entero de la primera posición de la matriz (eso significa matriz [0]).

Entonces, cuando dices matriz [-1] es como referirse al entero guardado en la memoria que está justo antes de la matriz [0], que en nuestro es, hipotéticamente, entero a. En realidad, esta no es exactamente la forma en que las variables se almacenan en la memoria.

//:Example of negative index:
//:A memory pool with a heap and a stack:

unsigned char memory_pool[64] = {0};

unsigned char* stack = &( memory_pool[ 64 - 1] );
unsigned char* heap  = &( memory_pool[ 0     ] );

int stack_index =    0;
int  heap_index =    0;

//:reserve 4 bytes on stack:
stack_index += 4;

//:reserve 8 bytes on heap:
heap_index  += 8;

//:Read back all reserved memory from stack:
for( int i = 0; i < stack_index; i++ ){
    unsigned char c = stack[ 0 - i ];
    //:do something with c
};;
//:Read back all reserved memory from heap:
for( int i = 0; i < heap_index; i++ ){
    unsigned char c = heap[ 0 + i ];
    //:do something with c
};;