Tipo valor y referencia

Las variables de tipo valor son aquellas en la que los los datos se almacenan directamente en la variable.

Es decir, tu variable tiene un “huequito” para meter su valor.

En general, los tipo valor se limitan a los tipos más sencillos (primitivos) de cada lenguaje. En particular, normalmente son únicamente:

• Números enteros, y de coma flotante
• Caracteres (no strings)
• Booleanos
• Agrupaciones de variables sencillas

Esto significa que cuando asignamos una variable a otra, se realiza una copia independiente de los datos.

Las variables de tipo referencia son aquellos en los que las variables contienen referencias a los datos en lugar de los datos en sí mismos.

Es decir, tu variable contiene un enlace a unos datos, que están “en otro lado”.

Los tipos de referencia incluyen:

• Colecciones (arrays, listas, diccionarios…)
• Objetos
• Estructuras de datos complejas

Es decir, básicamente todo son REFERENCIAS. Excepto los números, los caracteres… y poquito más.

Empecemos por un tipo valor. Por ejemplo, un número entero

int A = 10;  // creamos una variable A, y le ponemos valor 10
int B = A;   // creamos una variable B, y le ponemos valor A

int B = 20;  // cambiamos B. ¿Ha cambiado A?

¿Cuánto vale A al final del proceso? En este caso, A vale 10 y B vale 20.

Con tipo valor: Modificar B -> NO ❌ ha modificado a A

Esto es así por porque A y B son tipo valor, son independientes. Cada uno tiene su propio valor.

Al copiar el valor de A en B, hemos copiado su valor, pero siguen siendo variables separadas. Cualquier cambio posterior no afecta a la otra, porque no hay un vínculo entre ellas.

Ahora vamos a hacer lo mismo con un tipo referencia. Por ejemplo, vamos a coger un array (solo vamos a trabajar con la posición 0 del array, suficiente para mostrar lo que queremos ver).

Así que hacemos el mismo experimento:

int[] A = {10, 0, 0};  // creamos una variable A
int[] B = A;           // creamos una variable B, y le ponemos valor A

B[0] = 20;             // cambiamos B. ¿Ha cambiado A?

¿Cuánto vale A[0]? En en este caso, A[0] vale 20.

Con tipo referencia: Modificar B -> SI ✔️ ha modificado a A

Esto ha pasado porque estamos trabajando con tipo referencia. Al crear la variable A, esta era una referencia a un array. Al crear la nueva variable B, hemos igualado a A. Por lo cuál, teníamos dos referencias, que apuntaban al mismo Array.

Por tanto, si modificamos cualquier cosa en B, estamos modificándola en A. Porque las dos variables apuntan a los mismos datos.

Si quisiéramos volver a hacerlas independientes, tendríamos que asignar a B un Array diferente.

int[] A = {10, 0, 0};   // creamos una variable A
int[] B = A;            // A y B apuntan a los mismos datos


int[] B = {10, 0, 0};   // ahora B apunta a otro Array
B[0] = 20;              // si cambiamos B, ya no afecta a A

La trabajar con variables de tipo valor, en estas casillas de memoria va a meter el valor de tu variable. En nuestro ejemplo, 10. Pero son dos casillas independientes. Si en una pongo 20, la otra no se ve afectada.

Cuando tienes variables de tipo referencia, igualmente tienes dos casillas para tus variables. Pero, en vez de tener el valor, esta vez tienen la dirección de memoria donde están los datos “de verdad”.

En nuestro ejemplo, digamos que tenemos un ARRAY. El ordenador ha creado este array en la posición 0x30. Nuestras variables A y B, tienen esta posición como valor.

Así que, tanto A como B están modificando los mismos datos, que realmente están en la posición de memoria 0x30.