Change language
Python.Engineering Wiki Aufteilen einer großen Datei in separate Module in C/C++, Java und Python

Aufteilen einer großen Datei in separate Module in C/C++, Java und Python

_files | cos | File handling | insert | mean | open | Python functions | scanf | sep | sin | split | std
Michael Zippo Michael Zippo

Dieser Ansatz ist zum Scheitern verurteilt und muss normalerweise von Grund auf neu geschrieben werden.

Um dieses Szenario zu lösen, können wir also versuchen, das Problem in mehrere Teilprobleme zu unterteilen und dann versuchen, es nacheinander zu lösen ein.

Dies erleichtert nicht nur unsere Aufgabe, sondern ermöglicht uns auch,

Jetzt Die große Frage ist, wie man nicht theoretisch "zerbricht", sondern SOFTWARE.

Wir werden mehrere verschiedene Arten solcher Einheiten in populären Sprachen wie C / C++ sehen, Python und Java.

C / C++

Zur Veranschaulichung:

Nehmen wir an, wir haben alle grundlegenden verknüpften Listeneinfügungen in einem Programm. Da es viele Methoden (Funktionen) gibt, können wir das Programm nicht überladen, indem wir alle Methodendefinitionen über die erforderliche Hauptfunktion schreiben. Aber selbst wenn wir das täten, könnte es ein Problem geben, Methoden zu ordnen, wenn eine Methode vor einer anderen stehen sollte, und so weiter.

Um dieses Problem zu lösen, können wir also alle Prototypen am Anfang deklarieren das Programm und dann die Main-Methode und darunter können wir sie in beliebiger Reihenfolge definieren:

Program:

FullLinkedList.c


// eine vollständige verknüpfte Liste einfügen


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


// ------------ -------------- ------
// Ankündigungen - START:
// ------ --------------------------


struct Knoten;

struct Node * create_node ( int data);

void b_insert ( struct Knoten ** Kopf, int data);

void n_insert ( struct Knoten ** Kopf, int data, int pos);

void e_insert ( struct Knoten ** Kopf, int data);

void display ( struct Knoten * temp);


// ------------ -------------- ------
// Ankündigungen - ENDE:
// ------ ---------------------


int main ()

{

struct Node * head = NULL;


int ch, data, pos;


printf ( " Verknüpfte Liste: " );

while (1) {

printf ( "1.Insert at Beginning" );

printf ( "2.Insert an N-ter Position" );

printf ( "3.Insert Am Ende" );

printf ( "4.Display " );

printf ( "0.Exit " );

printf ( "Geben Sie Ihre Wahl ein :" );

scanf ( "% d" , & ch);


switch (ch) {

case 1:

printf ( "Geben Sie die Daten:" );

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

b_insert (& amp; Kopf, Daten);

break ;


case 2:

printf ( "Geben Sie die Daten:" );

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


printf ( " Geben Sie die Position ein: " );

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

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

break ;


case 3:

printf ( "Geben Sie die Daten:" );

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

e_insert (& amp; Kopf, Daten);

break ;


case 4:

< Codeklasse ="undefinierte Leerzeichen"> Anzeige (Kopf);

break ;


case 0:

< Codeklasse ="undefinierte Leerzeichen"> return 0;


default :

printf ( "Wrong Choice" );

}

}

}


// ---------------- ---------- ------
// Definitionen - START:
// ---- -----------------------


struct Knoten {

int < Codeklasse ="plain"> Daten;

struct Node * next;

};


struct Node * create_node ( int data)

{

struct Node * temp

= ( struct Node *)

malloc ( sizeof ( struct Knoten));

temp- > Daten = Daten;

temp- > weiter = NULL;


return temp;

}


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

{

struct Node * new_node = create_node (data);


new_node- > next = * Kopf;

* head = new_node;

}


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

