C++ for Scientists - Technische Universität Dresden

74 CHAPTER 3. CLASSES
a real number, the implicit conversion does not create semantic inconsistencies. An implicit
constructor is more convenient because doubles and double literals can be given whereever a
complex is expected. Functions that are not performance-critical can be implemented only once
for complex and used for double. Vice versa, in performance-critical applications it might be
preferable using an explicit constructor because the compiler will refuse to call complex functions
with double arguments. Then the programmer can implement overload of those functions with
double arguments that do not waste run time on null imaginaries.
That does not mean that high-performance implementations necessarily have to be realized with
explicit constructors. The implicit conversion might happen in rarely called functions and the
impact on the overall performance might be negligible. The compiler cannot tell us but a profiling
tool can. A function that consumes less than 1 % of the execution time is not worth to spend
much time on tuning it. All this considered, there are more reasons for an implicit constructor
than for an explicit one and so it is implemented in std::complex.
3.4 Destructors
A destructor is a function that is called every time an object of this class is destroyed, for
example:
∼complex()
{
std::cout ≪ ”So long and thanks for the fish.\n”;
}
Since the destructor is the complementary operation of the default constructor it uses the
complementary notation in the signature. Opposed to the constructor there is only one single
overload and arguments are not allowed — what could they are good for anyway, as grave
goods? There is no live after death in C ++.
In our example, there is nothing to do when a complex number is destroyed and we can omit
the destructor. A destructor is needed when the object acquired resources, e.g. memory. In
this cases the memory must be freed in the destructor and the other ressource be released.
class vector
{
public:
// ...
∼vector()
{
if (data) // check if pointer was allocated
delete[] data;
}
// ...
private:
unsigned my size;
double ∗data;
};
Files that are opened with std::ifstream or std::ofstream does not need to closed explicitly, their
destructors will do this if necessary. Files that are opened with old C handles require explicit
closing and this is only one reason for not using them.