Splits een groot bestand in afzonderlijke modules in C/C++, Java en Python

| | | | | | | | | | |

Deze aanpak is gedoemd te mislukken en vereist meestal een nieuwe versie.

Dus om dit scenario op te lossen, kunnen we proberen het probleem in verschillende subproblemen op te delen en het vervolgens één voor één proberen op te lossen. een.

Dit maakt onze taak niet alleen gemakkelijker, maar stelt ons ook in staat om

Nu de grote vraag is hoe te "breken", niet theoretisch, maar SOFTWARE .

We zullen verschillende soorten van dergelijke eenheden in populaire talen zien, zoals C / C++, Python en Java.

C / C++

Voor illustratieve doeleinden,

Laten we aannemen dat we alle basis gelinkte lijst-inserts in één programma hebben. Omdat er veel methoden (functies) zijn, kunnen we het programma niet rommelig maken door alle methodedefinities boven de vereiste hoofdfunctie te schrijven. Maar zelfs als we dat zouden doen, zou er een probleem kunnen zijn met het bestellen van methoden, wanneer de ene methode voor de andere zou moeten zijn, enzovoort.

Dus, om dit probleem op te lossen, kunnen we alle prototypen aan het begin van het programma, en dan de hoofdmethode en daaronder kunnen we ze in een bepaalde volgorde definiëren:

Programma:

FullLinkedList.c


// voeg een volledige gelinkte lijst in


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


// ------------ -------------- ------
// Aankondigingen - START:
// ------ --------------------------


struct Knooppunt;

struct Knooppunt * create_node ( int data);

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

void n_insert ( struct Knooppunt ** head, int data, int pos);

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

void display ( struct Node * temp);


// ------------ -------------- ------
// Aankondigingen - EINDE:
// ------ --------------------------


int main ()

{

struct Knooppunt * head = NULL;


int ch, data, pos;


printf ( " Gelinkte lijst: " );

while (1) {

printf ( "1.Invoegen bij begin" );

printf ( "2.Invoegen op N-de Positie" );

printf ( "3.Invoegen At Ending" );

printf ( "4.Display " );

printf ( "0.Exit " );

printf ( "Voer uw keuze in :" );

scanf ( "% d" , & ch);


switch (ch) {

hoofdlettergebruik 1:

printf ( "Voer de data:" );

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

b_insert (& head, data);

break ;


case 2:

printf ( "Voer de data:" );

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


printf ( " Voer de Positie in: " );

scanf ( "% d" , & pos);

n_insert (& head, data, pos);

break ;


case 3:

printf ( "Voer de data:" );

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

e_insert (& head, data);

break ;


case 4:

weergave (hoofd);

break ;


case 0:

return 0;


standaard :

printf ( "Verkeerde keuze" );

}

}

}


// ---------------- ---------- ------
// Definities - START:
// ---- ----------------------------


struct Knooppunt {

int gegevens;

struct Knooppunt * volgende;

};


struct Node * create_node ( int data)

{

struct Node * temp

= ( struct Node *)

malloc ( sizeof ( struct Node));

temp- > gegevens = gegevens;

temp- > volgende = NULL;


return temp;

}


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

{

struct Node * new_node = create_node (data);


new_node- > volgende = * hoofd;

* head = new_node;

}


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

{

if (* head == NULL) {

b_insert (head, data);

return ;

}


struct Node * new_node = create_node (data);


struct Node * temp = * head;


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

temp = temp- > De volgende;


new_node- > volgende = temp- > De volgende;

temp- > volgende = nieuwe_node;

}


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

{

if (* head == NULL) {

b_insert (head, data);

return ;

}


struct Node * temp = * head;


while (temp- > volgende! = NULL)

temp = temp- > De volgende;


struct Node * new_node = create_node (data);

temp- > volgende = nieuwe_node;

}


void display ( struct Node * temp)

{

printf ( "De elementen zijn:" );

while (temp! = NULL) {

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

temp = temp- > De volgende;

}

printf ( " " );

}


// ------ --------------------------
// Definities - END
// --------------------- -----------

De code compileren: we kunnen het bovenstaande programma compileren:

 gcc linkedlist.c -o linkedlist 

En het werkt!

De belangrijkste problemen in de bovenstaande code:
We kunnen de belangrijkste problemen met het programma al zien, het is niet zo eenvoudig om individueel of in een groep met de code te werken.

Als iemand met het bovenstaande wil werken programma, dan enkele van de vele problemen waarmee die persoon wordt geconfronteerd:

  1. Men moet het volledige bronbestand doorlopen. om bepaalde functionaliteit te verbeteren of te verbeteren.
  2. Kan het programma niet gemakkelijk hergebruiken als basis voor andere projecten.
  3. De code is erg onoverzichtelijk en is helemaal niet aantrekkelijk, waardoor het erg moeilijk is om door de code te navigeren.

In het geval van een groepsproject of grote programma’s, zal de bovenstaande aanpak gegarandeerd de totale kosten, energie en uitvalpercentages verhogen.

Correcte aanpak:

We zien dat deze regels beginnen in elk C/C++-programma dat begint met "#include".
Dit betekent om omvatten alle functies gedeclareerd in de "library" header (.h files) en eventueel gedefinieerd in library.c / cpp bestanden.

Deze regels worden tijdens het compileren voorbewerkt.

