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

Michael Zippo

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.

Passer à C / C++
< a href = # Python> Passer à Python
Passer à 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 :
Il faut passer par le fichier source complet. pour améliorer ou améliorer certaines fonctionnalités.
Ne peut pas être facilement réutilisé le programme comme base pour d`autres projets.
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 :
Les fichiers ".h" ne contiennent que des déclarations prototypes (telles que des fonctions, des structures) et des variables globales.
Les fichiers ".c / .cpp" contiennent l`implémentation réelle (définitions de déclaration dans les fichiers d`en-tête)
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)

Utilisez les fonctions statiques, pour vous limiter au fichier dans lequel elles sont déclarées.
Utilisez le mot-clé extern pour utiliser des variables référencées par et des fichiers externes.
Lorsque vous utilisez C++, soyez prudent avec les espaces de noms, utilisez toujours namespace_name :: function (), pour éviter les collisions.

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

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

© 2017—2022
Python Engineering Hub

EN | ES | DE | FR | IT | RU | TR | PL | PT | JP | KR | CN | HI | NL

Python.Engineering is a participant in the Amazon Services LLC Associates Program, an affiliate advertising program designed to provide a means for sites to earn advertising fees by advertising and linking to amazon.com

Python

Loops

Counters

NumPy

NLP

Regular Expressions

Wiki

Tech news

Python Wiki

StackOverflow

PHP

JavaScript

Books

All books

Computations

Development

Cryptography

For dummies

Big Data

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

Passer à C / C++

< a href = # Python> Passer à Python

Passer à Java

C / C++

Shop

News

Wiki