Fractionnement d`un gros fichier en modules distincts en C/C++, Java et Python

| | | | | | | | | | |

Cette approche est vouée à l`échec et nécessite généralement une réécriture à partir de zéro.

Ainsi, pour résoudre ce scénario, nous pouvons essayer de diviser le problème en plusieurs sous-problèmes, puis essayer de le résoudre un par une.

Cela facilite non seulement notre tâche, mais nous permet également d`obtenir une

Maintenant la grande question est de savoir comment "casser" non pas théoriquement, mais LOGICIEL.

Nous verrons plusieurs types différents de telles unités dans des langages populaires ‚Äã‚Äãtels que C / C++, Python et Java.

C / C++

À des fins d`illustration,

Supposons que nous avons tous les inserts de listes chaînées de base dans un seul programme. Puisqu`il existe de nombreuses méthodes (fonctions), nous ne pouvons pas encombrer le programme en écrivant toutes les définitions de méthodes au-dessus de la fonction principale requise. Mais même si nous le faisions, il pourrait y avoir un problème d`ordre des méthodes, lorsqu`une méthode devrait être avant une autre, et ainsi de suite.

Donc, pour résoudre ce problème, nous pouvons déclarer tous les prototypes au début de le programme, puis la méthode principale et ci-dessous que nous pouvons les définir dans n`importe quel ordre :

Programme :

FullLinkedList.c


// insère une liste chaînée complète


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


// ------------ -------------- ------
// Annonces - DÉBUT :
// ------ --------------------------


struct Nœud ;

struct Node * create_node ( int données);

void b_insert ( struct Nœud ** tête, int data);

void n_insert ( struct Nœud ** tête, int données, int pos);

void e_insert ( struct Nœud ** tête, int data);

void display ( struct Node * temp);


// ------------ -------------- ------
// Annonces - FIN :
// ------ --------------------------


int principal ()

{

struct Node * head = NULL;


int ch, data, pos ;


printf ( " Liste chaînée : "  );

tandis que (1) {

printf ( "1.Insérer au début"  );

printf ( "2.Insert à la nième position" );

printf ( "3.Insert À la fin" );

printf ( "4.Afficher " );

printf ( "0.Exit " );

printf ( "Entrez votre choix :" );

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


basculer (ch) {

case 1 :

printf ( "Entrez le données :" );

scanf ( "% d" , & amp; données);

b_insert (& amp; tête, données);

break  ;


case 2 :

printf ( "Entrez le données :" );

scanf ( "% d" , & amp; données);


printf ( " Saisissez la position : "  );

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

n_insert (& amp; tête, données, pos);

break  ;


case 3 :

printf ( "Entrez le données :" );

scanf ( "% d" , & amp; données);

e_insert (& amp; tête, données);

break  ;


case 4 :

display (head);

break  ;


case 0 :

return 0 ;


par défaut  :

printf ( "Mauvais choix" );

}

}

}


// ---------------- ---------- ------
// Définitions - DÉBUT :
// ---- ----------------------------


struct Nœud {

int < classe de code ="plain "> données ;

struct Node * next ;

} ;


struct Node * create_node ( entier données)

{

struct Node * temp

= ( struct Node *)

malloc ( sizeof ( struct Noeud));

temp- > données = données ;

temp- > suivant = NULL ;


return temp;

}


vide b_insert ( struct Nœud ** tête, int données)

{

struct Node * new_node = create_node (data);


new_node- > suivant = * tête ;

* head = new_node;

}


vide n_insert ( struct Nœud ** tête, int données, int pos)

{

si (* head == NULL) {

b_insert (head, data);

return  ;

}


struct Node * new_node = create_node (data);


struct Node * temp = * head ;


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

temp = temp- > suivant;


new_node- > suivant = temp- > suivant;

temp- > suivant = nouveau_nœud ;

}


vide e_insert ( struct Nœud ** tête, int données)

{

if (* head == NULL)

b_insert (tête, données);

return  ;

}


struct Node * temp = * head ;


tandis que (temp- > suivant ! = NULL)

temp = temp- > suivant;


struct Node * new_node = create_node (data);

temp- > suivant = nouveau_nœud ;

}


vide display ( struct Node * temp)

{

printf ( "Les éléments sont :" );

tandis que (temp ! = NULL)

printf ( "% d" , temp-> données);

temp = temp- > suivant;

}

printf ( " " );

}


// ------ --------------------------
// Définitions - FIN
// --------------------- -----------

Compilation du code : nous pouvons compiler le programme ci-dessus :

 gcc linkedlist.c -o linkedlist 

Et ça marche !

Les principaux problèmes dans le code ci-dessus :
Nous pouvons déjà voir les principaux problèmes avec le programme, il n`est pas si facile de travailler avec le code individuellement ou en groupe.

Si quelqu`un veut travailler avec ce qui précède programme, puis quelques-uns des nombreux problèmes auxquels cette personne est confrontée :

  1. Il faut passer par le fichier source complet. pour améliorer ou améliorer certaines fonctionnalités.
  2. Ne peut pas être facilement réutilisé le programme comme base pour d`autres projets.
  3. Le code est très encombré et n`est pas du tout attrayant, ce qui rend très difficile la navigation dans le code.

