Reduzieren Sie Code-Duplizierung

Question

Ich habe zwei Funktionen, die sich nur in einem Parameter (unterschiedliche Struktur) unterscheiden, die fast die gleiche Verarbeitung ausführen, was zu viel Codeverdopplung führt. Sehen Sie im folgenden vereinfachten Beispiel:

struct foo { 
    int a; 
}; 

struct bar { 
    int a; 
    int b; 
}; 

foo(struct foo *f) { 
    do_b(); 
    // error handling 
    f->a = 1; 
    do_c(); 
    // error handling 
    do_d(); 
    // error handling 
} 

bar(struct bar *b); { 
    do_a(); 
    // error handling 
    b->b = 2; 
    do_b(); 
    // error handling 
    b->a = 1; 
    do_c(); 
    // error handling 
    do_d(); 
    // error handling 
} 

Gibt es eine intelligente Art und Weise nur eine Funktion bei der Verwendung der Code-Duplizierung zu beseitigen?

Answer 1

Ja gibt es, aber nicht in einer Weise, die Sie sich vorstellen. Es ist sehr nützlich, die Typensicherheit zu halten, und es ist nicht in Ihrem besten Interesse, sie loszuwerden (entweder mit Hilfe von Zeigern auf Void oder Struct-Interitance).

Wenn Sie zwei verschiedene Typen haben, die aus einem sinnvollen Grund als separate Typen definiert sind, dann sollten Sie haben zwei separate Funktionen, die diese Typen übernehmen.

Was Sie in diesem Fall tun sollte, ist die Verdoppelung innerhalb dieser Funktionen zu entfernen:

first(int* a) 
{ 
    do_b(); 
    // error handling 
    *a = 1; 
    do_c(); 
    // error handling 
    do_d(); 
    // error handling 
} 

foo(struct foo *f) { 
    first(&f->a); 
} 

bar(struct bar *b); { 
    do_a(); 
    // error handling 
    b->b = 2; 
    first(&b->a); 
}