C++ for Scientists - Technische Universität Dresden

42 CHAPTER 2. C++ BASICS
To make sure that our vector is not changed (and not copied either), we pass it as constant
reference:
double two norm(const vector& v) { ... }
If we would change v in this function the compiler would emit an error. Both call-by-value and
constant references ascertain that the argument is not altered but by different means:
• Arguments that are passed by value can be changed in the function since the function
works with a copy. 17
• With const references one works on the passed argument directly but all operations that
might change the argument are forbidden. In particular, const-referred arguments cannot
appear on the left side of an assignment or passed as non-const references to other functions
(in fact the LHS of an assignment is also a non-const reference).
In contrast to mutable references, constant ones allow for passing temporaries:
alpha= two norm(v + w);
This is admittedly not entirely consequent on the language design side, but it makes the life of
programmers much easier.
Values that are quite frequent as argument might be declared as default. Say we implement a
function the computes the n nt root and mostly the square root then we can write:
double root(double x, int degree= 2) { ... }
This function can be called with one or two arguments:
x= root(3.5, 3);
y= root(7.0);
One can declare multiple default arguments but only at the end. In other words, after an
argument with a default value one cannot have one without.
2.6.3 Returning Results
In the examples before, we only returned double or int. These are the nice ones. Functions that
compute new values of large data structures are more difficult.
Default arguments
Sometimes functions have arguments that are used very infrequently. To address this, you can
give a parameter a default value that is automatically used when no argument corresponding
to that parameter is specified. In this way the caller only needs to specify those arguments that
are meaningful at a particular instance. Consider the following example:
void foo( int a = 5, char ch =’A’ )
{ std::cout ≪ a ≪ ” ” ≪ ch ≪ std::endl ;}
17 This assumes that the argument is properly copied. For user-defined types one can implement its own copy
operation with aliasing effect (on purpose or by accident). Then modifications of the copy also affect the original
object.