C++ for Scientists - Technische Universität Dresden

70 CHAPTER 3. CLASSES
class solver
{
public:
solver(int nrows, int ncols) : A(nrows, ncols) {}
// ...
private:
matrix type A;
};
Often the matrix (or whatever other object) is already constructed and we do not like to waste
the memory for a copy. In this case we will use a reference to the object. A reference must
be set in the constructor because this is the only place to declare what it is referring to. The
solver shall not modify the matrix, so we write:
class solver
{
public:
solver(const matrix type& A) : A(A) {}
// ...
private:
const matrix type& A;
};
The code also shows that we can give the constructor arguments the same names as the member
variables. After the colon, which A is which? The rule is that names outside the parenthesis
refer to members and inside the parenthesis the constructor arguments are hiding the member
variables. Some people are confused by this rule and use different names. To what refers A
inside {}? To the constructor argument. Only names that does not exist as argument names
are interpreted as member variables. In fact, this is a pure scope resolution: the scope of the
function — in this case the constructor — is inside the scope of the class and thus the argument
names hide the class member names.
Let us return to our complex example. So far, we have a constructor allowing us to set the real
and the imaginary part. Often only the real part is set and the imaginary is defaulted to 0.
class complex
{
public:
complex(double r, double i) : r(r), i(i) {}
complex(double r) : r(rnew), i(0) {}
// ...
};
We can also say that the number is 0 + 0i if no value is given, i.e. if the complex number is
default-constructed:
complex() : r(0), i(0) {}