Dans le cas d`un projet de groupe ou de grands programmes, l`approche ci-dessus est garantie d`augmenter les coûts globaux, l`énergie et les taux d`échec.

Approche correcte :

Nous voyons que ces lignes commencent dans chaque programme C/C++ qui commence par "#include".
Cela signifie inclure toutes les fonctions déclarées dans l`en-tête "library" (fichiers .h) et définies éventuellement dans les fichiers library.c / cpp .

Ces lignes sont prétraitées au moment de la compilation.

Nous pouvons manuellement essayer de créer une telle bibliothèque pour nos propres besoins.

Éléments importants à retenir :

  1. Les fichiers ".h" ne contiennent que des déclarations prototypes (telles que des fonctions, des structures) et des variables globales.
  2. Les fichiers ".c / .cpp" contiennent l`implémentation réelle (définitions de déclaration dans les fichiers d`en-tête)
  3. Lors de la compilation de tous les fichiers source, assurez-vous que plusieurs définitions de la même fonction, variable, etc. n`existent pas pour le même projet. (TRÈS IMPORTANT)
  4. Utilisez les fonctions statiques, pour vous limiter au fichier dans lequel elles sont déclarées.
  5. Utilisez le mot-clé extern pour utiliser des variables référencées par et des fichiers externes.
  6. Lorsque vous utilisez C++, soyez prudent avec les espaces de noms, utilisez toujours namespace_name :: function (), pour éviter les collisions.
  7. En divisant le programme en codes plus petits :
    Après avoir examiné le programme ci-dessus, nous pouvons voir comment ce grand programme peut être divisé en petites parties appropriées et puis facilement traité.

    Le programme ci-dessus a essentiellement 2 fonctions principales :
    1) Créer, insérer et enregistrer des données dans les nœuds.
    2) Afficher les nœuds


    De cette façon, je peux diviser le programme en conséquence de sorte que :
    1) Le fichier principal est > Pilote de programme, Nice Wrapper de Insertion Modules et où nous utilisons des fichiers supplémentaires.
    2) Coller - > La véritable mise en œuvre se trouve ici.

    Avec les points importants mentionnés, le programme est divisé en :

    linkedlist.c - > Contient le programme de pilote
    insert.c - > Contient du code pour l`insertion

    linkedlist.h - > Contient les déclarations de nœud nécessaires
    insert.h - > Contient les déclarations d`insertion de nœud nécessaires

    Dans chaque fichier d`en-tête, nous commençons par :

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

    La raison pour laquelle nous écrivons nos déclarations entre #ifndef, #define et #endif, est d`empêcher les déclarations multiples d`identifiants tels que les types de données, les variables, etc., lorsqu`un seul et même fichier d`en-tête est appelé dans un nouveau fichier appartenant au même projet.

    Pour cet exemple de programme :

    insert.h - > Contient la déclaration du nœud d`insertion ainsi que la déclaration du nœud lui-même.

    Il est très important de se rappeler que le compilateur peut voir les déclarations dans le fichier d`en-tête, mais si vous essayez d`écrire du code qui inclut la déclaration ailleurs, cela entraînera une erreur, car le compilateur compile chaque fichier .c individuellement avant de passer à l`étape de liaison. ,

    connectedlist.h - > Un fichier d`aide qui contient Node et ses déclarations Display qui doivent être incluses pour les fichiers qui les utilisent.


    insert.c - > Incluez une déclaration de nœud via #include "connectedlist.h", qui contient la déclaration ainsi que toutes les autres définitions de méthode déclarées dans insert.h.

    connectedlist.c - > Simple Wrapper, contenant une boucle infinie invitant l`utilisateur à insérer des données entières aux positions requises, et contenant également une méthode qui affiche la liste.

    Et la dernière chose à garder à l`esprit est que cela n`a pas de sens les fichiers d`inclusion les uns dans les autres peuvent entraîner plusieurs remplacements (s) et entraîner une erreur.

    En tenant compte de ce qui précède, vous devez soigneusement diviser en routines appropriées.

    linkedlist.h


    // connectedlist.h


    # ifndef LINKED_LIST_H
    # définir LINKED_LIST_H


    struct Nœud {

    int données ;

    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 données);

    void b_insert ( struct Nœud ** tête, int data);

    void n_insert ( struct Nœud ** tête, int données, int pos);

    void e_insert ( struct Nœud ** tête, int data);


    # endif

    insert.c


    // insert.c


    # include "linkedlist.h"
    // & quot; & quot; ainsi le préprocesseur recherche
    // le répertoire courant et
    // les fichiers de bibliothèque standard plus tard.


    # inclure "stdlib.h >


    struct Node * create_node ( entier données)

    {

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

    temp- > données = données ;

    temp- > suivant = NULL ;


    return temp;

    }


    vide b_insert ( struct Nœud ** tête, int données)

    {

    struct Node * new_node = create_node (data);


    new_node- > suivant = * tête ;

    * head = new_node;

    }


    vide n_insert ( struct Nœud ** tête, int données, int pos)

    {

    si (* head == NULL) {

    b_insert (head, data);

    return  ;

    }


    struct Node * new_node = create_node (data);


    struct Node * temp = * head ;


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

    temp = temp- > suivant;


    new_node- > suivant = temp- > suivant;

    temp- > suivant = nouveau_nœud ;

    <

    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


    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