C++ 之 const references

extraction from The C++ Programming Language 4th. ed., Section 7.7 References, Bjarne Stroustrup

To reflect the lvalue/rvalue and const/non-const distinctions, there are three kinds of references:

• lvalue references: to refer to objects whose value we want to change
• const references: to refer to objects whose value we do not want to change (e.g., a constant)
• rvalue references: to refer to objects whose value we do not need to preserve after we have used it (e.g., a temporary)

Collectively, they are called referencs. The first two are both called lvalue references.

　The obvious implementation of a reference is as a (constant) pointer that is dereferenced each time it is used. It doesn't do much harm to think about references that way, as long as one remembers that a reference isn't an object that can be manipulated the way a pointer is.

　In some cases, the compiler can optimize away a reference so that there is no object representing that reference at run time.

　Intialization of a reference is trivial when the initializer is an lvalue (an object whose address you can take). The initializer for a "plain" T& must be an lvaue of type T.

　The intializer for a const T& need not be an lvaue or even of type T. In such cases:

1. First, implicit type conversion to T is applied if necessary.
2. Then, the resulting value is placed in a temporary variable of type T.
3. Finally, this temporary variable is used as the value of the initializer.

Consider:

　　double &dr=1;　　　　　　//error: lvalue needed

　　const double& cdr{1};　　//OK

The iterpretation of this last initialization might be:

　　double temp = double{1};

　　cosnt double &cdr {temp};

A temporary created to hold a reference initializer persists until the end of its reference's scope.

References to variables and references to constants are distinguished because introducing a temporary for a variable would have been highly error-prone; an assignment to the variable would become an assignment to the -- soon-to-disappear -- temporary. No such problem exists for references to constants, and references to constants are often important as function arguments.