{

if (* Kopf == NULL) {

b_insert (Kopf, Daten);

return ;

}


struct Node * new_node = create_node (data);


struct Node * temp = * head;


für ( int i = 0; i "pos - 2; ++ i)

temp = Temp- > nächste;


new_node- > next = temp- > nächste;

temp- > next = new_node;

}


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

{

if (* head == NULL) {

b_insert (head, data);

return ;

}


struct Node * temp = * head;


while (temp- > next! = NULL)

temp = temp- > nächste;


struct Node * new_node = create_node (data);

temp- > next = new_node;

}


void display ( struct Node * temp)

{

printf ( "Die Elemente sind:" );

while (temp! = NULL) {

printf ( "% d" , Temp- > Daten);

temp = temp- > nächste;

}

printf ( " " );

}


// ------ --------------------------
// Definitionen - ENDE
// --------------------- -----------

Kompilieren des Codes: können wir das obige Programm kompilieren:

 gcc linkedlist.c -o linkedlist

Und es funktioniert!

Die Hauptprobleme im obigen Code:
Wir sehen bereits die Hauptprobleme mit dem Programm, es ist nicht so einfach, mit dem Code zu arbeiten, weder einzeln noch in einer Gruppe.

Falls jemand mit dem obigen arbeiten möchte Programm, dann einige der vielen Probleme, mit denen diese Person konfrontiert ist:

  1. Man muss die vollständige Quelldatei durchgehen. um einige Funktionen zu verbessern oder zu verbessern.
  2. Kann nicht einfach wiederverwendet werden das Programm als Grundlage für andere Projekte.
  3. Der Code ist sehr unübersichtlich und überhaupt nicht attraktiv, was es sehr schwierig macht, durch den Code zu navigieren.

Im Falle eines Gruppenprojekts oder großer Programme erhöht der obige Ansatz garantiert die Gesamtkosten, den Energieaufwand und die Ausfallraten.

Korrekter Ansatz:

Wir sehen, dass diese Zeilen in jedem C/C++-Programm beginnen, das mit "#include" beginnt.
Das bedeutet zu enthalten alle Funktionen, die im "library"-Header deklariert sind (.h-Dateien) und möglicherweise in library.c / cpp -Dateien definiert sind.

Diese Zeilen werden zur Kompilierzeit vorverarbeitet.

Wir können versuchen, eine solche Bibliothek für unsere eigenen Zwecke manuell zu erstellen.

Wichtige Dinge, die Sie beachten sollten :

  1. Die ".h"-Dateien enthalten nur Prototypdeklarationen (wie Funktionen, Strukturen) und globale Variablen.
  2. Die ".c / .cpp"-Dateien enthalten die eigentliche Implementierung (Deklarationsdefinitionen in Header-Dateien)
  3. Beachten Sie beim Kompilieren aller Quelldateien, dass mehrere Definitionen derselben Funktion, Variable usw. sind für dasselbe Projekt nicht vorhanden. (SEHR WICHTIG)
  4. Verwenden Sie statische Funktionen, um sich auf die Datei zu beschränken, in der sie deklariert sind.
  5. Verwenden Sie das Schlüsselwort extern , um Variablen zu verwenden, auf die verwiesen wird, und externe Dateien.
  6. Seien Sie bei der Verwendung von C++ vorsichtig mit Namensräumen, verwenden Sie immer namespace_name:: function (), um Kollisionen zu vermeiden.

    7. Durch Aufteilen des Programms in kleinere Codes:
    Nachdem wir das obige Programm untersucht haben, können wir sehen, wie dieses große Programm in geeignete kleine Teile aufgeteilt werden kann dann leicht verarbeitet.

    Das obige Programm hat im Wesentlichen 2 Hauptfunktionen:
    1) Daten in Knoten erstellen, einfügen und speichern.
    2) Knoten anzeigen


    Auf diese Weise kann ich das Programm entsprechend aufteilen:
    1) Die Hauptdatei ist > Programmtreiber, Nice Wrapper von Insertion Modules und wo wir zusätzliche Dateien verwenden.
    2) Einfügen - > Hier liegt die eigentliche Implementierung.

    Mit den genannten wichtigen Punkten gliedert sich das Programm in:

    linkedlist.c - > Enthält Treiberprogramm
    insert.c - > Enthält Code zum Einfügen

    linkedlist.h - > Enthält die notwendigen Node-Deklarationen
    insert.h - > Enthält die notwendigen Node Insertion Declarations

    In jeder Header-Datei beginnen wir mit:

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

    Wir schreiben unsere Deklarationen zwischen #ifndef, #define und #endif, um zu verhindern, dass beim Aufruf ein und derselben Header-Datei mehrfache Deklarationen von Bezeichnern wie Datentypen, Variablen usw in einer neuen Datei, die zum selben Projekt gehört.

    Für dieses Beispielprogramm:

    insert.h - > Enthält die Deklaration des Insert-Knotens sowie die Deklaration des Knotens selbst.

    Es ist sehr wichtig, sich daran zu erinnern, dass der Compiler Deklarationen in der Header-Datei sehen kann, aber wenn Sie versuchen, Code zu schreiben, dass include die Deklaration an anderer Stelle, führt dies zu einem Fehler, da der Compiler jede .c-Datei einzeln kompiliert, bevor er mit dem Verknüpfungsschritt fortfährt. ,

    connectedlist.h - > Eine Hilfsdatei, die Node und seine Display-Deklarationen enthält, die für Dateien enthalten sein müssen, die sie verwenden.


    insert.c - > Fügen Sie eine Node-Deklaration über #include "connectedlist.h", ein, die die Deklaration sowie alle anderen in insert.h deklarierten Methodendefinitionen enthält.

    connectedlist.c - > Einfacher Wrapper, der eine Endlosschleife enthält, die den Benutzer auffordert, ganzzahlige Daten an den erforderlichen Positionen einzufügen, und der auch eine Methode enthält, die die Liste anzeigt.

    Und das Letzte, woran man denken sollte, ist das bedeutungslos Einschluss von Dateien ineinander kann zu mehreren Überschreibungen führen und führt zu einem Fehler.

    Unter Berücksichtigung des Obigen sollten Sie sorgfältig in geeignete Routinen unterteilen.

    linkedlist.h


    // connectedlist.h


    # ifndef LINKED_LIST_H
    # define LINKED_LIST_H


    struct Knoten {

    int data;

    struct Node * next;

    };


    void display ( struct Node * temp);


    # endif

    insert.h


    // insert.h


    # ifndef INSERT_H
    #define INSERT_H


    struct Node;

    struct Node * create_node ( int data);

    void b_insert ( struct Knoten ** Kopf, int data);

    void n_insert ( struct Knoten ** Kopf, int data, int pos);

    void e_insert ( struct Knoten ** Kopf, int data);


    # endif

    insert.c


    // insert.c


    # include "linkedlist.h"
    // & quot; & Quot; Daher sucht der Präprozessor
    // im aktuellen Verzeichnis und
    // später nach Standardbibliotheksdateien.


    # include "stdlib.h >


    struct Node * create_node ( int data)

    {

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

    temp- > Daten = Daten;

    temp- > weiter = NULL;


    return temp;

    }


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

    {

    struct Node * new_node = create_node (data);


    new_node- > next = * Kopf;

    * head = new_node;

    }


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

    {

    if (* Kopf == NULL) {

    b_insert (Kopf, Daten);

    return ;

    }


    struct Node * new_node = create_node (data);


    struct Node * temp = * head;


    für ( int i = 0; i "pos - 2; ++ i)

    temp = Temp- > nächste;


    new_node- > next = temp- > nächste;

    temp- > next = new_node;

    <

    Shop

    Learn programming in R: courses

    $

    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

    $

    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

    All questions

    News

    16/08/2022 TikTok has the ability to generate backgrounds using artificial intelligence 16/08/2022 Nvidia and AMD will reduce the price of their graphics cards by the end of August 16/08/2022 Google has released the mobile platform Android 13

    Wiki

    __del__

    Python OpenCV | cv2.putText () method

    __del__

    numpy.arctan2 () in Python

    __del__

    Python | os.path.realpath () method

    around

    Python OpenCV | cv2.circle () method

    cvtcolor

    Python OpenCV cv2.cvtColor () method

    Python functions

    Python - Move item to the end of the list

    Counters

    time.perf_counter () function in Python

    __dict__

    Check if one list is a subset of another in Python

    __del__

    Python os.path.join () method