When is a reference variable appropriate and why? Can you explain the actual syntax and placement?

Question

I am brand new to C++. We have recently begun exploring reference variables in class, and I am very confused about them. Not necessarily how to do them, as I understand that they switch variable values, but more along the lines of WHY a developer would want to do such a thing? What do they accomplish? Do they save memory? Do they avoid having to return information?

Here is part of the project we are working on. We need to include at least one reference variable. I can see how I would write the program without the reference variable, but I don't see where a reference variable would be useful or necessary.

"The user may wish to get an estimate for one to many rooms. The rates are based on the square footage of the walls and/or ceiling. The company estimates that it takes 2.5 hours to paint 200 SF of wall space and 3.2 hours to paint the same area on a ceiling. The labor rate is $40 per hour. If the job for painting WALLS totals more than 1400 SF of space, then the customer receives a 15% discount for all square footage above 1400 square feet. There is no discount for painting ceilings.

The program shall print out a final report of the estimated costs in a professional format.

The program shall ask the user if they want to make more calculations before exiting."

I'm not looking for you guys to do my homework for me, and for reference, we have only just finished with learning functions. I'm pretty good, but there are a LOT of things reading through these sites that I do not understand.

And, essentially, studentID would be set to 21654. Am I understanding this correctly?

Let us try this again:

I have reviewed this suggested duplication. While it does cover the basics of the pros/cons of using reference variables instead of pointers and discusses multitudes of reasons for using both, I am still questioning the basic idea of when (when is is appropriate vs. not necessary) and why (why is appropriate in certain circumstances, what advantages does it give to the program?)

I should use such variables as well as how (the actual syntax and placement). Almost everyone here has been great, and I have learned so much on the subject through my interactions with you. Even as much of this is repetitive and irritating to seasoned coders, it is all new to me, and I needed to be involved in the conversation as much as I needed the information. I have used Stack Overflow for many projects, learning about Java's newString.equalsIgnoreCase(), for instance, and I admire your knowledge. I can only tell you the truth, if that is not good enough then it is what it is.

Alright, let me review my understanding so far:

Reference variables tend to cut down on unwanted modification of variables within a function and/or program.

Reference variables are used to modify existing variables within functions

This is useful as it "moves" values around while minimizing copying of those values.

Reference variables modify existing variables within functions/programs

I don't know if you guys can still read this or not since it has been flagged a duplicate. I've been playing with a few of the mini-programs you guys have given me, re-read portions of my book, done further research, etc., and I think I understand on a rudimentary level. These reference variables allow you to alter and/or use other variables within your code without pulling them directly into your code. I can't remember which user was using the foo(hubble, bubble) example, but it was his/her code that finally made it click. Instead of just using the value, you are actually using and/or reassigning the variable.

Answer 1

A reference variable is nothing but an alias name of the variable. You would use it when you wanted to just pass the value around instead of copying the same variable into memory at a different location. So, using reference, copy can be avoidable which saves the memory.

According to Bjarne Stroustrup's FAQ:

C++ inherited pointers from C, so I couldn't remove them without causing serious compatibility problems. References are useful for several things, but the direct reason I introduced them in C++ was to support operator overloading. For example:

void f1(const complex* x, const complex* y)    // without references
    {
        complex z = *x+*y;    // ugly
        // ...
    }

    void f2(const complex& x, const complex& y)    // with references
    {
        complex z = x+y;    // better
        // ...
    }

More generally, if you want to have both the functionality of pointers and the functionality of references, you need either two different types (as in C++) or two different sets of operations on a single type. For example, with a single type you need both an operation to assign to the object referred to and an operation to assign to the reference/pointer. This can be done using separate operators (as in Simula). For example:

Ref<My_type> r :- new My_type;
r := 7;            // assign to object
r :- new My_type;    // assign to reference

Alternatively, you could rely on type checking (overloading). For example:

Ref<My_type> r = new My_type;
r = 7;            // assign to object
r = new My_type;    // assign to reference

Also, read this Stack Overflow question about the differences between a pointer variable and a reference variable.

Answer 2

I will give three reasons, but there are many more.

1. Avoiding unnecessary copies.

   Suppose you write a function like so:

   double price(std::vector<Room> rooms)
   {
          ...
   }
   

   Now, every time you call it, the vector of Room will be copied. If you only compute the prices of a few rooms that's fine, but if you want to compute the cost of repainting the entirety of the offices of the Empire State Building, you will start to copy huge objects, and this takes time.

   It is better in this case to use a constant reference that provides read-only access to the data:

   double price(const std::vector<Room>& rooms) { ... }
   

