la suppression des codes en double entraîne-t-elle des opérations redondantes ?

Question

void caller()
{
    int var;

    var = setvar();
    if (var == 1)
        func1();
    else if (var == 3)
        func3();
    else if (var == 8)
        func8();
}

void func1()
{
    common();
    //do something case 1 specific...
}

void func3()
{
    common();
    //do something case 3 specific...
}

void func8()
{
    common();
    //do something case 8 specific...
}

Dans ce cas, je me sens très mal à l'aise parce que j'ai une fonction en double. commun() qui pourrait être écrit à l'intérieur du appelant() pour supprimer les doublons. Je peux donc modifier le code ci-dessus comme suit :

void caller()
{
    int var;

    var = setvar();
    if (var == 1 || var == 3 || var == 8)
        common();
    if (var == 1)
        func1();
    else if (var == 3)
        func3();
    else if (var == 8)
        func8();
}

void func1()
{ //do something case 1 specific... }

void func3()
{ //do something case 3 specific... }

void func8()
{ //do something case 8 specific... }

Cependant, je me sens très mal à l'aise dans ce cas également, car appelant() vérifier maintenant var deux fois.

Je n'ai pas beaucoup d'expérience en matière de codage, et je ne sais donc pas ce qu'il faut prendre en compte pour choisir la meilleure solution. Quel est le meilleur code et pourquoi ? Que dois-je prendre en compte ?

Answer 1

Si common n'est censé être appelé que par func1 , func3 y func8 La première option est donc la meilleure - il n'y a aucune raison pour que l'on puisse faire des économies d'échelle. caller à connaître common et encore moins de l'appeler directement.

Idéalement, caller ne devrait pas se préoccuper de ce que func1 , func3 y func8 Il ne doit se préoccuper que des paramètres qu'ils prennent et des valeurs qu'ils renvoient. Supposons que vous ayez besoin d'ajouter une autre fonction (que nous appellerons func5 ). Doit-il appeler common également ? Ou non ? Que se passe-t-il si vous devez modifier le comportement de func3 de sorte qu'il n'appelle plus common du tout ?

Avec la première option, vous localisez les connaissances relatives aux common aux fonctions qui l'utilisent réellement, ce qui facilitera la maintenance et le débogage.

Answer 2

J'opterais pour la deuxième approche.

Tout d'abord, j'améliorerais ce code en séparant la fonction de validation (pour améliorer le débogage) et en utilisant un cas de commutation pour déterminer la fonction à exécuter en fonction de la valeur de var .

Pour :

• Vous pouvez facilement savoir où se trouve la fonction common() est utilisé simplement en regardant le isAllowed chiffres.
• Pas besoin d'écrire common() dans chaque fonction où vous l'utilisez. Il serait redondant si vous l'utilisiez dans des centaines de fonctions et vous pourriez en oublier une.
• Visualiser facilement quand common() sera appliquée

Cons :

• Vous devez ajouter ou supprimer des cas dans switch/case (utilisez if/else si vous préférez) en fonction des entiers définis dans isAllowed. Cela peut conduire à un incendie default si vous avez oublié d'ajouter un cas ou si un bug se produit.

• Vous vérifiez deux fois la valeur de la var.

  int isAllowed(int var){ return var == 1 || var == 3 || var == 8; }

  void caller() { int var = setVar(); if (isAllowed(var)){ common(); switch(var){ case 1: func1(); break; case 3: func3(); break; case 8: func8(); break; default: break; } } }

Answer 3

Vous pouvez utiliser un pointeur de fonction :

void caller()
{
    int var = setvar();
    void (*func)() = NULL;

    if (var == 1)
        func = func1;
    else if (var == 3)
        func = func3;
    else if (var == 8)
        func = func8;
    else return; // or error handling

    common();
    func();
}

Si un commun spécial est utilisé pour un cas spécifique, on peut utiliser deux pointeurs de fonction, l'un pour la fonction common partie une autre pour func partie.

void caller()
{
    int var = setvar();
    void (*func)() = NULL;
    void (*fcommon)() = common; // default common

    if (var == 1) {
        func = func1;
    } else if (var == 3) {
        func = func3;
    } else if (var == 8) {
        fcommon = common_for_8;
        func = func8;
    } else {
        return; // or error handling
    }

    fcommon();
    func();
}