78

Why do constant references not behave the same way as constant pointers, so that I can actually change the object they are pointing to? They really seem like another plain variable declaration. Why would I ever use them?

This is a short example that I run which compiles and runs with no errors:

int main (){
    int i=0;
    int y=1;    
    int&const icr=i;
    icr=y;          // Can change the object it is pointing to so it's not like a const pointer...
    icr=99;         // Can assign another value but the value is not assigned to y...
    int x=9;
    icr=x;
    cout<<"icr: "<<icr<<", y:"<<y<<endl; 
}
nbro
  • 15,395
  • 32
  • 113
  • 196
Bat0u89
  • 610
  • 2
  • 17
  • 25

7 Answers7

107

The clearest answer. Does “X& const x” make any sense?

No, it is nonsense

To find out what the above declaration means, read it right-to-left: “x is a const reference to a X”. But that is redundant — references are always const, in the sense that you can never reseat a reference to make it refer to a different object. Never. With or without the const.

In other words, “X& const x” is functionally equivalent to “X& x”. Since you’re gaining nothing by adding the const after the &, you shouldn’t add it: it will confuse people — the const will make some people think that the X is const, as if you had said “const X& x”.

Community
  • 1
  • 1
Bat0u89
  • 610
  • 2
  • 17
  • 25
54

The statement icr=y; does not make the reference refer to y; it assigns the value of y to the variable that icr refers to, i.

References are inherently const, that is you can't change what they refer to. There are 'const references' which are really 'references to const', that is you can't change the value of the object they refer to. They are declared const int& or int const& rather than int& const though.

Hu Xinqiao
  • 21
  • 5
mattnewport
  • 13,728
  • 2
  • 35
  • 39
  • So a reference to a const can also be seen as a constant reference to a const? That makes a lot of sense now. – Dasaru Sep 27 '12 at 23:07
  • 2
    @Dasaru: Yes, it can, but a reference to non-const can also be seen as a constant reference to non-const, as the reference itself is always const, independently from if it references a const or not. – Kaiserludi Jan 12 '15 at 13:04
30

What is a constant reference (not a reference to a constant)
A Constant Reference is actually a Reference to a Constant.

A constant reference/ Reference to a constant is denoted by: 

int const &i = j; //or Alternatively
const int &i = j;
i = 1;            //Compilation Error

It basically means, you cannot modify the value of type object to which the Reference Refers.
For Example:
Trying to modify value(assign 1) of variable j through const reference, i will results in error:

assignment of read-only reference ‘i’

icr=y;          // Can change the object it is pointing to so it's not like a const pointer...
icr=99;

Doesn't change the reference, it assigns the value of the type to which the reference refers. References cannot be made to refer any other variable than the one they are bound to at Initialization.

First statement assigns the value y to i
Second statement assigns the value 99 to i

Foggzie
  • 9,691
  • 1
  • 31
  • 48
Alok Save
  • 202,538
  • 53
  • 430
  • 533
  • How & why statement like const int& a=3; valid? – Destructor Jul 17 '15 at 17:40
  • 6
    Wait, `const Type&` is equivalent to `Type const&`? – Tyler Sep 20 '15 at 01:42
  • While instructive with regard to the interaction between `const` and `&`, this answer does not quite address the question. `int const &` is not the same as `int & const` as present in the question. The latter is not even well-formed and won't compile (it would mean the non-sensical "constant reference" as described in the accepted answer). This answer is talking about a "reference to a constant", which is something else and well-formed. – user118967 Oct 26 '22 at 01:55
  • @Tyler: yes. Same for `const Type*` and `Type const*`. The latter is not as common but considered by some people to be better since you can understand it by simply reading it right-to-left: "a pointer to a constant of type Type". – user118967 Oct 26 '22 at 01:57
6

This code is ill-formed:

int&const icr=i;

Reference: C++17 [dcl.ref]/1:

Cv-qualified references are ill-formed except when the cv-qualifiers are introduced through the use of a typedef-name or decltype-specifier, in which case the cv-qualifiers are ignored.

This rule has been present in all standardized versions of C++. Because the code is ill-formed:

  • you should not use it, and
  • there is no associated behaviour.

The compiler should reject the program; and if it doesn't, the executable's behaviour is completely undefined.

NB: Not sure how none of the other answers mentioned this yet... nobody's got access to a compiler?

M.M
  • 138,810
  • 21
  • 208
  • 365
  • Damn! Burn! But you're right - even I was wondering the same. When I wrote cv-qualified reference, compiled complained that 'error: ‘const’ qualifiers cannot be applied to ‘int&’' which makes complete sense. But I wonder since OP has compiled this code before so many years, may be in traditional standards (C98, C++03) it was allowed and ignored? – ZoomIn May 05 '23 at 12:35
  • @ZoomIn there have been various compilers over the years that allow non-standard code – M.M May 06 '23 at 08:53
4

By "constant reference" I am guessing you really mean "reference to constant data". Pointers on the other hand, can be a constant pointer (the pointer itself is constant, not the data it points to), a pointer to constant data, or both.

Poodlehat
  • 360
  • 1
  • 2
  • 9
3

As it mentioned in another answers, a reference is inherently const.

int &ref = obj;

Once you initialized a reference with an object, you can't unbound this reference with its object it refers to. A reference works just like an alias.

When you declare a const reference, it is nothing but a reference which refers to a const object.

const int &ref = obj;

The declarative sentences above like const and int is determining the available features of the object which will be referenced by the reference. To be more clear, I want to show you the pointer equivalent of a const reference;

const int *const ptr = &obj;

So the above line of code is equivalent to a const reference in its working way. Additionally, there is a one last point which I want to mention;

A reference must be initialized only with an object

So when you do this, you are going to get an error;

int  &r = 0; // Error: a nonconst reference cannot be initialized to a literal

This rule has one exception. If the reference is declared as const, then you can initialize it with literals as well;

const int  &r = 0; // a valid approach
Ozan Yurtsever
  • 1,274
  • 8
  • 32
0

First I think int&const icr=i; is just int& icr = i, Modifier 'const' makes no sense(It just means you cannot make the reference refer to other variable).

const int x = 10;
// int& const y = x; // Compiler error here

Second, constant reference just means you cannot change the value of variable through reference.

const int x = 10;
const int& y = x;
//y = 20; // Compiler error here

Third, Constant references can bind right-value. Compiler will create a temp variable to bind the reference.

float x = 10;
const int& y = x;
const int& z = y + 10;
cout << (long long)&x << endl; //print 348791766212
cout << (long long)&y << endl; //print 348791766276
cout << (long long)&z << endl; //print 348791766340
Novice
  • 11