2. Using polymorphism

   Suppose you now have different types of rooms, perhaps a CubicRoom and a CylindricalRoom, that both inherit from the same base class, Room.

   It is not possible to write:

   double price(Room room) { ... }
   

   and then call

   price(CylindricalRoom());
   //or
   price(CubicRoom());
   

   but you can if you define price as follows:

   double price(Room& room);
   

   Everything then works the same as if you passed by value.

3. Avoiding returns

   Suppose that each time you compute a price, you want to add a formatted quote to a report. In C++ you can only return a single object from a function, so you can not write:

   return price, fmtQuote
   

   However, you can do:

   double price(Room room, std::vector<std::string>& quotes)
   {
       ...
       quotes.push_back(fmtQuote);
       return price
   }
   

   Obviously, you could return a pair of objects std::pair<double, std::string>, but this means that the caller has to unpack the result. If you intend to call often the above function, this will quickly become ugly. In this case, this ties in to the first point: the log of all quotes will grow, and you do not want to copy it for each call.

   This is a typical access pattern for shared resources: you want a few functions/objects to get a handle on a resource, not a copy of that resource.

Answer 3

You're mixing up two completely separate things here. Three examples to show how the two things work, individually and then together...

1. A function can take a parameter passed by value, and return a value.

   double foo (double y)
   {
       y = y + 200.0;
       return y;
   }
   
   void main(void)
   {
       double hubble = 50.0;
       double bubble = 100.0;
   
       hubble = foo(bubble);
   
       std::cout << "hubble=" << hubble << ", bubble=" << bubble << std::endl;
   }
   

   Note that because this is passed by value, even though foo() changes y, bubble does not change. hubble is set to the value returned by foo().

   Then you get

   hubble=300, bubble=100
   

2. A function can take a parameter passed by reference, and modify that parameter.

   void foo (double& y)
   {
       y = y + 200.0;
   }
   
   void main(void)
   {
       double hubble = 50.0;
       double bubble = 100.0;
   
       foo(bubble);
   
       std::cout << "hubble=" << hubble << ", bubble=" << bubble << std::endl;
   }
   

   Then you get

   hubble=50, bubble=300
   

   Of course hubble hasn't changed. But because bubble was passed by reference, the change to y inside foo() changes bubble, because that change is happening on the actual variable passed and not on a copied value.

   Note that you do not have a "return" statement here. The function does not return anything - it simply modifies the variable which is passed to it.

3. And of course you can use both together.

   double foo (double& y)
   {
       y = y + 200.0;
       return y + 400.0;
   }
   
   void main(void)
   {
       double hubble = 50.0;
       double bubble = 100.0;
   
       hubble = foo(bubble);
   
       std::cout << "hubble=" << hubble << ", bubble=" << bubble << std::endl;
   }
   

   Then you get

   hubble=700, bubble=300
   

   As before, changing y inside foo() changes bubble. But now the function is returning a value as well, which sets hubble.

Why would you choose to return a value, or to modify the value passed in, or to do both? That entirely depends on how you write your code.

I agree with you that you don't have to use a pass-by-reference here. Myself, I'd probably just return a value. But this is a learning exercise, and you've been told to do it that way, so you've got to. Suppose your pass-by-reference is the discount? So a function "void discount(double& value)" takes the value passed and multiplies it by 0.85. It's a bit artificial, but it would demonstrate the principle.

Answer 4

Reference variables are a safer alternative to pointers. Usually, when dealing with pointers you don't really care about the pointer (ptr) so much as what it points to (*ptr); and yet, all the time programmers screw up and manipulate ptr instead of *ptr and so on. Consider this code:

void zeroize_by_pointer(int* p)
{
    p = 0; // this compiles, but doesn't do what you want
}

Compare to the reference version,

void zeroize_by_reference(int& p)
{
    p = 0; // works fine
}

There are many other reasons why references are a good idea, but for someone starting out in C++ I'd suggest focusing on this one: it makes it slightly harder to shoot yourself in the foot. Whenever you deal with pointers you're going to be dealing on some level with the machine's memory model, and that's a good thing to avoid when possible.

Answer 5

