La réponse acceptée est bonne lorsque vous n'avez que 3 cas et où la logique de chacun est simple.
Mais si la logique de chaque cas était plus compliquée, ou s'il y a beaucoup plus de cas, une bien meilleure option consiste à utiliser le modèle de conception de la chaîne de responsabilité .
Vous créez un BaseValidatorqui contient une référence à a BaseValidatoret une méthode à validateet une méthode pour appeler la validation sur le validateur référencé.
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;
}
}
Ensuite, vous créez un certain nombre de sous-classes qui héritent de BaseValidator, en remplaçant la validateméthode par la logique nécessaire pour chaque validateur.
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);
}
}
Ensuite, son utilisation est simple, instanciez chacun de vos validateurs et définissez chacun d'entre eux comme étant la racine des autres:
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)) { ... }
En substance, chaque cas de validation a sa propre classe qui est responsable (a) de déterminer si la validation correspond à ce cas, et (b) d'envoyer la validation à quelqu'un d'autre dans la chaîne si ce n'est pas le cas.
Veuillez noter que je ne suis pas familier avec C ++. J'ai essayé de faire correspondre la syntaxe de certains exemples que j'ai trouvés en ligne, mais si cela ne fonctionne pas, traitez-le plus comme un pseudocode. J'ai également un exemple Python fonctionnel complet ci-dessous qui peut être utilisé comme base si vous le souhaitez.
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))
Encore une fois, vous pouvez trouver cette surpuissance pour votre exemple spécifique, mais cela crée un code beaucoup plus propre si vous vous retrouvez avec un ensemble de cas beaucoup plus compliqués qui doivent être remplis.
ifdéclaration complexe . De plus, comme il s'agit d'indicateurs booléens, vous pouvez modéliser chaque scénario en tant que constante et la comparer.