Suddivisione di un file di grandi dimensioni in moduli separati in C/C++, Java e Python

| | | | | | | | | | |

Questo approccio è destinato al fallimento e di solito richiede la riscrittura da zero.

Quindi, per risolvere questo scenario, possiamo provare a dividere il problema in diversi sottoproblemi e poi provare a risolverlo in uno uno.

Questo non solo semplifica il nostro compito, ma ci consente anche di ottenere l`

Ora la grande domanda è come "rompere" non in teoria, ma SOFTWARE .

Vedremo diversi tipi di tali unità nei linguaggi popolari ‚Äã‚Äãcome C / C++, Python e Java.

C / C++

A scopo illustrativo,

Supponiamo di avere tutti gli inserimenti di elenchi collegati di base in un programma. Poiché ci sono molti metodi (funzioni), non possiamo ingombrare il programma scrivendo tutte le definizioni dei metodi sopra la funzione principale richiesta. Ma anche se lo facessimo, potrebbe esserci un problema nell`ordinare i metodi, quando un metodo dovrebbe essere prima di un altro e così via.

Quindi, per risolvere questo problema, possiamo dichiarare tutti i prototipi all`inizio di il programma, quindi il metodo principale e di seguito che possiamo definirli in un ordine particolare:

Programma:

FullLinkedList.c


// inserisce un elenco completo di collegamenti


# include "stdio.h >
# include "stdlib.h >


// ------------ -------------- ------
// Annunci - START:
// ------ --------------------------


struct Nodo;

struct Nodo * create_node ( int dati);

void b_insert ( struct Node ** head, int data);

void n_insert ( struct Nodo ** head, int dati, int pos);

void e_insert ( struct Node ** head, int data);

void display ( struct Nodo * temp);


// ------------ -------------- ------
// Annunci - FINE:
// ------ --------------------------


int main ()

{

struct Nodo * head = NULL;


int ch, data, pos;


printf ( " Elenco collegato: " );

mentre (1) {

printf ( "1.Inserisci all`inizio" );

printf ( "2.Insert all`ennesima posizione" );

printf ( "3.Insert Alla fine" );

printf ( "4.Display " );

printf ( "0.Exit " );

printf ( "Inserisci la tua scelta :" );

scanf ( "% d" , & amp; ch);


cambia (ch) {

maiuscolo 1:

printf ( "Inserisci il dati:" );

scanf ( "% d" , & amp; dati);

b_insert (& amp; head, data);

interruzione ;


case 2:

printf ( "Inserisci il dati:" );

scanf ( "% d" , & amp; dati);


printf ( " Inserisci la Posizione: " );

scanf ( "% d" , & amp; pos);

n_insert (& amp; head, data, pos);

interruzione ;


case 3:

printf ( "Inserisci il dati:" );

scanf ( "% d" , & amp; dati);

e_insert (& amp; head, data);

interruzione ;


maiuscolo 4:

display (testa);

interruzione ;


maiuscole/minuscole 0:

return 0;


default :

printf ( "Scelta sbagliata" );

}

}

}


// ---------------- ---------- ------
// Definizioni - START:
// ---- --------------


struct Nodo {

int < codice classe ="semplice"> dati;

struct Nodo * next;

};


struct Nodo * create_node ( int data)

{

struct Node * temp

= ( struct Node *)

malloc ( sizeof ( struct Nodo));

temp- > dati = dati;

temp- > successivo = NULL;


return temp;

}


void b_insert ( struct Node ** head, int data)

{

struct Nodo * new_node = create_node (dati);


new_node- > successivo = * testa;

* head = new_node;

}


void n_insert ( struct Node ** head, int data, int pos)

