C++ for Scientists - Technische Universität Dresden

2.2. VARIABLES 21
2.2.1 Constants
Syntactically, constants are like special variables in C ++ with the additional attribute of immutability.
const int integer1 = 2;
const int integer3; // Error
const float pi = 3.14159;
const char mycharacter = ’a’;
const bool cmp = integer1 < pi;
As they cannot be changed, it is mandatory to set the value in the definition. The second
constant definition violates this rule and the compiler will complain about it.
Constants can be used where ever variables are allowed — as long as they are not modified, of
course. On the other hand, constants like those above are already known during compilation.
This enables many kinds of optimizations and the constants can be even used as arguments of
types (we will come back to this later).
2.2.2 Literals
Literals like “2” or “3.14” have types as well. Simply spoken, integral numbers are treated as
int, long or unsigned long depending on the number of digits. Every number with a dot or an
exponent (e.g. 3e12 ≡ 3 · 10 12 ) is considered a double.
Usually this does not matter much in practice since C ++ has implicit conversation between
built-in numeric types and most programs work well without explicitly specifying the type of
the literals. There are however three major reasons why paying attention to the types of literals:
• Availability;
• Ambiguity and
• Accuracy.
Without going into detail here, the implicit conversation is not used with template functions
(for good reasons). The standard library provides a type for complex numbers where the type
for the real and imaginary part can be parametrized by the user:
std::complex z(1.3, 2.4), z2;
These complex numbers provide of course the common operations. However, when we write:
z2= 2 ∗ z; // error
z2= 2.0 ∗ z; // error
we will get an error message that the multiplication is not available. More specifically, the
compiler will tell us that there is no operator∗() for int and std::complex respectively for
double and std::complex. 2 The library provides a multiplication for the type that we use
for the real and imaginary part, here float. There are two ways to ascertain that “2” is float:
z2= float(2) ∗ z;
z2= 2.0f ∗ z;
2 It is however possible to implement std::complex in a fashion such that these expressions work [Got11].