Una struttura dovrebbe essere rifattorizzata in strutture più piccole?

Question

Una struttura dovrebbe essere rifattorizzata in strutture più piccole?

#1 da (7 voti)

0

In uno dei progetti (in C), ho il codice che assomiglia a questo ( i nomi sono offuscati appositamente per la domanda per non fornire dettagli del probject ):

typedef struct Module_s {
    /* These fields are parsed by f1() */
    S1 *s11;
    S2 *s12;
    size_t n11;
    size_t n12;
    int i11;

    /* These fields are parsed by f2() */
    S2 *s21;
    S3 *s22;
    S4 *s23;
    char *c24;

    /* These fields are set by f3() and later */
    void *v31;
    bool b32;
    S5 s33[N];
    bool b34;
} Module_t;

{
    /* Read only header of file and
     * parse first 5 fields to determine how to load the rest. */
    Module_t *module = f1(input_file);

    /* Read the rest of file using information set by f1()
     * and determine how f3() should preprocess it. */
    f2(input_file, module);

    /* Preprocess the file using information provided by f1() and f2(). */
    f3(module);

    /* Process the file using the information provided by f2() and f3(). */
    f4(module);
}

Quindi, la domanda è: è una buona scelta separare Module_t in 3 pezzi più piccoli, che conterranno campi corrispondenti, impostati da ciascuna funzione? Quindi ogni funzione accetterà e restituirà solo una parte più piccola di Module_t , che è probabilmente buona, ma potrebbe complicare ulteriormente lo sviluppo in quanto le interconnessioni diventano più complesse e mantenere tutti i campi dipendenti in un posto sembra più semplice.

Quello che ho in mente è questo:

typedef struct SS1_s {
    /* These fields are parsed by f1() */
    S1 *s11;
    S2 *s12;
    size_t n11;
    size_t n12;
    int i11;
} SS1_t;


typedef struct SS2_s {
    /* These fields are parsed by f2() */
    S2 *s21;
    S3 *s22;
    S4 *s23;
    char *c24;
} SS2_t;


typedef struct SS3_s {
    /* These fields are set by f3() and later */
    void *v31;
    bool b32;
    S5 s33[N];
    bool b34;
} SS3_t;


typedef struct Module_s {
    SS1_t ss1;
    SS2_t ss2;
    SS3_t ss3;
} Module_t;


{
    /* Read only header of file and
     * parse first 5 fields to determine how to load the rest. */
    SS1_t *ss1 = f1(input_file);

    /* Read the rest of file using information set by f1()
     * and determine how f3() should preprocess it. */
    SS2_t *ss2 = f2(input_file, ss1);

    /* Preprocess the file using information provided by f1() and f2(). */
    SS3_t *ss3 = f3(ss1, ss2);

    /* Compose module and
     * process the file using the information provided by f2() and f3().
     * Store ss1 as well for future use. */
    Module_t module = f4(ss1, ss2, ss3);
}

Quindi, dovrei rifattare la struttura in sottostrutture più piccole?

refactoring parsing

posta Michael Pankov 19.12.2013 - 09:52

fonte

1 risposta

Leggi altre domande sui tag refactoring parsing

HTML: alternativa per l'ID quando l'ID è unico all'interno di un determinato ambito? Limitazione di determinate funzionalità solo all'ambiente di sviluppo [chiuso]

score 7 · Accepted Answer

Lo stai osservando da un punto di vista puramente tecnico, e questo è il problema.

Stai chiedendo una decisione di progettazione per qualcosa che sembra essere un modello di dominio, e la progettazione del modello di dominio dovrebbe basarsi quasi completamente sulla conoscenza del dominio (cioè ciò che hai offuscato) piuttosto che sui dettagli tecnici di quale parte viene analizzato da quale funzione.

Se i tuoi "tre pezzi più piccoli" rappresentano parti del modello che sono concettualmente coerenti (per le quali un buon criterio è se puoi dare loro un nome significativo), allora sì, dovresti dividerlo in quel modo. Se no, allora non farlo. Il punto di progettazione è rendere il codice più facile da capire e un modello è più facilmente comprensibile quando le sue strutture riflettono da vicino i concetti di dominio.

Naturalmente, ci sono buone probabilità che questo sia ciò che stai già facendo e quei blocchi vengono elaborati con funzioni diverse esattamente perché sono concettualmente separati. Ma la tua offuscazione rende impossibile dire e quindi impossibile rispondere alla domanda.