C++ for Scientists - Technische Universität Dresden

2.6. FUNCTIONS 41
It should be mentioned here that the inline keyword is not mandatory. The compiler can decide
against inlining for the reasons given in the previous paragraph. On the other hand, the compiler
is free to inline functions without the inline keyword.
For obvious reasons, the definition of an inline function must be visible in every compile unit
where it is called. In contrast to other functions, it cannot be compiled separately. Conversely,
a non-inline function cannot be visible in multiple compile units because it collides when the
compiled parts are ‘linked’ together. Thus, there are two ways to avoid such collisions: assuring
that the function definition is only present in one compile unit or declaring the function as
inline.
2.6.2 Function Arguments
If we pass an argument to a function it creates by default a copy. For instance, the following
would not work (as expected):
void increment(int x)
{
x++;
}
int main()
{
int i= 4;
increment(i);
cout ≪ ”i is ” ≪ i ≪ ’\n’;
}
The output would be 4. The operation x++ in the second line only increments a local copy but
not the original value. This kind of argument transfer is called ‘call-by-value’ or ‘pass-by-value’.
To modify the value itself we have to ‘pass-by-reference’ the variable:
void increment(int& x)
{
x++;
}
Now the variable itself is increment and the output will be 5 as expected. We will discuss
references more detailed in § 2.10.2.
Temporary variables — like the result of an operation — cannot be passed by reference:
increment(i + 9); // error
We could not compute (i + 9)++ anyway. In order to call such a function with some temporary
value one needs to store it first in a variable and pass this variable to the function.
Larger data structures like vectors and matrices are almost always passed by reference for
avoiding expensive copy operations:
double two norm(vector& v) { ... }
An operation like a norm should not change its argument. But passing the vector by reference
bears the risk of accidentally overwriting it.