C++ for Scientists - Technische Universität Dresden

58 CHAPTER 2. C++ BASICS
Now that the function is complete, we first run our test. Evidently, we have to uncomment
part of the test because we only implemented one function so far. But it is worth to know if
this first function already behaves as expected. It does and we could be now happy with it and
turn our attention to the next task, there are still many. But we will not.
Well, at least we can be happy to have a correctly running function. Nevertheless, it is still
worth spending some time to improve it. Such improvements are called refactoring. Experience
from practise has shown that refactoring immediately after implementation is takes much less
time than later modification when bugs are discovered, the software is ported to other platforms
or extended for more usability. Obviously, it is much easier now to simplify and structure our
software immediately when we still know what is going on than in some week/months/years or
when somebody else is refactoring it.
First thing we might dislike is that something so simple as the initialization of a unit vector
takes 5 lines. This is rather verbose. Putting the if statement in one line
is badly structured.
for (unsigned i= 0; i < n; ++i)
if (i == k) e k[i]= 1.0; else e k[i]= 0.0;
C ++ and even good ole C have a special operator for conditions
for (unsigned i= 0; i < n; ++i)
e k[i]= i == k ? 1.0 : 0.0;
The conditional operator ‘?:’ usually needs some time to get used to but it results in a more
concise representation. There are also situations where one cannot use an if but the ?: operator.
Although, we have not changed anything semantically in the program and it seems obvious that
the result will still be the same, it cannot harm to run our test again. You will see, how often
you are sure that your program changes could never possibly change the behavior but still do.
And the sooner you realize the better. And with the test we already wrote it only takes a few
seconds and makes you feel more confident.
If we would like to be really cool we could explore some insider know how. The expression
‘i == k’ returns a boolean and we know that bool can be converted implicitely into int. In this
conversation false results in 0 and true returns 1 according to the standard. This are precisely
the values we want as double:
e k[i]= double(i == k);
In fact, the conversion from int to double is performed implicitly and can be omitted:
e k[i]= i == k;
As cute as this looks, it is some stretch to assign a logical value to a floating point number. It is
well-defined by the implicit conversion chain bool → int → double but it will confuse potential
readers and you might end up explaining them what is happening on a mailing list or you add
a comment to the program. In both cases you end up writing more for the explication than you
saved in the program.
Another thought that might occur to us is that it is probably not the last time we need a unit
vector. So, why don’t writing a function for it?