1

For example: 

void do_something(int& x){ //this function asks for a reference to an int, //since the type of its argument is int& } int main() { int x = 4; //the variable x is simply an int; it isn't a reference? int& y = x; //the variable y is a reference to x do_something(y); //this works, as expected do_something(x); //this calls the method with an int, instead of a reference. //Why does this work? It's not giving the function what the function is //asking for. }

Why does do_something(x) work? It's not giving the function what the function is asking for. The only explanation I can come up with is that the int being passed to the function has a reference created for it, and that reference is what ends up being passed to the function.

Improve this question
14
  • 1
    in a wider sense x references itself Commented May 23, 2019 at 15:40
  • 1
    @PierreEmmanuelLallemant An important difference between pointers and references is that references cannot be uninitialized, but pointers can be nullptr to signify "points to nothing". Commented May 23, 2019 at 15:43
  • 2
    Looks like you can benefit from a good C++ book, you can find curated list here: stackoverflow.com/questions/388242/… Commented May 23, 2019 at 15:44
  • 2
    @PierreEmmanuelLallemant, no reference is NOT an implicit pointer, it it's best NOT to understand it this way. Commented May 23, 2019 at 15:45
  • 2
    @JesperJuhl references are just not pointers. Comparing reference to a pointer might be justified when someone is coming from the language which doesn't have references (but has pointers, like C), but if C++ is learned from the ground up, there is simply no reason to invoke pointers when talking about references. Commented May 23, 2019 at 15:46

4 Answers 4

Reset to default
7

One way to look at a reference is to think of it as an alias. It's just a new name for an existing object, and you can use the existing name or the new one you gave it. That means

void do_something(int& x)

doesn't really need a reference passed to it. What it is saying is that x will be a reference to some int object. Looking at it that way it makes perfect sense that you can pass an int to do_something because you are giving it the int that x will refer to.

This also works the other way around. If you instead had

void do_something(int x)

you could still pass y to it since y is just the name for an int.

Improve this answer
Sign up to request clarification or add additional context in comments.

6 Comments

One way to look at a reference is to think of it as an alias. I dare say, it is the best way to look at reference, and potentially the only correct one.
@SergeyA Pretty Much. It gets a little tricky with classes since reference members normally take up space so there is more to just being an alias, but those are implementation details that don't need to to be taught at the start. The "it's just an alias" way works until they have a good foundation and are ready to start diving into the deep end.
Thank you for the response, that makes sense! So if void do_something(int x) is identical to void do_something(int& x), what is the point of including the &? In the book I'm reading (Tour of C++ 2nd edition) the author seems to always use the latter version instead of the former, so I'm guessing there's a reason
@JamesRonald They are not identical. With void do_something(int& x) any change you make to x in the function will be reflected in the variable you passed to the function. With void do_something(int x) any changes made to x in the function will not show up in the variable you passed to the function.
@JamesRonald When learning C++, do yourself a favor and pretend that Java doesn't exists. They are pretty different languages and have a lot of things that are different, even if they syntactically look the same.
|
5

If a reference could only be bound to other references, then there would be no way of referring to an object.

do_something(x) works just the same as int& y = x does. In both cases a reference variable is bound to an object. In case of the function call, the reference variable is a parameter.

The only explanation I can come up with is that the int being passed to the function has a reference created for it

All function parameters - and more generally all variables (function parameters are essentially local variables) - are "created" (although it depends on what is meant by "creation"). If the variable is a reference, then a reference is created. If the variable is not a reference, then an object is created.

Improve this answer

2 Comments

Thank you for the response! So I understand now that references should just be thought of as aliases for the object they refer to. With that in mind, is there any meaningful difference between a reference being created and a object being created (described in your last sentence)?
@JamesRonald No difference in general. They're just different types.
2

You can imagine the function

void do_something(int& parn){ //... }

and its call

int x = 4; //the variable x is simply an int; it isn't a reference? do_something(x);

the following way

int x = 4; //the variable x is simply an int; it isn't a reference? do_something(x); // ... void do_something( /* int& parn */ ){ int &parm = x; //... }

That is the function parameter (that is a local variable of the function) that has a referenced type is initialized by the argument. Now the parameter parm references the variable x. It can be considered as an alias for the variable x within the function.

The only difference between this reference declaration inside the function

void do_something( /* int& parn */ ){ int &parm = x; //... }

and this declaration in main

int& y = x;

is that the variable parm (the function parameter) has block scope of the function.

Improve this answer

Comments

0

"Why can a function which takes a reference be given just an object (and not a reference)? Is a reference automatically made?"

Yes. A reference to the object you pass is formed when you call the function.

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.