References were introduced primarily to support operator overloading. Using pointers for "passing via reference" would give you unacceptable syntax according to Bjarne Stroustrup. They also allow aliasing.

In addition, they allow object-oriented programming with a nicer syntax than using pointer explicitly. If you are using classes you must pass references to avoid object slicing.

In summary, you should always prefer using references over bare pointers.

Answer 6

There is another, more general advantage of references that pointers do not provide. References by their very nature allow you to express through the function signature that the object referred to must exist at the time the function is called No nulls allowed.

The caller cannot reasonably expect a function that takes a reference to check the validity of that reference..

Pointers, on the other hand, may validly be null. If I write a function that accepts a pointer...

void increment(int* val)
{ 
    (*val)++;
}

...and the caller supplies null, my program is probably going to crash. I can write all the documentation I want stating that the pointer must not be null but the fact is it's pretty easy for someone to pass it in accidentally. So if I want to be safe, I must check for it.

But write this function with a reference and the intent is clear. No nulls allowed.

Answer 7

There are also different kinds of references. We have lvalue and rvalue references, designated by & and &&, respectively. Generally, a reference tells us something about the lifetime of the object it references, a pointer does not. Compare

void foo(int* i);
void foo(int& i);
void foo(int&& i);

In the first case, i might point to an object we can assign to, but more importantly, it may also be a nullptr or point to one-past-the-end of an array. Thus, dereferencing it may lead to undefined behaviour. Checking for a nullptr is easy enough, the other check is not.

The the second case and third case, i must always reference an valid int we can assign too.

The difference between rvalue and lvalue references is that rvalue/&& references convey the meaning that the referenced value is not needed by anyone else and as such, allows for optimizations. Read up on std::move and move constructors to see what I mean.

---

To summarize: references tell us something about the object's lifetime. Sure, this could be stated in the documentation, but with pointers, violations of that contract might be hard to catch. References enforce the contract (to a high degree) at compile time and as such provide documentation to the code implicitly. This allows for some quick, uncomplicated optimizations by using e.g. move constructors or perfect forwarding in some cases.

Answer 8

You could almost always use reference variables (instead of ever passing by value): for example ...

// this function creates an estimate
// input parameter is the Rooms to be painted
// passed as a const reference because this function doesn't modify the rooms
// return value is the estimated monetary cost
Money createEstimate(const Rooms& rooms)
{
  ...
}

// this function adds paint to the rooms
// input parameter is the Rooms to be painted
// passed as a non-const reference because this function modifies the rooms
void paintRooms(Rooms& rooms)
{
  ...
}

When you pass-by-value instead of pass-by-reference then you implicitly create and pass a copy of the thing ...

// creates and passes a copy of the Rooms to the createEstimate function
Money createEstimate(Rooms rooms)
{
  ...
}

... which (creating a copy) is (often, slightly) slower than passing by reference (furthermore, creating a copy may have side-effects).

As a possible slight performance optimization, and by convention (because people don't care), it's common to pass-by-value instead of pass-be-reference when the type is small and simple (a.k.a. a "primitive" type), for example:

// passes a copy of the x and y values
// returns the sum
int add(int x, int y)
{
  ...
}

... instead of ...

// passes a reference to x and y
// returns the sum
int add(const int& x, const int& y)
{
  ...
}

See also Passing a modifiable parameter to c++ function as well as Why have pointer parameters?

Answer 9

Reference arguments are more used when you pass an object as argument. That way you don't copy the whole variable; usually they come with a const modifier like:

void printDescription(const Person& person) { ... }

That way you don't copy the object.

Sometime the return type is also set as a reference. That way you are returning the same object (and not a copy of it). Have a look at the << operator of ostream. ostream& operator<< (streambuf* sb );.

With variables you can think about the case where you can swap values.

void swap(int & a, int & b) {
    int aux = a;
    int a = b;
    int b = aux;
}

This case in Java, for example, has to be done in a more complex way.

Answer 10

Reference variables are pointers without a * and practically without pointer arithmetics.

They are not needed from the C++, they are only syntactic sugar around them.

The initial idea of the creators was probably to make C++ code better comprehensible, although they reached its exact opposite.

My opinion is that a C++ program is better if it entirely misses reference variables and it uses only pointers.

Your function in the form

double foo (double studentID* y)
{
  *y = 21654;
  return *y;
}

...would do exactly the same, but it would be actually better comprehensible.