C++ for Scientists - Technische Universität Dresden

188 CHAPTER 6. INHERITANCE
{
}
std::cout ≪ ”CG\n”;
void bicg(const matrix& A, const vector& b, vector& x)
{
std::cout ≪ ”BiCG\n”;
}
int main (int argc, char∗ argv[])
{
matrix A;
vector b, x;
}
switch (std::atoi(argv[1])) {
case 0: cg(A, b, x); break;
case 1: bicg(A, b, x); break;
}
return 0 ;
This works but it is not scalable with respect to source code complexity. If we call the solver
with other vectors and matrices somewhere else we must copy the whole switch-case-block
for each argument combination. This can avoided by encapsulating the block into a function
and call this one with different arguments. More complicated is to different preconditioners
(diagonal, ILU, IC, . . . ) that are also dynamically selected. Shall we copy a switch block for
the preconditioners into each case block of the solvers?
An elegant solution is an abstract solver class and derived classes for the solvers:
struct solver
{
virtual void operator()(const matrix& A, const vector& b, vector& x)= 0;
virtual ∼solver() {}
};
// potentially templatize
struct cg solver : solver
{
void operator()(const matrix& A, const vector& b, vector& x) { cg(A, b, x); }
};
struct bicg solver : solver
{
void operator()(const matrix& A, const vector& b, vector& x) { bicg(A, b, x); }
};
In the application we can define one or multiple pointers of type solver and assign them the
desired solver:
// Factory
solver∗ my solver= 0;
switch (std::atoi(argv[1])) {
case 0: my solver= new cg solver; break;
case 1: my solver= new bicg solver; break;