Difference between passing *mycar and &mycar

I came across this in my book. Both of them look quite similar.

void fixFlatTire(Car *myCar);
void fixFlatTire(Car &myCar);

The first one pass myCar to function fixFlatTire via a pointer.
The second one pass myCar to function fixFlatTire via L-value of myCar. So, what's the different? Am I right, in explaining this way?

You would call the functions differently.

Code:

---

// in order of appearance:
fixFlatTire(&myCar);
fixFlatTire(myCar);

---

What happens in these functions also looks different. The pointer version has this inside:

Code:

---

void fixFlatTire(Car *myCar)
{
  if (myCar != NULL) {
      myCar->removeLugnuts();
      myCar->exchangeTire(new Tire);
      myCar->screwonLugnuts();
  }
  else {
      panic();
  }
}

---

The reference version...

Code:

---

void fixFlatTire(Car &myCar)
{
  myCar.removeLugnuts();
  mycar.exchangeTire(new Tire);
  myCar.screwonLugnuts();
}

---

Maybe something like that? It's complicated...

So that is the difference. Syntactically no big deal, but with the pointer version, you have to make sure that the pointer points to an object, and handle times when it doesn't. References are always an object with a different name, so there is nothing to really check, (unless you are too clever it won't break,) but references can't be reassigned a new object like pointers can. So pick whatever you need the variable to do.

The difference within the function is syntax used to manipulate myCar. Within your first version, it is necessary to either dereference the pointer (to obtain a reference from the pointer) or use the -> operator to manipulate members or call member functions of myCar (it is also possible, as some amateurs do, to do (*myCar).operation in place of myCar->operation). Within your second version, it is necessary to use the . (dot) operator to manipulate members of myCar, or use the & operator to obtain a pointer from the reference.

One important difference is that the second version (which accepts a reference) is allowed to assume myCar is a valid object (the caller has to avoid passing an invalid reference, or it is deemed to be invoking undefined behaviour). The pointer version can receive a NULL pointer, so that needs to be checked for.

For the caller, the difference is in what can be passed. Given a reference to Car (or a variable of type Car) it is necessary to use the & operator to call the first version. Given a pointer to Car, it is necessary to dereference that pointer to call the second version.

One other important difference is that the function can be called with an array of cars, and it is possible for the function to loop over those cars using array syntax. The second version cannot.

thanks guys for the great explanation. Actually there's no big deal