Гибкий дизайн несмотря на сильно зависимые классы

Другим решением было бы передать вашему контролеру объект, который предоставляет текущее состояние алгоритма в ответ на имена параметров, выраженные в виде строковых имен. Это позволяет отдельно компилировать ваши стратегии преобразования, потому что интерфейс этого интерфейса «обратного вызова» остается прежним, даже если вы добавляете больше параметров в свой алгоритм:

struct AbstractAlgorithmState {
virtual double getDoubleByName(const string& name) = 0;
virtual int getIntByName(const string& name) = 0;
};
struct ConvergenceChecker {
virtual bool converged(const AbstractAlgorithmState& state) = 0;
};

Это все, что нужно увидеть разработчикам средства проверки сходимости: они реализуют средство проверки и получают состояние.

Теперь вы можете создать класс, который тесно связан с вашей реализацией алгоритма для реализации AbstractAlgorithmState и получить параметр на основе его имени. Этот тесно связанный класс является частным для вашей реализации: вызывающие пользователи видят только его интерфейс, который никогда не меняется:

class PrivateAlgorithmState : public AbstractAlgorithmState {
private:
const Algorithm &algorithm;
public:
PrivateAlgorithmState(const Algorithm &alg) : algorithm(alg) {}
...
// Implement getters here
}
void runAlgorithm() {
PrivateAlgorithmState state(*this);
...
converged=_convChecker[i]->converged(state);
}

Использование отдельной структуры данных / состояний кажется достаточно простым — просто передайте ее в средство проверки в качестве постоянной ссылки для доступа только для чтения.

class Algorithm {
public:
struct State {
double foo_;
double bar_;
double foobar_;
};
struct ConvergenceChecker {
virtual ~ConvergenceChecker();
virtual bool isConverged(State const &) = 0;
}
void addChecker(std::unique_ptr<ConvergenceChecker>);
private:
std::vector<std::unique_ptr<ConvergenceChecker>> checkers_;
State state_;

bool isConverged() {
const State& csr = state_;
return std::all_of(checkers_.begin(),
checkers_.end(),
[csr](std::unique_ptr<ConvergenceChecker> &cc) {
return cc->isConverged(csr);
});
}
};

Может быть шаблон декоратора может помочь в упрощении (неизвестного) набора проверок сходимости. Таким образом, вы можете не зависеть от самого алгоритма от того, какие проверки могут выполняться, и вам не требуется контейнер для всех проверок.

Вы бы получили что-то вроде этого:

class ConvergenceCheck {
private:
ConvergenceCheck *check;
protected:
ConvergenceCheck(ConvergenceCheck *check):check(check){}
public:
bool converged() const{
if(check && check->converged()) return true;
return thisCheck();
}
virtual bool thisCheck() const=0;
virtual ~ConvergenceCheck(){ delete check; }
};

struct Check1 : ConvergenceCheck {
public:
Check1(ConvergenceCheck* check):ConvergenceCheck(check) {}
bool thisCheck() const{ /* whatever logic you like */ }
};

Затем вы можете создавать произвольные сложные комбинации проверок сходимости, сохраняя только одну ConvergenceCheck* член в Algorithm, Например, если вы хотите проверить два критерия (реализовано в Check1 а также Check2):

ConvergenceCheck *complex=new Check2(new Check1(nullptr));

Код не полный, но вы поняли идею. Кроме того, если вы фанат производительности и боитесь вызова виртуальной функции (thisCheck), вы можете применить любопытно возвращая шаблон чтобы устранить это.

Вот полный пример декораторов для проверки ограничений на int, чтобы дать представление о том, как это работает:

#include <iostream>

class Check {
private:
Check *check_;
protected:
Check(Check *check):check_(check){}
public:
bool check(int test) const{
if(check_ && !check_->check(test)) return false;
return thisCheck(test);
}
virtual bool thisCheck(int test) const=0;
virtual ~Check(){ delete check_; }
};

class LessThan5 : public Check {
public:
LessThan5():Check(NULL){};
LessThan5(Check* check):Check(check) {};
bool thisCheck(int test) const{ return test < 5; }
};

class MoreThan3 : public Check{
public:
MoreThan3():Check(NULL){}
MoreThan3(Check* check):Check(check) {}
bool thisCheck(int test) const{ return test > 3; }
};

int main(){

Check *morethan3 = new MoreThan3();
Check *lessthan5 = new LessThan5();
Check *both = new LessThan5(new MoreThan3());
std::cout << morethan3->check(3) << " " << morethan3->check(4) << " " << morethan3->check(5) << std::endl;
std::cout << lessthan5->check(3) << " " << lessthan5->check(4) << " " << lessthan5->check(5) << std::endl;
std::cout << both->check(3) << " " << both->check(4) << " " << both->check(5);

}

Выход:

0 1 1

1 1 0

0 1 0