{

if (* head == NULL) {

b_insert (head, data);

return ;

}


struct Nodo * new_node = create_node (dati);


struct Nodo * temp = * head;


for ( int i = 0; i "pos - 2; ++ i)

temp = temp- > prossimo;


new_node- > successivo = temp- > prossimo;

temp- > successivo = nuovo_nodo;

}


void e_insert ( struct Node ** head, int data)

{

if (* head == NULL) {

b_insert (testa, dati);

return ;

}


struct Nodo * temp = * head;


mentre (temp- > next! = NULL)

temp = temp- > prossimo;


struct Nodo * new_node = create_node (dati);

temp- > successivo = nuovo_nodo;

}


void display ( struct Nodo * temp)

{

printf ( "Gli elementi sono:" );

while (temp! = NULL) {

printf ( "% d" , temp- > dati);

temp = temp- > prossimo;

}

printf ( " " );

}


// ------ --------------------------
// Definizioni - FINE
// ------- -----------

Compilazione del codice: possiamo compilare il programma sopra:

 gcc linkedlist.c -o linkedlist 

E funziona!

I problemi principali nel codice sopra:
Possiamo già vedere i problemi principali con il programma, non è così facile lavorare con il codice né individualmente né in gruppo.

Se qualcuno vuole lavorare con quanto sopra programma, poi alcuni dei tanti problemi che la persona deve affrontare:

  1. Bisogna passare attraverso il file sorgente completo. per migliorare o migliorare alcune funzionalità.
  2. Non può essere facilmente riutilizzato il programma come base per altri progetti.
  3. Il codice è molto disordinato e non è affatto attraente, il che rende molto difficile la navigazione nel codice.

Nel caso di un progetto di gruppo o di programmi di grandi dimensioni, l`approccio di cui sopra garantisce un aumento dei costi complessivi, dell`energia e dei tassi di guasto.

Approccio corretto:

Vediamo che queste righe iniziano in ogni programma C/C++ che inizia con "#include".
Ciò significa includere tutte le funzioni dichiarate nell`intestazione "library" (file .h) ed eventualmente definite nei file library.c / cpp .

Queste righe vengono preelaborate in fase di compilazione.

Possiamo provare a creare manualmente una tale libreria per i nostri scopi.

Cose importanti da ricordare :

  1. I file ".h" contengono solo dichiarazioni di prototipi (come funzioni, strutture) e variabili globali.
  2. I file ".c / .cpp" contengono l`effettiva implementazione (definizioni di dichiarazione nei file di intestazione)
  3. Quando si compilano tutti i file sorgente, assicurarsi che più definizioni della stessa funzione, variabile, ecc. non esistono per lo stesso progetto. (MOLTO IMPORTANTE)
  4. Usa funzioni statiche, per limitarti al file in cui sono dichiarate.
  5. Utilizza la parola chiave extern per utilizzare variabili a cui fanno riferimento e file esterni.
  6. Quando usi C++, fai attenzione con gli spazi dei nomi, usa sempre nome_spazio dei nomi:: funzione (), per evitare collisioni.
  7. Suddividendo il programma in codici più piccoli:
    Dopo aver esaminato il programma sopra, possiamo vedere come questo grande programma può essere suddiviso in parti piccole adatte e quindi facilmente elaborato.

    Il programma sopra ha essenzialmente 2 funzioni principali:
    1) Creare, inserire e salvare i dati nei nodi.
    2) Visualizzare i nodi


    In questo modo posso dividere il programma di conseguenza in modo che:
    1) Il file principale sia > Driver del programma, Nice Wrapper da Insertion Modules e dove utilizziamo file aggiuntivi.
    2) Incolla - > La vera implementazione sta qui.

    Con i punti importanti citati, il programma è suddiviso in:

    linkedlist.c - > Contiene il programma driver
    insert.c - > Contiene codice per l`inserimento

    linkedlist.h - > Contiene le dichiarazioni Node necessarie
    insert.h - > Contiene le dichiarazioni di inserimento dei nodi necessarie

    In ogni file di intestazione iniziamo con:

     #ifndef FILENAME_H #define FILENAME_H Dichiarazioni ... #endif 

    Il motivo per cui scriviamo le nostre dichiarazioni tra #ifndef, #define e #endif, è impedire dichiarazioni multiple di identificatori come tipi di dati, variabili, ecc., quando viene chiamato lo stesso file di intestazione in un nuovo file appartenente allo stesso progetto.

    Per questo programma di esempio:

    insert.h - > Contiene la dichiarazione del nodo di inserimento così come la dichiarazione del nodo stesso.

    È molto importante ricordare che il compilatore può vedere le dichiarazioni nel file di intestazione, ma se provi a scrivere il codice che include la dichiarazione altrove, questo risulterà in un errore, poiché il compilatore compila ogni file .c individualmente prima di passare al passaggio del collegamento. ,

    connectedlist.h - > Un file di supporto che contiene Node e le relative dichiarazioni Display che devono essere incluse per i file che li utilizzano.


    insert.c - > Includere una dichiarazione Node tramite #include "connectedlist.h", che contiene la dichiarazione e tutte le altre definizioni di metodo dichiarate in insert.h.

    connectedlist.c - > Simple Wrapper, contenente un ciclo infinito che richiede all`utente di inserire dati interi nelle posizioni richieste e contiene anche un metodo che visualizza l`elenco.

    E l`ultima cosa da tenere a mente è che non ha significato i file di inclusione l`uno nell`altro possono portare a più sostituzioni e risulteranno in un errore.

    Tenendo conto di quanto sopra, dovresti dividere attentamente in routine adeguate.

    linkedlist.h


    // connectedlist.h


    # ifndef LINKED_LIST_H
    # define LINKED_LIST_H


    struct Nodo {

    int dati;

    struct Nodo * next;

    };


    void display ( struct Nodo * temp);


    # endif

    insert.h


    // insert.h


    # ifndef INSERT_H
    #define INSERT_H


    struct Nodo;

    struct Nodo * create_node ( int dati);

    void b_insert ( struct Node ** head, int data);

    void n_insert ( struct Nodo ** head, int dati, int pos);

    void e_insert ( struct Node ** head, int data);


    # endif

    insert.c


    // insert.c


    # include "linkedlist.h"
    // & quot; & quot; quindi il preprocessore guarda
    // alla directory corrente e
    // ai file della libreria standard in seguito.


    # include "stdlib.h >


    struct Nodo * create_node ( int data)

    {

    struct Node * temp = ( struct Nodo *) malloc ( sizeof ( struct Nodo));

    temp- > dati = dati;

    temp- > successivo = NULL;


    return temp;

    }


    void b_insert ( struct Node ** head, int data)

    {

    struct Nodo * new_node = create_node (dati);


    new_node- > successivo = * testa;

    * head = new_node;

    }


    void n_insert ( struct Node ** head, int data, int pos)

    {

    if (* head == NULL) {

    b_insert (head, data);

    return ;

    }


    struct Nodo * new_node = create_node (dati);


    struct Nodo * temp = * head;


    for ( int i = 0; i "pos - 2; ++ i)

    temp = temp- > prossimo;


    new_node- > successivo = temp- > prossimo;

    temp- > successivo = nuovo_nodo;

    <

    Suddivisione di un file di grandi dimensioni in moduli separati in C/C++, Java e Python _files: Questions

    Suddivisione di un file di grandi dimensioni in moduli separati in C/C++, Java e Python cos: Questions

    Shop

    Best Python online courses for 2022

    $

    Best laptop for Fortnite

    $

    Best laptop for Excel

    $

    Best laptop for Solidworks

    $

    Best laptop for Roblox

    $

    Best computer for crypto mining

    $

    Best laptop for Sims 4

    $

    Best laptop for Zoom

    $499

    Latest questions

    NUMPYNUMPY

    psycopg2: insert multiple rows with one query

    12 answers

    NUMPYNUMPY

    How to convert Nonetype to int or string?

    12 answers

    NUMPYNUMPY

    How to specify multiple return types using type-hints

    12 answers

    NUMPYNUMPY

    Javascript Error: IPython is not defined in JupyterLab

    12 answers

    Wiki

    Python OpenCV | cv2.putText () method

    numpy.arctan2 () in Python

    Python | os.path.realpath () method

    Python OpenCV | cv2.circle () method

    Python OpenCV cv2.cvtColor () method

    Python - Move item to the end of the list

    time.perf_counter () function in Python

    Check if one list is a subset of another in Python

    Python os.path.join () method