Sobrecarga Subíndice o operador de índice de array [] en C++

El operador de índice de array o subíndice se indica con ‘[]’. Este operador generalmente se usa con arreglos para recuperar y manipular los elementos del arreglo.
Este es un operador binario o n-ario y se representa en dos partes:

1. posfijo/expresión primaria
2. expresión

La expresión de sufijo, también conocida como expresión principal, es un valor de puntero, como una array o identificadores, y la segunda expresión es un valor integral. En la segunda expresión también podemos incluir los valores enumerados.

Sintaxis:

postfix-expression[expression];

Example: Ramswarup[10];
Here the Ramswarup is an array and the above
statement print the value which is held by
Ramswarup at index position 10.

La expresión primaria seguida del operador subíndice es el puntero y puede ser un valor entero pero se debe tener en cuenta que una de expresión entre dos expresiones debe ser un valor puntero y no importa si la segunda es de un orden integral o no.
Ejemplo:

// CPP program to demonstrate []
// operator
#include <iostream>
using namespace std;
int main()
{
    char name[] = "Ramswarup Tushar Nilesh Subhash";
  
    // Both of the statement prints same thing
    cout << name[5] << endl;
    cout << 5 [name] << endl;
    return 0;
}

a
a

OUTPUT
a
a

Explicación:
En el ejemplo anterior, ambas declaraciones «cout» proporcionan resultados similares debido a la propiedad exclusiva del operador de subíndice. El compilador lee ambas declaraciones de manera similar, por lo que no hay diferencia entre *(name + 5) y *(5 + name) .

Subíndices positivos y negativos
El primer elemento de una array se almacena en el índice 0. El rango de una array de C++ es de array[0] a array[tamaño – 1]. Sin embargo, C++ admite subíndices positivos y negativos. Los subíndices negativos deben estar dentro de los límites de la array; si no lo hacen, los resultados son impredecibles. El siguiente código muestra subíndices de array positivos y negativos:

// CPP program illustrating the
// positive and negative subscripts
#include <iostream>
using namespace std;
  
// Driver Method
int main()
{
    int intArray[1024];
    for (int i = 0, j = 0; i < 1024; i++) {
        intArray[i] = j++;
    }
  
    // 512
    cout << intArray[512] << endl;
  
    // 257
    cout << 257 [intArray] << endl;
  
    // pointer to the middle of the array
    int* midArray = &intArray[512];
  
    // 256
    cout << midArray[-256] << endl;
  
    // unpredictable, may crash
    cout << intArray[-256] << endl;
}

512
257
256
0

El subíndice negativo en la última línea puede producir un error de tiempo de ejecución porque apunta a una dirección de -256 posiciones que puede estar más abajo en la memoria que el origen de la array. El puntero midArray se inicializa a la mitad de intArray; por lo tanto, es posible (pero no recomendado) usar índices de array positivos y negativos simultáneamente. Los errores de subíndice de array no generan errores en tiempo de compilación, pero pueden generar resultados impredecibles.

Hemos introducido la sobrecarga de operadores . En esta publicación se analiza la sobrecarga del operador de índice [].
Los siguientes son algunos datos útiles sobre la sobrecarga de [].
1) La sobrecarga de [] puede ser útil cuando queremos verificar el índice fuera de límite.
2) Debemos regresar por referencia en la función porque una expresión como «arr[i]» puede usarse como un valor l.

El siguiente es un programa de C++ para demostrar la sobrecarga del operador de índice de array [].

// Overloading operators for Array class
#include <cstdlib>
#include <iostream>
  
using namespace std;
  
// A class to represent an integer array
class Array {
private:
    int* ptr;
    int size;
  
public:
    Array(int*, int);
  
    // Overloading [] operator to access elements in array style
    int& operator[](int);
  
    // Utility function to print contents
    void print() const;
};
  
// Implementation of [] operator.  This function must return a
// reference as array element can be put on left side
int& Array::operator[](int index)
{
    if (index >= size) {
        cout << "Array index out of bound, exiting";
        exit(0);
    }
    return ptr[index];
}
  
// constructor for array class
Array::Array(int* p = NULL, int s = 0)
{
    size = s;
    ptr = NULL;
    if (s != 0) {
        ptr = new int[s];
        for (int i = 0; i < s; i++)
            ptr[i] = p[i];
    }
}
  
void Array::print() const
{
    for (int i = 0; i < size; i++)
        cout << ptr[i] << " ";
    cout << endl;
}
  
// Driver program to test above methods
int main()
{
    int a[] = { 1, 2, 4, 5 };
    Array arr1(a, 4);
    arr1[2] = 6;
    arr1.print();
    arr1[8] = 6;
    return 0;
}

1 2 6 5 
Array index out of bound, exiting

Producción:

1 2 6 5
Array index out of bound, exiting

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.