En el puntero y la referencia de C++, ambos se utilizan para acceder al objeto de forma indirecta. Por lo tanto, es importante saber cuándo usar el puntero y cuándo usar la referencia. Este artículo explica la diferencia entre puntero y referencia (punteros frente a referencias) en C++. Aquí, discutiré algunas diferencias importantes entre la referencia y el puntero que lo ayudarán a tomar la decisión de cuándo usar la referencia y cuándo usar el puntero. Además, usaré algunos fragmentos de código que lo ayudarán a comprender por qué las referencias y los punteros son diferentes entre sí.
También puede ver el artículo mencionado a continuación,
- Referencias en C++, debe saber.
- Referencia y const en C++.
- Breve introducción del puntero.
- Diferencia entre referencia constante y referencia en un parámetro.
Punteros vs Referencias en C++:
Si dejamos algunos puntos, entonces las referencias son similares a los punteros. A continuación he seleccionado algunos puntos que son puntero y referencia diferenciados en C++ (Punteros vs Referencias):
1. Declaración e inicialización:
La estructura sintáctica de la declaración de referencia es similar a la declaración de puntero. La diferencia es que mientras una declaración de puntero usa el * operador, una declaración de referencia utiliza el & operador. Significa el nombre del puntero seguido del * (asterisco) pero el nombre de referencia seguido de & (Dirección del operador).
Ejemplo,
//create an variable
int data = 6;
//rData (reference) refer to data
int& rData = data;
//pData (pointer) refer to data
int *pData = &data;
OR
int *pData;
pData = &data;
2. Inicialización con un puntero NULL:
Un puntero puede apuntar al puntero nulo, pero una referencia no puede referirse a NULL.
//reference refer to null int& rData = NULL; //error //pointer point to null int *pData = NULL; // ok
3. Reenlazado:
Debe recordar que una vez que una referencia se vincula con cualquier objeto, no se volverá a vincular con otro objeto. Pero no es cierto para los punteros, podemos inicializar los punteros varias veces según el requisito y no es necesario inicializar los punteros en el momento de la creación.
/****reference****/ int& rData; //error int& rData = a; //ok, rData (reference) refer to 'a' rData = b; //error /****Pointer****/ int *pData; // ok int *pData = &a; // ok, pData point to 'a' pData = &b; // ok, pData point to 'b'
4. Forma de acceder al valor:
Una referencia puede considerarse como el nombre de un objeto. Por lo tanto, no necesitamos ningún operador adicional al acceder al valor. Pero con los punteros, necesitamos el operador de direccionamiento indirecto al acceder al valor. Veamos un código de ejemplo para una mejor comprensión,
#include <iostream>
using namespace std;
int main()
{
//create an variable
int data = 6;
//pointer point to data
int *pData = &data;
//rOffData refer to data
int& rData = data;
cout << "Value of data, rData and pData" << endl;
cout << "data = " << data << endl;
//accessing value by reference
cout << "rData = " << rData << endl;
//accessing value by pointer
cout << "*pData = " << *pData << endl;
return 0;
}
Salida:
Value of data, rData and pData data1 = 6 rData = 6 *pData = 6
Si desea aprender un lenguaje de programación en línea, puede consultar los cursos, hay una prueba gratuita disponible.
Haga clic para obtener su prueba gratuita
5. Transmisión dinámica fallida:
Una transmisión dinámica fallida no tiene el mismo efecto en un puntero y una referencia:
2. Una transmisión dinámica fallida en una referencia genera una excepción de tipo std::bad_cast. Esto tiene sentido porque no puede devolver una referencia nula.
6. Almacenamiento:
no se especifica si una referencia requiere almacenamiento o no. Pero aun así, he visto algunos ejemplos en los que una referencia comparte la misma dirección de memoria con la variable original, pero también ocupa algo de espacio en la pila. Veamos un código de ejemplo,
void fun(int& rChangeData)
{
rChangeData = 10;
}
int main()
{
int data = 5;
int& rData = data;
fun(rData);
return 0;
}
En el código anterior, rData no debería ocupar espacio en la pila principal, pero la función de referencia rChangeData ocupará un lugar en su pila. Significa que al llamar a la función "divertida" con rData como argumento, la dirección de los datos se insertará en la pila de funciones.
7. Seguridad:
Las referencias son bastante más seguras que los punteros; es la razón por la que la gente de C++ insiste en usar la referencia en la programación de C++. Pero depende de ti y de tus requisitos.
Los punteros son más eficaces que las referencias porque permiten volver a vincular y anular. También si has visto “Spider-Man Movie” , entonces sabe que "un gran poder conlleva grandes responsabilidades", por lo que siempre debe preocuparse de que un puntero no sea nulo y no cambie su objetivo señalado.
Pero tampoco es 100% cierto que una referencia siempre sea segura, también debe tener cuidado antes de usar una referencia.
Veamos un ejemplo, donde la referencia no es válida y puede causar un comportamiento indefinido y lo malo es que sería difícil rastrear este tipo de problema.
int* pData; int& rData = *pData;
Algunas otras diferencias entre referencias y punteros:
Publicación recomendada
- Cursos y tutoriales de programación en C.
- Cursos y Tutoriales de Programación CPP.
- Cursos y tutoriales de Python.
- Introducción de referencia en C++.
- Todo sobre el nuevo operador.
- C++ MCQ para usted.
- Preguntas de la entrevista de C++ con respuestas.
- constructores en c++.
- El mejor mouse para el programador.
- Increíble lista de regalos para programadores, debes hacerlo.
- Los mejores kits electrónicos para programadores.
- 100 C Preguntas de la entrevista.
- Preguntas de la entrevista de C# con respuestas.