Programmation structurée Est une méthode qui implique la création de programmes améliorés. Il sert à organiser la conception et le codage des programmes de manière à éviter la plupart des erreurs logiques et à détecter celles qui se produisent.
En utilisant un langage de haut niveau (tel que Fortran), les programmeurs pouvaient écrire des programmes de plusieurs milliers de lignes. Cependant, un langage de programmation facilement compris dans les programmes courts devient illisible (et ingérable) lorsqu'il s'agit de grands programmes. Se débarrasser de ces programmes non structurés est venu avec la création de langages de programmation structurés en 1960. Il s'agit notamment des langues Algol, Pascal et S.
La programmation structurée implique des structures de contrôle bien définies, des blocs de programme, aucune instruction GOTO, des routines autonomes qui prennent en charge la récursivité et les variables locales. L'essentiel de la programmation structurée est la possibilité de diviser un programme en ses éléments constitutifs. En utilisant une programmation structurée, le programmeur moyen peut créer et maintenir des programmes de plus de 50 000 lignes.
La programmation structurée est étroitement liée à des concepts tels que la «conception descendante» et la «programmation modulaire».
Méthode de conception descendante suppose une décomposition séquentielle de la fonction de traitement des données en éléments fonctionnels simples ("top-down").
En conséquence, un schéma hiérarchique est construit qui reflète la composition et la subordination des fonctions individuelles, ce que l'on appelle structure fonctionnelle de l'algorithme(FSA).
La structure fonctionnelle de l'algorithme d'application est développée dans l'ordre suivant:
1) les objectifs de l'automatisation du domaine et leur hiérarchie sont déterminés;
2) la composition des candidatures (tâches de traitement) est établie pour assurer la mise en œuvre des objectifs;
3) la nature de la relation entre les applications et leurs principales caractéristiques (informations pour résoudre les problèmes, temps et fréquence des solutions, etc.) est clarifiée;
4) les fonctions de traitement des données nécessaires pour résoudre les problèmes sont déterminées;
5) les fonctions de traitement sont décomposées selon la complexité structurelle requise, implémentée par la boîte à outils proposée.
Une telle structure d'application reflète la chose la plus importante - la composition et l'interconnexion des fonctions de traitement de l'information pour la mise en œuvre des applications, bien qu'elle ne révèle pas la logique de l'exécution de chaque fonction, condition ou fréquence de leurs appels.
La décomposition doit être portée strictement fonctionnel caractère, c'est-à-dire un élément FSA distinct doit décrire fonction significative complète traitement de l'information, qui suppose un certain mode de mise en œuvre au niveau logiciel.
Programmation modulaire basé sur le concept d'un module – un ensemble d'éléments fonctionnels interconnectés logiquement, conçus sous la forme de modules logiciels séparés. La programmation modulaire est abordée dans la section 7.
Programmation structuréeconsiste à obtenir le bon programme à partir de quelques structures logiques simples. Il est basé sur un théorème de structuration éprouvé, qui stipule que tout programme correct (avec une entrée, une sortie, pas de boucles et d'instructions inaccessibles) peut être écrit en utilisant uniquement les structures logiques de base suivantes:
· Linéaire (suivant);
Non linéaire (fourche);
· Cyclique (cycle ou répétition).
Ce théorème a été formulé en 1966 par Boim et Jacopini (Corrado Bohm, Guiseppe Jacopini). L'idée principale du théorème est de transformer chaque partie du programme en l'une des trois structures de base, ou une combinaison de celles-ci, de sorte que la partie non structurée du programme soit réduite. Après un nombre suffisant de telles transformations, la partie non structurée restante disparaîtra ou deviendra inutile. Le théorème prouve que le résultat est un programme équivalent à celui d'origine et n'utilisant que les structures de base mentionnées ci-dessus.
Les combinaisons de programmes corrects obtenues en utilisant ces trois structures de base sont également des programmes corrects. En itérant et en imbriquant des structures de base, vous pouvez obtenir un programme de toute taille et complexité. Lorsque vous n'utilisez que les structures spécifiées, il n'y a pas besoin de sauts et d'étiquettes inconditionnels. Par conséquent, le codage parfois structuré est compris dans un sens étroit comme une programmation sans "GOTO".
Dans le langage algorithmique C (C ++), les opérateurs suivants sont utilisés pour implémenter le codage structuré:
· Opérateur composé;
· Expression d'opérateur;
· Choix de l'opérateur;
· Opérateur avec étiquette;
· Transition d'opérateur;
· Opérateur-itération;
Asm-opérateur;
· Déclaration (uniquement en C ++).
Suivre la structure(Fig.5.1, a) est implémentée par un opérateur composé, un opérateur d'expression, un opérateur asm, etc.
Opérateur composé, ou block, est une liste d'instructions (éventuellement vides) entre accolades {…} ... Syntaxiquement, un bloc est traité comme une seule instruction, mais cela affecte le contexte identifiants qui y sont déclarés. Les blocs peuvent être imbriqués à n'importe quelle profondeur.
Opérateur d'expression est une expression suivie d'un point-virgule. Son format est le suivant:
<выражение>;
Le compilateur C ++ exécute des instructions d'expression en évaluant des expressions. Tous les effets secondaires de ce calcul sont terminés avant que l'instruction suivante ne soit exécutée. La plupart des instructions d'expression sont soit des instructions d'affectation, soit des appels de fonction (par exemple, printf (), scanf ()). Un cas particulier est opérateur vide, composé d'un point-virgule ( ; ). Une instruction vide n'effectue aucune action. Cependant, il est utile dans les cas où la syntaxe C ++ attend un opérateur, mais le programme n'en a pas besoin (par exemple, une boucle for infinie).
Opérateurs ASM fournir une programmation au niveau de l'assemblage (à l'aide de pointeurs, d'opérations au niveau du bit, d'opérations de décalage, etc.). En utilisant le langage assembleur pour gérer les situations critiques et les opérations répétitives, vous pouvez accélérer l'optimisation sans aucune amélioration de langage de haut niveau.
Structure de la fourche (Fig. 5.1, b, c) est implémentée par des opérateurs de sélection. Opérateurs de sélection , ou des instructions de contrôle de flux, effectuent une sélection de l'une des branches alternatives du programme, en vérifiant certaines valeurs pour cela. Il existe deux types d'instructions select: if ... else et switch.
Opérateur de base si(Figure 5.1, b) a le format suivant:
if (expression_conditionnelle) operator_if_ "true"
Le langage C ++, contrairement, par exemple, au langage Pascal n'a pas de type de données booléen spécial. Dans les vérifications conditionnelles, ce type peut être joué par une variable entière ou un pointeur vers un type. L'expression_conditionnelle doit être écrite entre parenthèses. Cette expression est évaluée. S'il est nul (ou vide dans le cas d'un type pointeur), on dit que l'expression_conditionnelle faussement(faux ) ; sinon ça en vérité(vrai).
Si la clause else est absente et que l'expression conditionnelle est évaluée à "vrai", alors l'instruction_if_ "vrai" est exécutée; sinon, il est ignoré.
Si une phrase est donnée
Les conversions de pointeur sont effectuées de telle manière que la valeur d'un pointeur puisse toujours être correctement comparée à une expression de type constant donnant 0. Ainsi, la comparaison pour les pointeurs nuls peut être effectuée comme suit:
si (! ptr) ... ou si (ptr \u003d \u003d 0) ....
Operator_if_ "false" et operator_if_ "true" eux-mêmes peuvent être des opérateurs if, ce qui vous permet d'organiser n'importe quelle profondeur d'imbrication des vérifications conditionnelles. Lorsque vous utilisez des instructions if ... else imbriquées, veillez à bon choix opérateurs exécutables. Toute ambiguïté dans la construction "else" est résolue en comparant else avec la dernière trouvée au niveau de this if block without else.
Par exemple, l'entrée:
si (x \u003d\u003d 1)
if (y \u003d\u003d 1) met ("x \u003d 1 et y \u003d 1");
else met ("x! \u003d 1");
donne la mauvaise solution, car else, quel que soit le style d'écriture, ne correspond pas au premier, mais au second if. Par conséquent, l'enregistrement correct de la dernière ligne devrait être comme ceci:
else met ("x \u003d 1 et y! \u003d 1");
Cependant, en utilisant des accolades, vous pouvez également implémenter la première construction:
si (x \u003d \u003d 1)
if (y \u003d \u003d 1) met ("x \u003d et y \u003d 1");
else met ("x! \u003d 1"); // solution correcte
Instruction Switch (voir Figure 5.1, c) utilise le format de base suivant:
commutateur (switch_expression) case_operator;
Il permet de passer le contrôle à l'une des nombreuses instructions étiquetées casse en fonction de la valeur de switch_expression. Toute instruction dans une instruction case_ (y compris une instruction vide) peut être marquée avec une (ou plusieurs) étiquettes de variante:
casexpression_constante_i : case_operator_i;
où chaque constante_expression_i doit avoir une valeur entière unique (convertible en type de switch_expression) dans l'instruction switch englobante.
Il est permis d'avoir des constantes de cas répétées dans une instruction switch.
Une instruction peut également avoir au plus une étiquette par défaut:
par défaut: default_operator;
Une fois que l'expression_interrupteur a été évaluée, le résultat est comparé à l'une des expression_constante_i. Si une correspondance est trouvée, alors le contrôle est passé à case_operator_i avec l'étiquette pour laquelle la correspondance a été trouvée. Si aucune correspondance n'est trouvée et qu'il existe une étiquette par défaut, le contrôle est transféré à l'opérateur default_operator. Si aucune correspondance n'est trouvée et qu'il n'y a pas d'étiquette par défaut, aucune instruction n'est exécutée. Pour arrêter l'exécution d'un groupe d'instructions pour un cas particulier, utilisez l'instruction break.
Programmation structurée
La pratique de la programmation a montré la nécessité d'une méthodologie scientifiquement fondée pour le développement et la documentation d'algorithmes et de programmes. Cette méthodologie doit concerner l'analyse du problème d'origine, le diviser en parties assez indépendantes et programmer ces parties aussi indépendamment les unes des autres que possible. Cette méthodologie, née au début des années 70 et s'est récemment généralisée, est programmation structurée.À la base, il incarne les principes d'une approche systémique dans le processus de création et de fonctionnement. logiciel ORDINATEUR.
A toutes les étapes de préparation à l'algorithmisation du problème, la représentation structurelle de l'algorithme est largement utilisée.
Cprogrammation structurelle incarne les principes d'une approche systématique dans le processus de création et d'exploitation de logiciels informatiques. La programmation structurée est basée sur les dispositions assez simples suivantes:
l'algorithme et le programme doivent être élaborés par étapes (étape par étape).
une tâche complexe doit être décomposée en parties assez simples, chacune ayant une entrée et une sortie.
la logique de l'algorithme et du programme doit être basée sur le nombre minimum de structures de contrôle de base suffisamment simples .
La programmation structurée est parfois appelée «programmation sans GO TO». Il est recommandé d'éviter d'utiliser l'opérateur de saut dans la mesure du possible, mais cela ne conduit pas à des programmes structurés trop encombrants.
Des cas utiles d'utilisation de l'opérateur de saut incluent la sortie d'une boucle ou d'une procédure par une condition spéciale qui "à l'avance" met fin au travail de ce cycle ou de cette procédure, c'est-à-dire terminer le travail d'une unité structurelle (opérateur généralisé) et ne violer ainsi que localement la structuration du programme.
Le fondement de la programmation structurée est théorème structurant... Ce théorème établit que, quelle que soit la complexité de la tâche, le schéma du programme correspondant peut toujours être représenté en utilisant un nombre limité de structures de contrôle élémentaires. Les structures élémentaires de base sont des structures: suivant, branchement et répétition (boucle), tout algorithme peut être implémenté comme une composition de ces trois structures.
La première ( et) structure - séquence de type (ou juste séquence), la seconde ( b) - structure de sélection (ramification), troisième ( dans) - la structure d'une boucle avec une précondition.
Lorsque l'algorithme est écrit verbalement, ces structures ont respectivement la signification suivante:
"Exécuter 
; exécuter 
»,
si un 
puis exécutez 
, sinon exécutez 
»,
"jusqu'à ce que 
, effectuer 
»,
où 
- état; 
,
,
- Actions.
En ce qui concerne le langage Pascal, dans lequel les idées de programmation structurée sont le plus pleinement reflétées, il est conseillé d'utiliser quatre structures élémentaires supplémentaires dans la conception des algorithmes: une notation abrégée pour le branchement (Fig.16, 
); la structure de la variante (fig.16, 
); structure de répétition ou de cycle avec un paramètre (Fig.16, 
); la structure d'une boucle avec une post-condition (Fig.6, 
). Chacune de ces structures a une entrée et une sortie.
Ramification (branchement) est un processus de calcul dans lequel l'un des calculs possibles est sélectionné en fonction de la vérification des conditions spécifiées.
En fonction du type et du nombre de conditions vérifiées, on distingue:
Branchement avec condition simple (la condition est l'expression d'une relation);
Ramification avec une condition composée (la condition est une expression booléenne);
Ramification complexe (plusieurs conditions).
La variante de calcul déterminée à la suite de la vérification de la condition est appelée branche.
Cycliqueappelé le processus plusieurs répétition d'une partie des calculs lors du changement d'au moins un des quantités qu'il contient.
La section répétée du calcul est appelée cycle... Les opérations effectuées dans le cycle sont corps de boucle.
Une quantité qui change sa valeur d'un cycle à l'autre est appelée paramètre de boucle.
La dépendance liant les valeurs actuelles et précédentes du paramètre de boucle détermine la loi de variation du paramètre de cycle. La dépendance, prescrivant la répétition du cycle, ou en sortir, est appelée la condition pour répéter le cycle.
Un passage complet à cycle unique du début à la fin est appelé itération.
Tous les processus cycliques sur la base de la détermination du nombre de répétitions (M) sont divisés en deux classes.
Arithmétiqueappelé processus cyclique, le nombre de répétitions dans lequel peut être déterminé à l'avance, c.-à-d. ne dépend pas des résultats du comptage dans le corps de la boucle.
Itératifest un processus cyclique, dont le nombre de répétitions dépend des résultats des calculs dans le corps de la boucle et ne peut être déterminé à l'avance.
Quelle que soit la classe à laquelle appartient le processus de calcul, chacun d'eux contient les éléments requis:
entrer le cycle (formant la valeur initiale du paramètre de cycle);
calculs dans le corps du cycle (calcul de la valeur actuelle des fonctions, formation d'une nouvelle valeur du paramètre de cycle, ainsi que opérations auxiliaires);
sortie de la boucle (vérification de la condition qui détermine la répétition des calculs, ou leur terminaison).
Selon le type de réglage (modification) du paramètre de cycle, les cycles arithmétiques sont divisés en:
cycles avec changement de paramètre analytique;
boucles avec table de réglage du paramètre.
Effectuer des boucles arithmétiques, c'est-à-dire le calcul multiple des valeurs d'une fonction avec des valeurs variables de l'argument est appelé fonction tabulée.
Distribué deux méthodes (stratégies) d'élaboration de programmesliés à la programmation structurée:
- programmation "de haut en bas";
- programmation de bas en haut.
La programmation descendante, ou programmation descendante, est une technique de programmation dans laquelle le développement commence par définir les objectifs de résolution d'un problème, suivi par des détails séquentiels, se terminant par un programme détaillé.
Cette approche est pratique en ce qu'elle permet à une personne de penser constamment au niveau du sujet, sans s'arrêter à des opérateurs et des variables spécifiques. De plus, il devient possible de ne pas implémenter certains sous-programmes immédiatement, mais de reporter temporairement jusqu'à ce que d'autres parties soient terminées.
La programmation ascendante, ou programmation ascendante, est une technique de développement de programme qui commence par le développement de sous-programmes (procédures, fonctions), à un moment où le développement du schéma général n'est pas terminé.
Cette technique est moins préférable que la programmation descendante, car elle conduit souvent à des résultats indésirables, à des retouches et à une augmentation du temps de développement.
Il existe deux types de sous-programmes: les procédures et les fonctions. La procédure exécute simplement un groupe d'instructions, et la fonction calcule également une valeur et la renvoie au programme principal. Cette valeur est d'un type spécifique. Les données sont transmises au sous-programme sous forme de paramètres ou d'arguments, qui sont généralement décrits dans son en-tête de la même manière que les variables. Les sous-programmes sont généralement appelés en écrivant simplement leurs noms avec les paramètres requis.
Les sous-programmes peuvent être imbriqués - les sous-programmes peuvent être appelés non seulement à partir des programmes principaux, mais également à partir de tout autre programme.
Dans certains langages de programmation, il est permis d'appeler un sous-programme à partir de lui-même. Cette technique est appelée récursivité et est dangereuse en ce qu'elle peut conduire à une boucle sans fin - un auto-appel sans fin.
Les avantages de la programmation structurée:
- la fiabilité des programmes augmente (grâce à une bonne structuration lors de la conception, le programme est facile à tester et ne crée pas de problèmes lors du débogage);
- l'efficacité des programmes augmente (la structuration du programme facilite la recherche et la correction des erreurs, et les sous-programmes individuels peuvent être modifiés (modifiés) indépendamment des autres);
- le temps et les coûts diminuent développement de logiciels;
- la lisibilité des programmes est améliorée.
Préprogrammation de la tâche
Sur un ordinateur, des tâches de nature différente peuvent être résolues, par exemple: scientifique et technique; développement de logiciels système; apprentissage; gestion des processus de production, etc. Dans le processus de préparation et de résolution de problèmes scientifiques et techniques sur un ordinateur, les étapes suivantes peuvent être distinguées:
1. énoncé du problème;
2. formation modèle mathématique Tâches;
3. choix et justification de la méthode de solution;
4. algorithmisation du processus de calcul;
5. programmation;
6. débogage et test du programme;
7. résoudre le problème sur un ordinateur et analyser les résultats;
8. maintenance du programme.
Dans les problèmes d'une autre classe, certaines étapes peuvent être absentes, par exemple, dans les problèmes de développement d'un logiciel système, il n'y a pas de description mathématique. Ces étapes sont liées les unes aux autres. Pour réduire le nombre de ces changements, il est nécessaire à chaque étape, si possible, de prendre en compte les exigences des étapes ultérieures.
L'énoncé du problème est une étape de formulation verbale qui détermine le but de la solution, les données initiales, les modèles de base, les conditions et les restrictions sur l'utilisation de ces modèles. La nature et l'essence de toutes les grandeurs utilisées dans le problème sont analysées et les conditions dans lesquelles il est résolu sont déterminées.
L'énoncé du problème doit répondre aux exigences suivantes:
Un énoncé clair de l'objectif, indiquant le type et les caractéristiques des résultats finaux;
Représentation des valeurs et dimensions des données sources;
Détermination de toutes les solutions possibles, les conditions de choix de chacune;
Désignation des limites d'applicabilité et actions en cas de dépassement.
Formation d'un modèle mathématique du problème - l'étape de traduction de la formulation verbale du problème en un ensemble de dépendances mathématiques qui décrivent les données initiales et le calcul des résultats intermédiaires et finaux.
Le modèle mathématique est formé avec une certaine précision, des hypothèses et des limites. En outre, selon les spécificités du problème à résoudre, diverses sections de mathématiques et d'autres disciplines peuvent être utilisées.
Un modèle mathématique doit satisfaire au moins deux exigences: le réalisme et la réalisabilité. Le réalisme est compris comme la réflexion correcte par le modèle des caractéristiques les plus essentielles du phénomène étudié. La réalisabilité est obtenue par une abstraction raisonnable, une abstraction de détails mineurs afin de réduire le problème à un problème avec une solution connue. La condition de réalisabilité est la possibilité de réaliser concrètement les calculs nécessaires dans le temps imparti avec les coûts disponibles des ressources nécessaires.
Le modèle mathématique obtenu doit répondre aux exigences suivantes:
Tout d'abord, un modèle des données initiales est établi, puis - les dépendances calculées;
Dans le modèle de données source, les dimensions des données ne sont pas modifiées et aucune opération mathématique n'est utilisée;
Désignation de toutes les quantités comprises dans la dépendance par des noms qui définissent leur essence;
Indication des dimensions de toutes les grandeurs utilisées pour le contrôle et la modernisation ultérieure de la solution;
Le choix et la justification d'une méthode de solution est le stade de développement ou de sélection à partir de la méthode de solution existante, y compris le choix des structures standard des processus de calcul (linéaire, ramifié, cyclique). Les critères de sélection sont déterminés par le modèle mathématique de la solution (étape précédente), les exigences de polyvalence de la méthode et la précision du résultat, les limites du matériel et des logiciels. Pour justifier le choix de la méthode, il est nécessaire de prendre en compte divers facteurs et conditions, la précision des calculs, le temps de résolution du problème sur un ordinateur, la quantité de mémoire requise, etc. Les méthodes alternatives et les arguments du choix doivent être spécifiés ici.
L'algorithmisation du processus de calcul est l'étape de développement d'un ensemble de prescriptions qui déterminent de manière unique la séquence de transformation des données initiales en résultats finaux. A ce stade, un algorithme de résolution du problème est élaboré en fonction des actions données par la méthode de solution choisie. Le processus de traitement des données est divisé en blocs séparés relativement indépendants et la séquence d'exécution des blocs est établie. Un schéma de principe de l'algorithme est en cours d'élaboration.
Programmation. Lors de la compilation d'un programme, l'algorithme de résolution du problème est traduit dans un langage de programmation spécifique. Pour la programmation, des langages de haut niveau sont généralement utilisés, par conséquent le programme compilé nécessite sa traduction dans un langage machine informatique. Après une telle traduction, le programme machine correspondant est exécuté.
1. Le programme doit être universel, c'est-à-dire indépendant d'un ensemble de données spécifique. Par exemple, si la quantité de données traitées peut changer, vous devez prévoir d'en stocker autant que possible. Un programme universel doit être capable de gérer les erreurs qui peuvent survenir lors du traitement de l'information.
2. Au lieu des constantes 1, il est préférable d'utiliser les variables 2. Si des constantes sont utilisées dans le programme, alors lorsqu'elles changent, chaque instruction 3 contenant la constante précédente doit être modifiée dans le programme d'origine. Cette procédure prend du temps et est sujette à des erreurs. Le programme doit prévoir le contrôle des données saisies (en particulier, le programme ne doit pas être exécuté si les données sont en dehors de la plage autorisée).
3. Certaines techniques simples peuvent améliorer l'efficacité du programme (c'est-à-dire réduire le nombre d'opérations effectuées et la durée du programme). Ces techniques comprennent:
Utiliser la multiplication au lieu de l'exponentiation;
Si une expression arithmétique se produit plusieurs fois dans les calculs, elle doit être calculée à l'avance et stockée dans la mémoire de l'ordinateur et utilisée si nécessaire;
Lors de l'organisation des boucles, utilisez des variables comme limites d'indices 4, et non des expressions qui seraient calculées à chaque fois que la boucle est passée;
Portez une attention particulière à l'organisation des boucles, en supprimant tous les calculs répétés avec les mêmes données et en les exécutant avant d'entrer dans la boucle.
4. Le programme doit contenir des commentaires permettant de retracer facilement la relation logique et les fonctions de ses différentes parties.
Lors de l'écriture d'un programme, vous devez structurer son texte de manière à ce qu'il soit facile à lire. En particulier, le programme doit voir clairement où la boucle commence et se termine.
Le débogage d'un programme est le processus d'identification et de correction de syntaxe et d'erreurs logiques dans un programme. L'essence du débogage est qu'un certain ensemble de données initiales est sélectionné, appelé ensemble de test (test), et le problème avec cet ensemble est résolu deux fois: une fois - en exécutant le programme, la deuxième fois - d'une autre manière, en fonction de la condition du problème, pour ainsi dire , "Manuellement". Si les résultats correspondent, l'algorithme est considéré comme correct. En tant que scénario de test, vous pouvez choisir toutes les données qui vous permettent de:
Assurer la vérification de l'exécution de toutes les opérations de l'algorithme;
Réduisez le nombre de calculs au minimum.
Au cours du contrôle syntaxique du programme par le traducteur, se révèlent des constructions et combinaisons de symboles inacceptables du point de vue des règles de construction ou d'écriture adoptées dans la langue donnée. L'ordinateur envoie des messages d'erreur au programmeur, et le type et la forme d'émission de ces messages dépendent du type de langage et de la version du traducteur utilisé.
Après avoir éliminé les erreurs de syntaxe, la logique du programme est vérifiée lors de son exécution avec des données initiales spécifiques. Pour cela, des méthodes spéciales sont utilisées, par exemple, des points de contrôle sont sélectionnés dans le programme, pour lesquels les résultats intermédiaires sont calculés manuellement. Ces résultats sont comparés aux valeurs obtenues par l'ordinateur à ces points lors de l'exécution du programme en cours de débogage. En outre, pour rechercher des erreurs, des débogueurs peuvent être utilisés pour effectuer des actions spéciales au stade du débogage, par exemple, supprimer, remplacer ou insérer des instructions individuelles ou des fragments de programme entiers, afficher ou modifier les valeurs des variables spécifiées.
Le test consiste à tester, vérifier l'exactitude du programme dans son ensemble ou de ses composants.
Le débogage et les tests (test d'anglais - test) sont deux étapes clairement distinctes et dissemblables:
Pendant le débogage, les erreurs de syntaxe et les erreurs de codage évidentes sont localisées et éliminées;
Au cours du test, les performances du programme sont vérifiées, ce qui ne contient pas d'erreurs évidentes.
Le test découvre qu'il y a des erreurs et le débogage découvre pourquoi. Dans les systèmes logiciels modernes (Turbo Basic, Turbo Pascal, Turbo C, etc.), le débogage est souvent effectué à l'aide de outils logicielsappelés débogueurs. Ces outils vous permettent d'explorer le comportement interne du programme.
Un programme de débogage fournit généralement les fonctionnalités suivantes:
Exécution pas à pas du programme avec un arrêt après chaque commande (opérateur);
Affichage de la valeur actuelle de n'importe quelle variable ou recherche de la valeur de n'importe quelle expression, y compris en utilisant des fonctions standard; si nécessaire, vous pouvez définir une nouvelle valeur pour la variable;
Réglage des «points de contrôle» dans le programme, c.-à-d. points auxquels le programme arrête temporairement son exécution, afin que les résultats intermédiaires puissent être évalués, etc.
Il est important de se souvenir des points suivants lors du débogage des programmes:
Au début du processus de débogage, vous devez utiliser des données de test simples;
Les difficultés qui surviennent doivent être clairement séparées et éliminées strictement une par une;
Quel que soit le degré de débogage du programme, l'étape décisive pour déterminer son aptitude au travail est le contrôle du programme en fonction des résultats de son exécution sur le système de test.
Pour mettre en œuvre la méthode d'essai, les résultats de référence doivent être établis ou connus à l'avance. Il est impératif de calculer les résultats de référence avant et non après l'obtention des résultats machine. Dans le cas contraire, il y a un risque d'ajustement par inadvertance des valeurs calculées aux valeurs souhaitées obtenues plus tôt sur la machine.
Les données de test doivent garantir que toutes les conditions d'erreur possibles sont vérifiées:
Chaque branche de l'algorithme doit être testée;
Le prochain essai devrait contrôler ce qui n'a pas encore été testé dans les exécutions précédentes;
Le premier test doit être aussi simple que possible pour vérifier si le programme fonctionne du tout;
Les opérations arithmétiques dans les tests doivent être extrêmement simplifiées pour réduire la quantité de calcul;
Le nombre d'éléments des séquences, la précision des calculs itératifs, le nombre de passes de boucle dans les cas de test doivent être spécifiés afin de réduire la quantité de calculs;
La minimisation des calculs ne doit pas réduire la fiabilité du contrôle;
Les tests doivent être ciblés et systématiques, car une sélection aléatoire des données d'entrée entraînerait des difficultés pour déterminer manuellement les résultats attendus; en outre, avec une sélection aléatoire des données de test, de nombreuses situations peuvent ne pas être testées;
La complication des données d'essai doit être graduelle.
Le processus de test peut être divisé en trois étapes.
1. Vérification dans des conditions normales. Suppose des tests basés sur des données caractéristiques des conditions réelles de fonctionnement du programme.
2. Vérification dans des conditions extrêmes. Les données de test incluent les valeurs limites de la plage des variables d'entrée, qui doivent être perçues par le programme comme des données valides. Des exemples typiques de telles valeurs sont des nombres très petits ou très grands et aucune donnée. Les marges de données sont un autre type de condition extrême, où les tableaux sont constitués de trop peu ou trop d'éléments.
3. Vérifiez les situations exceptionnelles. Elle est effectuée à l'aide de données dont les valeurs se situent en dehors de la plage de modifications autorisée. On sait que tous les programmes sont développés dans l'espoir de traiter un ensemble limité de données. Par conséquent, il est important d'obtenir une réponse aux questions suivantes:
Que se passe-t-il si un programme qui n'est pas conçu pour gérer des valeurs négatives et nulles de variables, à la suite d'une erreur, doit traiter uniquement de telles données?
Comment un programme fonctionnant avec des tableaux se comportera-t-il si le nombre de leurs éléments dépasse la valeur spécifiée dans la déclaration du tableau?
Que se passe-t-il si les nombres sont trop petits ou trop grands?
La pire situation est lorsque le programme interprète les mauvaises données comme correctes et produit un résultat incorrect mais plausible.
Le programme doit lui-même rejeter toutes les données qu'il ne peut pas traiter correctement.
Résoudre le problème sur un ordinateur et analyser les résultats. Après avoir débogué le programme, il peut être utilisé pour résoudre un problème appliqué. Dans ce cas, une solution multiple du problème est généralement effectuée sur un ordinateur pour divers ensembles de données initiales. Les résultats obtenus sont interprétés et analysés par un spécialiste ou un utilisateur qui a défini la tâche.
Soutien au programme:
Le programme développé d'utilisation à long terme est installé sur un ordinateur, en règle générale, sous la forme d'un programme machine prêt à être exécuté. Le programme est accompagné d'une documentation, y compris des instructions pour l'utilisateur. Depuis lors de l'installation d'un programme sur un disque pour son utilisation ultérieure, en plus des fichiers avec du code exécutable, divers programmes auxiliaires sont installés (utilitaires, livres de référence, personnalisateurs, etc.), ainsi que divers fichiers nécessaires au fonctionnement de programmes avec du texte, des graphiques, du son et autres information.
Raffinement du programme pour résoudre des problèmes spécifiques;
Rédaction de la documentation pour le problème résolu, modèle mathématique, algorithme, programme pour leur utilisation.
1La constante en programmation est une manière d'adresser des données dont le changement n'est pas attendu ou interdit par le programme en question.
2 Une variable en programmation impérative est une zone mémoire nommée ou adressée d'une autre manière dont l'adresse peut être utilisée pour accéder aux données. Les données d'une variable (c'est-à-dire à une adresse mémoire donnée) sont appelées la valeur de cette variable.
Dans d'autres paradigmes de programmation, par exemple, fonctionnels et logiques, le concept de variable s'avère quelque peu différent. Dans ces langages, une variable est définie comme un nom auquel une valeur peut être associée, ou même comme un emplacement pour stocker une valeur.
3 Une instruction ou une instruction est la plus petite partie autonome d'un langage de programmation; commander. Un programme est généralement une séquence d'instructions.
De nombreux langages (par exemple, C) font la distinction entre instruction et définition. La différence est que l'instruction exécute le code et que la définition crée un identificateur (c'est-à-dire que vous pouvez considérer la définition comme une instruction d'affectation).
Voici les instructions générales de base pour les langages de programmation impératifs.
4 Un index dans les langages de programmation est un élément d'un ensemble énuméré qui pointe vers un élément spécifique d'un tableau, généralement un entier scalaire non négatif.
Les éléments du tableau peuvent être indexés de trois manières avec des entiers non négatifs:
le premier élément du tableau a l'index 0;
le premier élément du tableau a l'indice 1;
n ("index commençant à n")
l'indice de base du tableau peut être librement choisi. habituellement langages de programmationautoriser "index commençant à n" autorise également les valeurs négatives comme index de tableau, ainsi que d'autres scalaires types de donnéescomme des énumérations ou des symboles.
Un tableau peut avoir plusieurs dimensions, il est donc courant d'accéder à un tableau à l'aide de plusieurs index. Par exemple, un tableau bidimensionnel avec trois lignes et quatre colonnes pourrait être adressé à un élément de la 2ème ligne et de la 4ème colonne en utilisant l'expression: (dans la langue dans laquelle la ligne a la priorité) et (dans la langue dans laquelle la colonne a la priorité) cas avec un index de base zéro. Ainsi, deux indices sont utilisés pour tableaux à deux dimensions, trois pour un tableau à trois dimensions et n pour un tableau à n dimensions.
Langages et technologies de programmation
Les premiers programmes consistaient à régler des interrupteurs à clé à l'avant du dispositif informatique. Évidemment, seuls de petits programmes pourraient être compilés de cette manière. Avec le développement de la technologie informatique, un langage machine est apparu, à l'aide duquel un programmeur pouvait définir des instructions, fonctionnant avec des cellules de mémoire, en utilisant pleinement les capacités de la machine. Cependant, l'utilisation de la plupart des ordinateurs au niveau du langage machine est difficile, en particulier pour les E / S. Par conséquent, nous avons dû abandonner son utilisation. Par exemple, pour organiser la lecture d'un bloc de données à partir d'une disquette, le programmeur peut utiliser 16 commandes différentes, dont chacune nécessite 13 paramètres, tels que le numéro de bloc sur le disque, le numéro de secteur sur la piste, etc. Lorsque l'opération de disque est terminée, le contrôleur renvoie 23 valeurs reflétant la présence et les types d'erreurs à analyser. Les "mots" en langage machine sont appelés instructions, dont chacun représente une action élémentaire pour unité centrale de traitement, comme, par exemple, la lecture d'informations à partir d'une cellule de mémoire. Chaque modèle de processeur possède son propre jeu d'instructions machine, bien que la plupart soient identiques. Si le processeur A comprend parfaitement le langage du processeur B, alors on dit que le processeur A est compatible avec le processeur B.Le processeur B sera appelé incompatible avec le processeur A si A a des instructions qui ne sont pas reconnues par le processeur B.Dans le cas où il est nécessaire d'avoir un programme efficace au lieu de la machine les langages sont utilisés à proximité des langages orientés machine - les assembleurs. Les humains utilisent des instructions mnémotechniques au lieu des instructions de la machine.
Mais même travailler avec l'assembleur est assez compliqué et nécessite une formation spéciale. Par exemple, pour le processeur Zilog Z80, l'instruction machine 00000101 demande au processeur de diminuer son registre B de un. En langage d'assemblage, ce sera également écrit DEC B.
Programmation structurée
L'étape suivante a été franchie en 1954, lorsque le premier langage de haut niveau a été créé - Fortran (ing. FORTRAN - TRANslateur FORmula). Les langues de haut niveau imitent les langues naturelles en utilisant certains des mots de la langue parlée et des symboles mathématiques courants. Ces langages sont plus pratiques pour les humains, avec leur aide, vous pouvez écrire des programmes de plusieurs milliers de lignes. Cependant, facilement compris dans les programmes courts, ce langage est devenu illisible et difficile à gérer lorsqu'il s'agissait de grands programmes. La solution à ce problème est venue après l'invention des langages de programmation structurés (eng. langage de programmation structuré) comme Algol (1958), Pascal (1970), C (1972).
La programmation structurée implique des structures de contrôle bien définies, des blocs de programme, aucune instruction de saut (GOTO), des routines autonomes, la récursivité et le support des variables locales. L'essence de cette approche réside dans la possibilité de scinder le programme en ses éléments constitutifs. Également créé fonctionnel Langages (applicatifs) (Exemple: Lisp - eng. Traitement LISt, 1958) et casse-tête langues (exemple: Prolog - eng. Programmation dans LOGic, 1972). Bien que la programmation structurée produise des résultats exceptionnels lorsqu'elle est utilisée, elle échoue même lorsque le programme atteint une certaine longueur. L'écriture d'un programme plus complexe (et plus long) exigeait une nouvelle approche de la programmation.
En conséquence, les principes de la programmation orientée objet ont été développés à la fin des années 70 et au début des années 80. La POO combine les meilleurs principes de la programmation structurée avec de nouveaux concepts puissants, dont le cœur est appelé encapsulation, polymorphisme et héritage. Voici quelques exemples de langages orientés objet: Object Pascal, C ++, Java, etc. Un programme dans un langage orienté objet, résolvant un problème, décrit en fait la partie du monde liée à ce problème.
La programmation structurée représente la plus grande avancée dans ce domaine à ce moment... Malgré le fait que presque tout le monde concept général à son sujet, presque personne ne peut donner une définition précise et claire de ce terme. La programmation structurée fixe l'objectif principal d'écrire des programmes de la moindre complexité, obligeant le programmeur à penser clairement, rendant le programme plus facile à comprendre. Son texte doit être fait de sorte qu'il soit lisible de haut en bas. Cette condition n'est pas respectée s'il y a des instructions go to dans le code du programme, car elles violent la structure du segment de programme entier. Malgré le fait que cet indicateur ne peut pas être considéré comme le plus pratique, on peut toujours dire que la présence dans le code du programme cet opérateur est le type de trouble structurel le plus visible. Les corps des modules et les structures sous-jacentes utilisées doivent être résistants aux pannes matérielles, aux erreurs de programmes et aux distorsions des données d'origine.
Les principes de base de la programmation structurée sont les suivants. Tout programme peut être facilement synthétisé à partir de constructions élémentaires de trois types principaux:
Cohérence simple;
Conditions ou alternatives;
Répétitions, c'est-à-dire boucles et itérations.
Un ou deux de n'importe quel type peuvent être utilisés en même temps. Chaque structure a une caractéristique unique - un point unique de transfert de contrôle à la structure et un point d'entrée unique dans la structure. Ce type de construction a un sens disciplinant et systématisant.
La simplicité des constructions initiales dans la programmation structurée empêche les connexions informationnelles ainsi que les transferts de contrôle confus. La complexité des programmes est sensiblement réduite avec une augmentation de la structure des modules, leur clarté augmente, ce qui contribue à réduire le nombre d'erreurs. Cependant, la structuration présente également un inconvénient: pour la beauté et la clarté du code du programme, il faut payer avec de la mémoire supplémentaire, ainsi que le temps nécessaire à leur mise en œuvre sur un ordinateur.
La programmation structurelle, c'est-à-dire la structure des textes de programme eux-mêmes, dépend entièrement du langage utilisé pour cela. Bien sûr, la question se pose, laquelle convient le mieux. Les outils de développement logiciel modernes sont considérés comme les plus les meilleures languesmettre en œuvre une approche structurée de la programmation. Parmi les plus courants, on trouve Basic, Pascal et FoxBASE. Par exemple, il est pratiquement impossible de mettre en œuvre les principes énoncés dans le concept de programmation structurée. Ce langage se concentre sur l'écriture de code de programmation de bas niveau.
La programmation structurée est fondamentalement axée sur la communication avec les gens, pas avec les machines, elle facilite donc l'écriture de programmes qui représentent une solution claire et simple à un problème donné. Le programmeur doit penser en termes de constructions structurelles de base.
Si nous parlons de la position par rapport à l'opérateur go to mentionné précédemment, cela devrait être évité dans la mesure du possible, mais cela ne devrait en aucun cas affecter la clarté du programme. Parfois l'utilisation de cet opérateur s'avère simplement nécessaire pour sortir d'un certain segment d'un programme ou d'un cycle, ainsi que pour éviter l'apparition de fourches trop profondes, d'autant plus que la transition est associée à des niveaux de programmes inférieurs. Dans le même temps, la structure du programme reste facilement lisible de haut en bas. Le pire de l'opérateur donné est de passer de bas en haut.
Pour faciliter la lecture, les programmes ajoutent souvent des lignes vides entre les sections. Il vaut la peine d'écrire le texte du programme avec des décalages afin que vous puissiez lire la séquence d'actions et le nombre de pièces jointes.
Programmation structurelle - méthodologie de développement logiciel, qui est basée sur la présentation du programme sous la forme d'une structure hiérarchique en blocs. Proposé dans les années 1970 par E. Dijkstroy et al.
Conformément à cette méthodologie, tout programme est construit sans utiliser l'opérateur goto à partir de trois structures de contrôle de base: séquence, branche, boucle; en outre, des sous-programmes sont utilisés. Dans ce cas, le développement du programme se fait étape par étape, par la méthode "top down".
La méthodologie de programmation structurée est apparue comme une conséquence de la complexité croissante des tâches résolues sur les ordinateurs et, par conséquent, de la complication des logiciels. Dans les années 1970, le volume et la complexité des programmes ont atteint un niveau tel que le développement de logiciels traditionnels (non structurés) a cessé de répondre aux besoins de la pratique. Les programmes sont devenus trop complexes pour être entretenus correctement. Par conséquent, il était nécessaire de systématiser le processus de développement et la structure du programme.
La méthodologie de développement de logiciel structuré a été reconnue comme «la plus forte formalisation des années 70».
Selon Bertrand Meyer, «La révolution de la programmation, lancée par Dijkstroy, a conduit à un mouvement connu sous le nom de programmation structurée, qui proposait une approche systématique et rationnelle de la conception des programmes. La programmation structurée est devenue la base de tout ce qui a été fait en méthodologie de programmation, y compris la programmation objet. "
YouTube encyclopédique
1 / 5
✪ Programmation structurée. Principes de base
✪ Pascal à partir de zéro [h1]. Premier programme.
✪ Leçon 7. Opérateurs de sortie d'écriture / d'écriture. Programme simple... Programmation Pascal / Pascal
✪ Fondamentaux de la programmation - # 5 - Arithmétique et expressions logiques
✪ 003. Algorithmes logiques de classification - K.V. Vorontsov
Les sous-titres
L'histoire
Initialement, l'idée de programmation structurée est née en lien avec l'opérateur goto et des doutes sur l'opportunité de son utilisation. Heinz Zemanek a exprimé pour la première fois de tels doutes lors d'une réunion sur la langue algol au début de 1959 à Copenhague. Cependant, cette performance n'a pas attiré l'attention et n'a eu aucune conséquence. Edsger Dijkstra se souvient: "Dans une certaine mesure, je me blâme de ne pas pouvoir apprécier la signification de cette idée à l'époque."
La situation a radicalement changé dix ans plus tard, lorsque Dijkstra a publié sa célèbre lettre «Go To Statement Considered Harmful» en mars 1968. Il s'agit d'un document vraiment historique qui a eu un impact notable sur le développement ultérieur de la programmation.
Le sort du document lui-même est très intéressant. Le fait est que Dijkstra a donné à l'article un titre complètement différent: "Les arguments contre la déclaration GO TO" (Une affaire contre la déclaration GO TO).
Cependant, au moment de la publication, quelque chose d'incompréhensible s'est produit - pour une raison quelconque, l'article s'est mystérieusement transformé en "Lettre à l'éditeur", et le titre précédent a tout aussi mystérieusement disparu. Que s'est-il vraiment passé? Dijkstra n'a expliqué la mystérieuse transformation de l'article en lettre que de nombreuses années plus tard, en 2001, un an avant sa mort.
objectif
Le but de la programmation structurée est d'augmenter la productivité des programmeurs, y compris dans le développement de systèmes logiciels volumineux et complexes, de réduire le nombre d'erreurs et de simplifier le débogage, la modification et la maintenance des logiciels.
Cet objectif a été fixé en raison de la complexité croissante des programmes et de l'incapacité des développeurs et des gestionnaires de grands projets logiciels à faire face aux problèmes qui se sont posés dans les années 1960 et 1970 en relation avec le développement d'outils logiciels.
Code spaghetti
La programmation structurée est conçue, en particulier, pour éliminer l'encombrement et les erreurs dans les programmes causés par des difficultés de lecture du code, code source non systématisé qui n'est pas pratique pour la perception et l'analyse. Un tel texte est souvent décrit comme "code spaghetti".
Le code Spaghetti peut être débogué et exécuté correctement avec haute performance, mais il est extrêmement difficile à maintenir et à développer. Le raffinage du code spaghetti pour ajouter de nouvelles fonctionnalités présente parfois un potentiel important de nouveaux bogues. Pour cette raison, la refactorisation du code, le principal remède contre les spaghettis, devient presque inévitable.
Déclaration Goto
Depuis les années 1970, l'opérateur goto est au centre de critiques systématiques et croissantes. Une utilisation incorrecte et irréfléchie de l'instruction goto dans le code source d'un programme conduit à un "code spaghetti" confus et illisible. Il est presque impossible de comprendre l'ordre d'exécution et l'interdépendance des fragments à partir du texte d'un tel code.
Ce point de vue a d'abord été reflété dans l'article d'Edsger Dijkstra «L'opérateur Go To est considéré comme nuisible». Dijkstra a remarqué que la qualité d'un code de programme est inversement proportionnelle au nombre d'instructions goto qu'il contient. L'article est devenu largement connu, à la suite de quoi les opinions sur l'utilisation de l'opérateur goto ont été considérablement révisées. Dans Notes on Structured Programming, Dijkstra a confirmé le fait que pour le code sans goto, il est beaucoup plus facile de vérifier l'exactitude formelle.
Le code avec goto est difficile à formater, car il peut violer la hiérarchie d'exécution (le paradigme de la programmation structurée) et par conséquent l'indentation conçue pour refléter la structure du programme ne peut pas toujours être définie correctement. De plus, l'instruction goto interfère avec l'optimisation des structures de contrôle par les compilateurs.
Certaines utilisations de goto peuvent créer des problèmes avec la logique d'exécution du programme:
- Si une variable est initialisée (obtient une valeur) à un endroit et est ensuite utilisée plus loin, alors la transition vers un point après l'initialisation, mais avant utilisation, conduira au fait que la valeur qui était dans la mémoire allouée pour la variable avant le moment de l'allocation (et qui est généralement arbitraire et aléatoire).
- Passer le contrôle à l'intérieur du corps de la boucle entraîne le saut du code d'initialisation de la boucle ou de la vérification de la condition initiale.
- De même, le transfert de contrôle dans une procédure ou une fonction conduit à sauter sa partie initiale, dans laquelle l'initialisation est effectuée (allocation de mémoire pour les variables locales).
Les arguments contre la déclaration goto se sont avérés si forts qu'elle a été considérée comme hautement indésirable dans la programmation structurée. Cela se reflète dans la conception de nouveaux langages de programmation. Par exemple, goto est interdit en Java et Ruby. Dans un certain nombre de langues modernes, il est encore abandonné pour des raisons d'efficacité dans les rares cas où goto est justifié. Ainsi, goto a survécu à Ada, l'un des langages les plus architecturaux de l'histoire.
Cependant, dans les langages de haut niveau où cet opérateur a été préservé, des restrictions strictes sont généralement imposées à son utilisation, empêchant l'utilisation des méthodes les plus dangereuses de son utilisation: par exemple, il est interdit de transférer le contrôle de l'extérieur d'une boucle, d'une procédure ou d'une fonction à l'intérieur. Le standard du langage C ++ interdit la traversée goto de l'initialisation des variables.
Théorème de programmation structurée
Le théorème a été formulé et prouvé par les mathématiciens italiens Corrado Böhm et Giuseppe Jacopini. Ils l'ont publié en 1965 en italien et en 1966 en anglais. Parallèlement au théorème, l'article de Boehm et Yakopini décrit des méthodes de conversion d'algorithmes non structurels en algorithmes structurels en utilisant l'exemple du langage de programmation P '' créé par Boehm. Le langage P ′ ′ est le premier langage de programmation complet de Turing sans instruction goto.
Le théorème de Boehm-Jacopini est écrit dans un langage complexe et en notation inhabituelle. Si nous utilisons une terminologie et une notation modernes, cela prendra la forme:
Tout programme donné sous forme de schéma bloc peut être représenté à l'aide de trois structures de contrôle:
- séquence - indiqué par:f PUIS g,
- ramification - indiqué par:SI p ALORS f AUTRE g,
- cycle - indiqué par:PENDANT p FAIRE f,
où f, g - schémas fonctionnels avec une entrée et une sortie,
P - condition, ALORS, SI, AUTRE, PENDANT, FAIRE - mots clés.
Explication. La formule f ALORS g signifie ce qui suit: le premier programme f est exécuté, puis le programme g est exécuté.
Boehm et Jacopini n'ont pas utilisé le terme de programmation structurée. Néanmoins, le théorème qu'ils ont prouvé (et ses variations ultérieures par différents auteurs) est venu plus tard pour être appelé le "Théorème sur la programmation structurée", "Théorème de structure", "Le théorème sur la structuration".
Principes de la programmation structurée
La formation et le développement de la programmation structurée sont associés au nom d'Edsger Dijkstra.
Principe 1. Vous devez éviter d'utiliser l'opérateur goto.
Principe 2. Tout programme est construit à partir de trois structures de contrôle de base: séquence, branche, boucle.
Principe 3. Dans un programme, les structures de contrôle de base peuvent être imbriquées les unes dans les autres de manière arbitraire. Aucun autre contrôle de flux n'est fourni.
Principe 4. Les fragments de programme répétitifs peuvent être formatés comme sous-programmes (procédures et fonctions). De la même manière (sous forme de sous-programmes), vous pouvez concevoir des fragments de programme logiquement intégraux, même s'ils ne sont pas répétés.
Principe 5. Chaque groupe d'instructions logiquement complet doit être formaté en bloc. Les blocs sont le fondement de la programmation structurée.
Un bloc est un morceau de code source logiquement groupé, par exemple, un ensemble d'instructions écrites dans une ligne dans code source programmes. Concept bloquer signifie que le bloc d'instructions doit être traité comme une seule instruction. Les blocs servent à limiter la portée des variables et des fonctions. Les blocs peuvent être vides ou imbriqués les uns dans les autres. Les limites des blocs sont strictement définies. Par exemple, dans une instruction if, le bloc est limité par le code BEGIN..END (en Pascal) ou accolades (...) (en C) ou indentation (en Python).
Principe 6. Toutes les structures ci-dessus doivent avoir une entrée et une sortie.
Les constructions de contrôle arbitraires (comme dans un plat de spaghetti) peuvent avoir un nombre arbitraire d'entrées et de sorties. En nous limitant à des structures de contrôle avec une entrée et une sortie, nous sommes capables de construire des algorithmes arbitraires de toute complexité à l'aide de mécanismes simples et fiables.
Principe 7. Le développement du programme se fait étape par étape, par la méthode "top down" (méthode descendante) .
Méthode descendante
Tout d'abord, le texte du programme principal est écrit, dans lequel, au lieu de chaque fragment logique cohérent de texte, un appel à un sous-programme est inséré qui exécutera ce fragment. Au lieu de sous-programmes réels, en cours d'exécution, des parties factices sont insérées dans le programme - bouchonsqui, pour le dire simplement, ne font rien.
Plus précisément, le stub satisfait aux exigences d'interface du fragment (module) remplacé, mais ne remplit pas ses fonctions ou ne les remplit que partiellement. Ensuite, les stubs sont remplacés ou modifiés en véritables fragments entièrement fonctionnels (modules) conformément au plan de programmation. À chaque étape du processus de mise en œuvre, le programme déjà créé doit fonctionner correctement par rapport au niveau inférieur. Le programme résultant est vérifié et débogué.
Il convient également de noter que dans la préface à la programmation structurée, Tony Hoare note que les principes de programmation structurée peuvent être appliqués de la même manière à la programmation descendante et ascendante.
Sous-programme
Un sous-programme est un élément essentiel de la programmation structurée. Au départ, les sous-programmes apparaissaient comme un moyen d'optimiser les programmes en termes de quantité de mémoire occupée - ils permettaient de ne pas répéter des blocs de code identiques dans un programme, mais de les décrire une fois et de les appeler au besoin. Maintenant cette fonction les sous-programmes sont devenus auxiliaires, leur objectif principal est de structurer le programme pour faciliter sa compréhension et sa maintenance.
Attribuer un ensemble d'actions à un sous-programme et l'appeler si nécessaire vous permet de sélectionner logiquement une sous-tâche intégrale qui a solution typique... Cette action présente un autre avantage (en plus d'économiser de la mémoire) par rapport à la répétition d'actions du même type. Tout changement (correction de bogue, optimisation, extension des fonctionnalités) effectué dans un sous-programme est automatiquement reflété dans tous ses appels, alors qu'en cas de duplication, chaque changement doit être effectué à chaque occurrence du code modifié.
Même dans les cas où un seul ensemble d'actions effectuées est alloué à un sous-programme, cela se justifie, car cela permet de réduire la taille des blocs intégraux de code qui composent le programme, c'est-à-dire de rendre le programme plus compréhensible et visible.
Les avantages de la programmation structurée
Suivre les principes de la programmation structurée a rendu les textes des programmes, même assez volumineux, normalement lisibles. La compréhension des programmes est devenue beaucoup plus facile, il est devenu possible de développer des programmes dans un mode industriel normal, lorsque le programme peut être facilement compris non seulement par son auteur, mais aussi par d'autres programmeurs. Cela a permis de développer des systèmes logiciels, suffisamment volumineux pour l'époque, grâce aux efforts des équipes de développement, et d'accompagner ces complexes pendant de nombreuses années, même dans des conditions de mutations inévitables du personnel.
- La programmation structurée vous permet de réduire considérablement le nombre d'options pour construire un programme selon la même spécification, ce qui réduit considérablement la complexité du programme et, plus important encore, facilite sa compréhension pour les autres développeurs.
- Dans les programmes structurés, les opérateurs logiquement connectés sont visuellement plus proches et les opérateurs faiblement connectés sont plus éloignés, ce qui permet de se passer de schémas de principe et d'autres formes graphiques d'algorithmes d'affichage (en fait, le programme lui-même est son propre schéma de principe).
- Le test et le débogage des programmes structurés sont grandement simplifiés.
Clarté et lisibilité des programmes
La programmation structurée améliore considérablement la clarté et la lisibilité des programmes. Edward Yourdon explique:
Le comportement de nombreux programmes non structurels est souvent plus proche du mouvement brownien que de tout processus organisé. Toute tentative de lecture de la liste conduit une personne à désespérer que dans un tel programme plusieurs instructions sont généralement exécutées, après quoi le contrôle est transféré à un point situé plusieurs pages ci-dessous. Là, plusieurs autres opérateurs sont exécutés et le contrôle est à nouveau transféré vers un point aléatoire. Ici, d'autres opérateurs sont exécutés, etc. Après plusieurs programmes de ce type, le lecteur oublie comment tout a commencé. Et perd le fil de la pensée.
Les programmes structurels, en revanche, ont tendance à être systématiquement organisés et exécutés.
L'amélioration de la lisibilité des programmes structurés s'explique par le fait que l'absence d'instruction goto permet au programme d'être lu de haut en bas sans interruption provoquée par les transferts de contrôle. En conséquence, vous pouvez immédiatement (d'un coup d'œil) découvrir les conditions nécessaires pour modifier un fragment de programme particulier.
Programmation structurée bidimensionnelle
La technologie P de production de programmes, ou "technologie de programmation bidimensionnelle" a été créée en. Le système graphique de la technologie de programmation R est fixé dans les normes GOST 19.005-85, GOST R ISO / IEC 8631-94 et la norme internationale ISO 8631N.
L'auteur de la technologie R de la programmation, docteur en sciences physiques et mathématiques, le professeur Igor Velbitsky a proposé de réviser le concept même de «structure du programme». À son avis, «la structure est un concept multidimensionnel. Par conséquent, la cartographie de ce concept à l'aide de textes linéaires (séquences d'opérateurs) annule pratiquement les avantages de l'approche structurée. Les énormes capacités associatives de l'appareil visuel et de l'appareil de la pensée humaine sont utilisées pratiquement en vain - pour la reconnaissance d'images structurelles sous la forme d'une séquence uniforme de symboles. "
La méthodologie de la programmation structurée bidimensionnelle diffère considérablement de la programmation structurée unidimensionnelle (textuelle) classique.
Les idées de programmation structurée ont été développées alors que l'infographie n'existait pas encore et que le principal outil de l'algorithmiste et du programmeur était le texte unidimensionnel (linéaire ou échelonné). Avant l'apparition infographie la méthodologie de la programmation structurée classique était le meilleur décision.
Avec l'avènement de l'infographie, la situation a changé. En utilisant des moyens expressifs de graphiques, il est devenu possible de modifier, de développer et de compléter trois types de structures structurelles de contrôle de base (texte), ainsi que d'abandonner complètement les mots-clés, puis, sinon, cas, interrupteur, pause, tandis que, faire, répéter, jusqu'à ce que, pour, foreach, continuer, boucler, quitter, quand, dernier, etc. et les remplacer par des graphiques de contrôle, c'est-à-dire utiliser une programmation structurée bidimensionnelle.
Un problème important est la complexité de la programmation moderne et la recherche de moyens de la surmonter. Selon le candidat sciences techniques, Professeur associé Evgeny Pyshkin, l'étude de la programmation structurée uniquement comme un outil pour développer des textes de programme basés sur la «triade structurelle» de base (séquence linéaire, branchement et boucle) est insuffisante et, en fait, nie l'analyse des avantages de l'approche structurée. Dans le processus de dépassement de la complexité essentielle des logiciels, l'outil le plus important est la visualisation de la conception et de la programmation.
voir également
Remarques
- Meyer B. Ressentez la classe. Apprenez à bien programmer avec des objets et des contrats. - Per. de l'anglais - M.: Université Nationale Ouverte INTUIT: BINOM. Laboratoire de connaissances, 2011. - 775p. - S. 208 .-- ISBN 978-5-9963-0573-5
- E. Dijkstra. La déclaration goto est considérée comme nuisible
- Dijkstra E. Aller à la déclaration considérée comme préjudiciable // Communications de l'ACM, Volume 11, No. 3, mars 1968, p. 147-148. - Association for Computing Machinery, Inc.
- Voir également les documents des archives de Dijkstra. Archives E. W. Dijkstra. Les manuscrits de Edsger W. Dijkstra. - Département d'informatique de l'Université du Texas à Austin
- Manuscrit EWD1308 des archives de Dijkstra.
- Transcription du manuscrit EWD1308 des archives de Dijkstra. Ce qui a conduit aux "Notes sur la programmation structurée" - Nuenen, 10 juin 2001. - Département d'informatique. Université du Texas à Austin, États-Unis
- Linger R., Mills H., Witt B. Théorie et pratique de la programmation structurée. - Per. de l'anglais - M .: Mir, 1982 .-- 406s. - S. 7.
- John Vlissides, Kyle Brown, Gérard Meszaros AntiPatterns: Le guide de survie. ...
