Die akzeptierte Antwort ist in Ordnung, wenn Sie nur 3 Fälle haben und die Logik für jeden einfach ist.
Wenn die Logik für jeden Fall komplizierter wäre oder es viel mehr Fälle gibt, ist es weitaus besser, das Entwurfsmuster der Verantwortungskette zu verwenden.
Sie erstellen eine, BaseValidatordie einen Verweis auf a BaseValidatorund eine Methode auf validateund eine Methode zum Aufrufen der Validierung für den referenzierten Validator enthält.
class BaseValidator {
BaseValidator* nextValidator;
public:
BaseValidator() {
nextValidator = 0;
}
void link(BaseValidator validator) {
if (nextValidator) {
nextValidator->link(validator);
} else {
nextValidator = validator;
}
}
bool callLinkedValidator(bool v1, bool v2, bool v3, bool v4) {
if (nextValidator) {
return nextValidator->validate(v1, v2, v3, v4);
}
return false;
}
virtual bool validate(bool v1, bool v2, bool v3, bool v4) {
return false;
}
}
Anschließend erstellen Sie eine Reihe von Unterklassen, die von der erben BaseValidator, und überschreiben die validateMethode mit der für jeden Validator erforderlichen Logik.
class Validator1: public BaseValidator {
public:
bool validate(bool v1, bool v2, bool v3, bool v4) {
if (v1 && v2 && v3 && v4) {
return true;
}
return nextValidator->callLinkedValidator(v1, v2, v3, v4);
}
}
Dann ist es einfach, jeden Ihrer Validatoren zu instanziieren und jeden von ihnen als Wurzel der anderen festzulegen:
Validator1 firstValidator = new Validator1();
Validator2 secondValidator = new Validator2();
Validator3 thirdValidator = new Validator3();
firstValidator.link(secondValidator);
firstValidator.link(thirdValidator);
if (firstValidator.validate(value1, value2, value3, value4)) { ... }
Im Wesentlichen hat jeder Validierungsfall eine eigene Klasse, die dafür verantwortlich ist, (a) festzustellen, ob die Validierung mit dieser übereinstimmt Fall , und (b) die Validierung an eine andere Person in der Kette zu senden, wenn dies nicht der Fall ist.
Bitte beachten Sie, dass ich mit C ++ nicht vertraut bin. Ich habe versucht, die Syntax einiger Beispiele zu finden, die ich online gefunden habe. Wenn dies jedoch nicht funktioniert, behandeln Sie sie eher wie einen Pseudocode. Ich habe auch ein vollständiges funktionierendes Python-Beispiel unten, das bei Bedarf als Grundlage verwendet werden kann.
class BaseValidator:
def __init__(self):
self.nextValidator = 0
def link(self, validator):
if (self.nextValidator):
self.nextValidator.link(validator)
else:
self.nextValidator = validator
def callLinkedValidator(self, v1, v2, v3, v4):
if (self.nextValidator):
return self.nextValidator.validate(v1, v2, v3, v4)
return False
def validate(self, v1, v2, v3, v4):
return False
class Validator1(BaseValidator):
def validate(self, v1, v2, v3, v4):
if (v1 and v2 and v3 and v4):
return True
return self.callLinkedValidator(v1, v2, v3, v4)
class Validator2(BaseValidator):
def validate(self, v1, v2, v3, v4):
if (v1 and v2 and v3 and not v4):
return True
return self.callLinkedValidator(v1, v2, v3, v4)
class Validator3(BaseValidator):
def validate(self, v1, v2, v3, v4):
if (v1 and not v2 and not v3 and not v4):
return True
return self.callLinkedValidator(v1, v2, v3, v4)
firstValidator = Validator1()
secondValidator = Validator2()
thirdValidator = Validator3()
firstValidator.link(secondValidator)
firstValidator.link(thirdValidator)
print(firstValidator.validate(False, False, True, False))
Auch hier finden Sie diesen Overkill möglicherweise für Ihr spezielles Beispiel, aber er erzeugt viel saubereren Code, wenn Sie am Ende eine weitaus kompliziertere Reihe von Fällen haben, die erfüllt werden müssen.
ifAnweisung verwenden. Da es sich um boolesche Flags handelt, können Sie außerdem jedes Szenario als Konstante modellieren und dagegen prüfen.