References References References
int i = 2;
int& ri = i; // reference to iri and i refer to the same object / memory location:
#include <iostream>
int main () {
using std::cout;
int i = 2;
int& ri = i;
cout << i <<'\n'; // 2
cout << ri <<'\n'; // 2
i = 5;
cout << i <<'\n'; // 5
cout << ri <<'\n'; // 5
ri = 88;
cout << i <<'\n'; // 88
cout << ri <<'\n'; // 88
}
- references cannot be "null", i.e., they must always refer to an object
- a reference must always refer to the same memory location
- reference type must agree with the type of the referenced object
int i = 2;
int k = 3;
int& ri = i; // reference to i
ri = k; // assigns value of k to i (target of ri)
int& r2; // COMPILER ERROR: reference must be initialized
double& r3 = i; // COMPILER ERROR: types must agree= Read-Only Access To An Object
int i = 2;
int const& cri = i; // const reference to icriandirefer to the same object / memory location- but
constmeans that value oficannot be changed throughcri
#include <iostream>
int main () {
using std::cout;
int i = 2;
int const& cri = i;
cout << i <<'\n'; // 2
cout << cri <<'\n'; // 2
i = 5;
cout << i <<'\n'; // 5
cout << cri <<'\n'; // 5
cri = 88; // COMPILER ERROR: const!
}
reference type is deduced from right hand side of assignment
#include <iostream>
int main () {
using std::cout;
int i = 2;
double d = 2.023;
double x = i + d;
auto & ri = i; // ri: int &
auto const& crx = x; // crx: double const&
std::cout << ri << '\n';
std::cout << crx << '\n';
}
Usage
References in Range-Based for Loops
In Range-Based for Loops
Range for
#include <iostream>
#include <string>
#include <vector>
int main () {
std::vector<std::string> v;
v.resize(10);
// modify vector elements:
std::cout << "enter " << v.size() << " words (separated by spaces):";
for (std::string & s : v) { std::cin >> s; }
// read-only access to vector elements:
for (std::string const& s : v) { std::cout << s << '\n'; }
std::cout << '\n';
// modify:
std::cout << "enter " << v.size() << " words (separated by spaces):";
for (auto & s : v) { std::cin >> s; }
//read-only access:
for (auto const& s : v) { std::cout << s << '\n'; }
std::cout << '\n';
}
const Reference Parameters
const& Parameters
const Parameters
Read-Only Access ⇒ const&
- avoids expensive copies
- clearly communicates read-only intent to users of function
Example: Function that computes median Example: median
only needs to read values from vector!
pass by value ⇒ copy
int median (vector<int>);
auto v = get_samples("huge.dat");
auto m = median(v);
// runtime & memory overhead!pass by const& ⇒ no copy
int median (vector<int> const&);
auto v = get_samples("huge.dat");
auto m = median(v);
// no copy ⇒ no overhead!Example: Mixed passing Example: Mixed passing (by ref + by value)
incl_first_last ({1,2,4},{6,7,8,9}) → {1,2,4,6,9}
The implementation works on a local copy 'x' of the first vector
and only reads from the second vector via const reference 'y':
auto incl_first_last ( std::vector<int> x, std::vector<int> const& y) {
if (y.empty() return x;
// append to local copy 'x'
x.push_back(y.front());
x.push_back(y.back());
return x;
}non-const Reference Parameters
non-const Ref. Parameters
non-const Parameters
Example: Function that exchanges values of two variables
#include <iostream>
void swap (int& i, int& j) {
int temp = i; // copy value: i → temp// copy i's value to temp
i = j; // copy value: j → i// copy j's value to i
j = temp; // copy value: temp → j// copy temp's (i's original value) to j
}
int main () {
int a = 5;
int b = 3;
swap(a,b);
std::cout << a << '\n' // 3
<< b << '\n'; // 5
}Use std::swap
to exchange values of objects (#include <utility>).
It can be used like the function above, but avoids expensive temporary
copies for move-enabled
objects like std::vector
(it's implementation will be explained in chapter
Move Semantics
).
As useful as non-const references might be in some situations, you should
avoid such output parameters
in general
(see the next panels for more details).
void read_from (int); // fundamental types
void read_from (std::vector<int> const&);
void copy_sink (std::vector<int>);
void write_to (std::vector<int> &);Read from cheaply copyable object (all fundamental types) ⇒ pass by value
double sqrt (double x) { … }Read from object with larger (> 64bit) memory footprint
⇒ pass by const&
void print (std::vector<std::string> const& v) {
for (auto const& s : v) { cout << s << ' '; }
}Copy needed inside function anyway ⇒ pass by value
Pass by value instead of copying explictly inside the function. The reasons for this will be explained in more advanced articles.
auto without_umlauts (std::string s) {
s.replace('ö', "oe"); // modify local copy
…
return s; // return by value!
}Write to function-external object ⇒ pass by non-const&
As useful as they might be in some situations, you should
avoid such output parameters
in general, see
here why.
void swap (int& x, int& y) { … }Functions with non-const ref parameters like
void foo (int, std::vector<int>&, double);can create confusion/ambiguity at the call site:
foo(i, v, j);- Which of the arguments (
i,v,j) is changed and which remains unchanged? - How and when is the referenced object changed and is it changed at all?
- Does the reference parameter only act as output (function only writes to it) or also as input (function also reads from it)?
⇒ in general hard to debug and to reason about!
Example: An interface that creates nothing but confusion
void bad_minimum (int x, int& y) {
if (x < y) y = x;
}
int a = 2;
int b = 3;
bad_minimum(a,b);
// Which variable holds the smaller value again?Lvalues = expressions of which we can get memory address
- refer to objects that persist in memory
- everything that has a name (variables, function parameters, …)
Rvalues = expressions of which we can't get memory address
- literals (
123,"string literal", …) - temporary results of operations
- temporary objects returned from functions
int a = 1; // a and b are both lvalues
int b = 2; // 1 and 2 are both rvalues
a = b;
b = a;
a = a * b; // (a * b) is an rvalue
int c = a * b; // OK
a * b = 3; // COMPILER ERROR: cannot assign to rvalue
std::vector<int> read_samples(int n) { … }
auto v = read_samples(1000);& |
only binds to Lvalues |
const& |
binds to const Lvalues and Rvalues |
bool is_palindrome (std::string const& s) { … }
std::string s = "uhu";
cout << is_palindrome(s) <<", "
<< is_palindrome("otto") <<'\n'; // OK, const&void swap (int& i, int& j) { … }
int i = 0;
swap(i, 5); // COMPILER ERROR: can't bind ref. to literalPitfalls
int& increase (int x, int delta) {
x += delta;
return x;
} // local x destroyed
int main () {
int i = 2;
int j = increase(i,4); // accesses invalid reference!
}Only valid if referenced object outlives the function!
int& increase (int& x, int delta) {
x += delta;
return x; // x references non-local int
} // OK, reference still valid
int main () {
int i = 2;
int j = increase(i,4); // OK, i and j are 6 now
}Careful With Referencing vector Elements!
Careful With vector Elements!
Careful With vector!
References to elements of a std::vector might be
invalidated after any operation that changes the number of
elements in the vector!
vector<int> v {0,1,2,3};
int& i = v[2];
v.resize(20);
i = 5; // UNDEFINED BEHAVIOR: original memory might be gone!- Dangling Reference = Reference that refers to a memory location that is no longer valid.
The internal memory buffer where std::vector stores
its elements can be exchanged for a new one during some vector operations,
so any reference into the old buffer might be dangling.
References can extend the lifetime of temporaries (rvalues)
auto const& r = vector<int>{1,2,3,4};⇒ vector exists as long as reference r exists
What about an object returned from a function?
std::vector<std::string> foo () { … }take it by value (recommended):
vector<string> v1 = foo();
auto v2 = foo();ignore it ⇒ gets destroyed right away
foo();get const reference to it ⇒ lifetime of temporary is extended
… for as long as the reference lives
vector<string> const& v3 = foo();
auto const& v4 = foo();don't take a reference to its members!
No lifetime extension for members of returned objects (here: the vector's content)!
string const& s = foo()[0]; // dangling reference!
cout << s; // UNDEFINED BEHAVIORDon't use lifetime extension through references!
- easy to create confusion
- easy to write bugs
- no real benefit
Just take returned objects by value. This does not involve expensive copies for most functions and types in modern C++, especially in C++17 and above.
Comments…