¿Cuál es la diferencia?
Estoy aprendiendo C++ y estoy haciendo un pequeño juego en el que tuve que pasar un objeto como parámetro por referencia, y al principio hice algo así:
void function(OBJECT* obj) {
std::cout << obj->x;
}
luego:
OBJECT obj(2);
function(&obj); //2
El parámetro es un puntero y llamo a la función con el parámetro por referencia. Eso es lo que pensé.
Pero en Internet he visto que se llama a la función sin referencia, y en la definición:
function(OBJECT &obj) {
std::cout << obj.x;
}
Entonces, ¿cuál es la diferencia entre esto:
class Road {
public:
int limit_r, limit_l;
Road(int _limit_r, int _limit_l) : limit_r(_limit_r), limit_l(_limit_l) {}
};
class Car {
int x;
public:
Car(int _x) : x(_x) { };
void move(Road &r);
};
void Car::move(Road &r) {
while (this->x >= r.limit_r) {
this->x++;
}
}
int main() {
Road road(0, 20);
Car car(road.limit_r);
car.move(road);
return 0;
}
Y esto:
...
class Car {
...
public:
...
void move(Road* r); //Cambiado
};
void Car::move(Road* r) { //Cambiado
while (this->x >= r->limit_r) { //Cambiado
this->x++;
}
}
int main() {
Road road(0, 20);
Car car(road.limit_r);
car.move(&road); //Cambiado
return 0;
}
¿Hay alguna diferencia? ¿Cuál es mejor o más correcto?
¿Por qué cambia la forma de llamar a una propiedad o método? (road->limit_r y road.limit_r)
Gracias.
davy.ai
La diferencia entre los dos fragmentos de código está en el mecanismo de paso de parámetros. En el primer fragmento de código, la función
functiontoma un puntero a un objeto de tipoOBJECTcomo parámetro, y en el segundo fragmento de código, el métodomovede la claseCartoma una referencia a un objeto de tipoRoadcomo parámetro.Ambos enfoques son válidos, pero usar una referencia como parámetro generalmente se considera una mejor práctica en C++. Esto se debe a que las referencias son menos propensas a errores que los punteros: las referencias no pueden ser nulas y no se pueden reasignar para apuntar a un objeto diferente una vez que se han inicializado. Pasar por referencia también resulta en un código más limpio y legible.
En el primer fragmento de código, la propiedad
xdel objeto apuntado porobjse accede utilizando el operador de flecha (->) debido a queobjes un puntero. En el segundo fragmento de código,xse accede utilizando el operador de punto (.) porqueobjes una referencia.En el segundo fragmento de código, el método
movetoma un puntero a un objetoRoadcomo parámetro, y la propiedadxdel objetoRoadse accede utilizando el operador de flecha porqueres un puntero. Esta sintaxis se utiliza porqueres un puntero, y el operador de flecha se utiliza para acceder a propiedades o métodos de objetos a los que apuntan los punteros.