Referencia a Array en C++

La referencia a una array significa crear un alias de una array mientras se conserva su identidad. La referencia a una array no será un int* sino un int[]. Discutamos esto en detalle discutiendo la diferencia entre estos dos. Es bastante extraño que int[] sea lo mismo que int*, pero aún así la perspectiva del compilador en ambos es completamente diferente. Las dos diferencias principales son las siguientes:

1. int[] para el compilador es una array, por lo que proporciona un iterador para esto (por eso tenemos For-Each Loop), pero int* es solo un puntero a un número entero. Esto podría ser simplemente un puntero a un número entero o un puntero al comienzo de una array de números enteros que depende totalmente de nuestra perspectiva. Por lo tanto, no hay bucle For-Each en este caso.
2. Para el compilador, a y b son del mismo tipo de datos, es decir, int* aquí para el compilador, solo son int* apuntando a la dirección. Pero para el compilador, el tipo de array es int[2] y el tipo de b como array es int[3], que son completamente diferentes entre sí. Nuevamente, solo la perspectiva del compilador. Para una mejor comprensión, deje que las dos arrays sean int a[2], int b[3].

Implementación: 

• Pasar una array para que funcione de forma clásica.
• Más tarde, tratando de llamar al ciclo for-each en él, se puede obtener una clara diferencia.

Ejemplo:

// C++ Program to demonstrate Above Approach
 
// Importing input output stream to take input
// and to display anything on the console
#include <iostream>
 
using namespace std;
 
// Method 1
// To print array elements
void print(int arr[], size_t n)
{
 
    // Iterating over elements on an array
    // using the foreach loop
    for (int element : arr) {
        // Print the elements of the array
        cout << element << " ";
    }
 
    // New line as all the desired elements are printed
    cout << endl;
}
 
// Method 2
// Main driver method
int main()
{
    // Declaring and initializing Integer array with
    // custom input entries
    int a[]{ 1, 2, 3, 4 };
 
    size_t size = sizeof(a) / sizeof(a[0]);
 
    // Calling the Method1 as created above
    // in the main) method to
    // print array elements
    print(a, size);
}

 
Producción: 

test.cpp: In function 'void print(int*, size_t)':
test.cpp:5:21: error: 'begin' was not declared in this scope
    for(int element: arr){

Salida Explicación:

Aquí está claro que int* no tiene ninguna información sobre la array subyacente, pero si pasa una array por referencia utilizando la plantilla, el código anterior funcionará. Como array de referencia, retiene información sobre la array subyacente y su tipo sería int[4], no int*. 

Ahora analicemos una referencia a una array.

Métodos:

1. método ingenuo 
2. Referencia a una array

Método 1: método ingenuo

Primero, la forma más común que viene a nuestra mente se describe a continuación sintácticamente. Este es claramente un enfoque Naive ya que pierde su identidad de array.

int a[] = {1, 2, 3, 4};
int *b = a;

Nota: int a[] = b; no funcionará ya que la array solo se puede inicializar usando un objeto agregado

Método 2 : referencia a la array 

• El tamaño debe mencionarse ya que int[x] e int[y] son ​​tipos de datos diferentes desde la perspectiva del compilador.
• La referencia a la array debe inicializarse en el momento de la declaración.
• (&nombre) no es redundante. Tiene su propio significado.

Sintaxis: 

data_type (&name)[size] = array;

Nota: data_type &name[size] es incorrecto porque significa una array de referencia a algún tipo de datos que claramente no tiene sentido. Al hacerlo, tenemos un «nombre» de tipo de datos int (&) [] que, por supuesto, es diferente de int[]

Ejemplo: 

// C++ Program to demonstrate Reference to an Array
 
// Importing input output classes
#include <iostream>
using namespace std;
 
// Main driver method
int main()
{
    // Creating and initializing an integer array
    // Custom input entries
    int a[]{ 1, 2, 3, 4 };
 
    // int (&b)[] = a;
    // Declaring this way wont work as an error will be
    // thrown invalid initialization of reference of type
    // ‘int (&)[]’ from expression of type ‘int [4]’ Here
    // you see compiler referred to "a" as int [4] not int*
 
    int(&b)[4] = a;
 
    // Iterating over elements using foreach loop
    for (int e : b) {
        // Print the elements of the array
        cout << e << " ";
    }
}

1 2 3 4