Assigning double to const int& vs int to const int&

Question

I am trying to understand constant reference in C++ and I stumbled across this problem:

When I assign double to a const int& and then change the value of the referencing double, the value of my int reference stays constant.

    double i = 10;
    const int &ref = i;    
    i = 20;

    cout << "i: " << i << endl;      // i = 20
    cout << "&ref: " << ref << endl; // ref = 10

Whereas while assigning int, the value gets changed.

    int i = 10;
    const int &ref = i;    
    i = 20;

    cout << "i: " << i << endl;      // i = 20
    cout << "&ref: " << ref << endl; // ref = 20

What is the reason for this behaviour? My guess is that when assigning double, the implicit conversion to int creates a new object and its reference is then being assigned, however I can't find it written down anywhere.

The = there is not assignment, its initialization/construction. — PlasmaHH, Oct 08 '13 at 20:07
@KubaSpatny sorry, I misread the assignments. Ignore my previous message. — juanchopanza, Oct 08 '13 at 20:19

jrok · Accepted Answer · 2013-10-08T20:44:04.747

10

Even though it looks like, ref isn't a reference to i.

double i = 10;
const int &ref = i;   // ***
i = 20;

A reference to an int cannot refer to a double. Therefore, in the marked line, a conversion from a double to an int takes place and the result of conversion is a temporary rvalue. Normaly, they are destroyed when the full expression they were created in ends. But there's a rule in C++ that allows extending the lifetime of a temporary when it is bound to a reference to const. It is extended until the reference dies. For that, the compiler actually allocates some memory for it behind the scenes.

The assignment modifies the original object i, the unnamed temporary stays intact.

edited Oct 08 '13 at 20:44

answered Oct 08 '13 at 20:14

jrok

54,456
9
109
141

What is the reason for this behaviour? It looks quite dangerous and unpredictable, so I assume there must be something it's useful for. – Kylotan Oct 08 '13 at 20:17
That's the kind of explanation I was looking for :) Thank you! – Kuba Spatny Oct 08 '13 at 20:21
@Kylotan For example, it allows writing `v.push_back( SomeClass(42) );`, where `v` is some container, without having to create a named object of `MyClass` and without needless copies. – jrok Oct 08 '13 at 20:21
@KubaSpatny No problem. I'd paste the normative text from the standard that describes this, but I forgot where exactly it is and it's getting late :) – jrok Oct 08 '13 at 20:24

score 4 · Answer 2 · answered Oct 08 '13 at 20:14

When you convert the double to an int, the result is an rvalue of type int. This temporary value is bound to a constant reference variable, and thus the lifetime of the temporary value is extended to that of the reference variable. Changing the original double has no effect on that.

Nawaz · Answer 3 · 2013-10-08T20:27:38.387

The compiler can help you a lot only if you remove const from both declarations and attempt to compile the code snippets:

double i = 10;
/*const*/ int &ref = i;    //ERROR - WHY?

This code will give compilation error! Why?

But this code:

int i = 10;
/*const*/ int &ref = i;   //NO ERROR

will compile fine.

If the first code compiles fine when there is const, why doesn't it compile now (when const is not there)? What is going on under the hood?

Well, the reason is, actually int& is a reference type which can refer to an object of type int only, not double, so a temporary object of type int is created out of the expressioni (which is double), but the temporary object cannot bind to int& , so it gives compilation error, but as soon as you put const there, it compiles fine, because a temporary object of type int can bind to const int&.

No such thing happens in the second code — no temporary object is created. So when you set i to 20, the ref also changes in the second case (as it refers to i) but in the first case, when you set i to 20, the ref does not change because ref does not refer to i anymore — it rather refers to the temporary object (which you're not changing!). That explains the behaviors of your code snippets.

Hope that helps.

Thanks for pointing that out.. Coming from Java, I find many things that are done differently but it's quite hard to see them all. — Kuba Spatny, Oct 08 '13 at 20:27

score 0 · Answer 4 · answered Oct 08 '13 at 20:28

double i = 10;
const int &ref = i;

Depending on the compiler you are using this code, as is, could as well give a compilation error.

On a compiler where it throws an error, if you cast it to (int &) you would see undefined behavior, since you are reading an int from a double's location. On a compiler which accepts this line, my best guess is it is creating a temporary variable (an rvalue) and assigning to the int reference, and any changes to the original variable are not reflected in the reference.

For the reference to work make sure the source data type can be represented by destination data type.

score -1 · Answer 5 · answered Oct 08 '13 at 20:06

-1

You can think of an int as a class, and int(double); as a way of constructing an int from a double, you have a const reference to that int, which was constructed from a double.

answered Oct 08 '13 at 20:06

Alec Teal

5,770
3
23
50

Assigning double to const int& vs int to const int&

5 Answers5