We kunnen handmatig proberen een dergelijke bibliotheek voor onze eigen doeleinden te maken.

Belangrijke dingen om te onthouden :

  1. De ".h"-bestanden bevatten alleen prototype-declaraties (zoals functies, structuren) en globale variabelen.
  2. De ".c / .cpp"-bestanden bevatten de daadwerkelijke implementatie (declaratiedefinities in headerbestanden)
  3. Zorg er bij het compileren van alle bronbestanden voor dat meerdere definities van dezelfde functie, variabele, enz. bestaan niet voor hetzelfde project. (HEEL BELANGRIJK)
  4. Gebruik statische functies om jezelf te beperken tot het bestand waarin ze zijn gedeclareerd.
  5. Gebruik het trefwoord extern om variabelen te gebruiken waarnaar wordt verwezen door en externe bestanden.
  6. Als je C++ gebruikt, wees dan voorzichtig met namespaces, gebruik altijd namespace_name:: function (), om botsingen te voorkomen.
  7. Door het programma op te splitsen in kleinere codes:
    Na onderzoek van het bovenstaande programma kunnen we zien hoe dit grote programma kan worden opgesplitst in geschikte kleine onderdelen en vervolgens gemakkelijk te verwerken.

    Het bovenstaande programma heeft in wezen 2 hoofdfuncties:
    1) Creëer, voeg in en bewaar gegevens in knooppunten.
    2) Toon knooppunten


    Op deze manier kan ik het programma dienovereenkomstig splitsen, zodat:
    1) Het hoofdbestand is > Programmastuurprogramma, Nice Wrapper van Insertion Modules en waar we extra bestanden gebruiken.
    2) Plakken - > De echte implementatie ligt hier.

    Met de genoemde belangrijke punten is het programma onderverdeeld in:

    linkedlist.c - > Bevat Stuurprogramma
    insert.c - > Bevat code voor invoeging

    linkedlist.h - > Bevat de benodigde Node-declaraties
    insert.h - > Bevat de benodigde Node Insertion Declarations

    In elk headerbestand beginnen we met:

     #ifndef FILENAME_H #define FILENAME_H Declarations ... #endif 

    De reden dat we onze declaraties tussen #ifndef, #define en #endif, schrijven, is om meerdere declaraties van identifiers zoals datatypes, variabelen, enz. te voorkomen wanneer één en hetzelfde headerbestand wordt aangeroepen. in een nieuw bestand dat bij hetzelfde project hoort.

    Voor dit voorbeeldprogramma:

    insert.h - > Bevat de declaratie van de insert-node en de declaratie van de node zelf.

    Het is erg belangrijk om te onthouden dat de compiler declaraties in het headerbestand kan zien, maar als je probeert code te schrijven die bevat de declaratie ergens anders, dit zal resulteren in een fout, omdat de compiler elk .c-bestand afzonderlijk compileert voordat hij verder gaat met de linkstap. ,

    connectedlist.h - > Een helperbestand dat Node en zijn Display-declaraties bevat die moeten worden opgenomen voor bestanden die ze gebruiken.


    insert.c - > Voeg een Node-declaratie toe via #include "connectedlist.h", die de declaratie bevat, evenals alle andere methodedefinities die zijn gedeclareerd in insert.h.

    connectedlist.c - > Simple Wrapper, met een oneindige lus die de gebruiker vraagt om integer-gegevens op de vereiste posities in te voegen, en ook met een methode die de lijst weergeeft.

    En het laatste dat u in gedachten moet houden, is dat het zinloos is inclusiebestanden in elkaar kunnen overschrijven kan leiden tot meerdere overschrijvingen en zal resulteren in een fout.

    Rekening houdend met het bovenstaande, moet u zorgvuldig verdelen in geschikte routines.

    linkedlist.h


    // connectedlist.h


    # ifndef LINKED_LIST_H
    # definiëren LINKED_LIST_H


    struct Knooppunt {

    int gegevens;

    struct Knooppunt * volgende;

    };


    void weergave ( struct Node * temp);


    # endif

    insert.h


    // insert.h


    # ifndef INSERT_H
    #define INSERT_H


    struct Knooppunt;

    struct Knooppunt * create_node ( int data);

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

    void n_insert ( struct Knooppunt ** head, int data, int pos);

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


    # endif

    insert.c


    // insert.c


    # include "linkedlist.h"
    // & quot; & quot; dus de preprocessor kijkt
    // naar de huidige directory en
    // standaardbibliotheekbestanden later.


    # include "stdlib.h >


    struct Node * create_node ( int data)

    {

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

    temp- > gegevens = gegevens;

    temp- > volgende = NULL;


    return temp;

    }


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

    {

    struct Node * new_node = create_node (data);


    new_node- > volgende = * hoofd;

    * head = new_node;

    }


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

    {

    if (* head == NULL) {

    b_insert (head, data);

    return ;

    }


    struct Node * new_node = create_node (data);


    struct Node * temp = * head;


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

    temp = temp- > De volgende;


    new_node- > volgende = temp- > De volgende;

    temp- > volgende = nieuwe_node;

    <

    Splits een groot bestand in afzonderlijke modules in C/C++, Java en Python _files: Questions

    Splits een groot bestand in afzonderlijke modules in C/C++, Java en 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