Le développement de modèles abstraits pour les données et les méthodes de traitement Ces données sont le composant le plus important du processus de résolution de tâches à l'aide d'un ordinateur. Des exemples de ceux-ci que nous voyons et à un niveau bas dans la programmation quotidienne (par exemple, lorsque vous utilisez des tableaux et des listes connectées considérées c), et à un niveau élevé lors de la résolution des tâches appliquées (comme lors de la résolution d'un problème de connexion avec l'aide d'une union forestière. -Search dans "Introduction"). Dans cette conférence, des types de données abstraits sont pris en compte (type de données abstraites, à l'avenir ATD), vous permettant de créer des programmes utilisant des abstractions de haut niveau. Les types de données abstraits vous permettent de séparer les transformations abstraites (conceptuelles) que les programmes sont effectués sur les données, à partir de toute représentation spécifique de la structure de données et de tout mise en œuvre spécifique Algorithme.
Tout systèmes informatiques Basé sur des niveaux d'abstraction: certaines propriétés physiques du silicium et d'autres matériaux vous permettent de prendre un modèle de bits abstrait qui peut prendre des valeurs binaires 0-1; Ensuite, le modèle abstrait de la machine est construit sur les propriétés dynamiques des valeurs d'un jeu de bits spécifique; En outre, sur la base du principe de fonctionnement de la machine exécutant le programme sur language de machine Un modèle abstrait de langage de programmation est construit; Enfin, un concept abstrait d'un algorithme est construit, mis en œuvre en tant que programme en C ++. Les types de données abstraits permettent de poursuivre ce processus plus loin et de développer des mécanismes abstraits pour certaines tâches de calcul à un niveau supérieur, fournie par le système C ++, développer des mécanismes abstraits axés sur des applications spécifiques et des tâches appropriées dans de nombreux domaines appliqués, car ainsi que créer des mécanismes abstraits plus haut niveauqui utilisent ces structures de base. Les types de données abstraits fournissent à notre disposition extensible pour l'ensemble des outils instrumentaux pour résoudre toutes les tâches nouvelles et nouvelles.
D'une part, l'utilisation de conceptions abstraites libère des préoccupations de leur mise en œuvre détaillée; D'autre part quand performance Les programmes sont importants, il est nécessaire de connaître le coût d'exécution des opérations de base. Nous utilisons de nombreuses abstractions de base intégrées à matériel ordinateur et employés la base des instructions de la machine; Nous mettons en œuvre d'autres abstractions dans des logiciels; Et nous utilisons des abstractions supplémentaires fournies par le logiciel système écrit précédemment. Les conceptions abstraites de haut niveau sont souvent créées en fonction de designs plus simples. À tous les niveaux, le même principe de base est valide: il est nécessaire de trouver les opérations les plus importantes dans les programmes et le plus caractéristiques importantes Données, puis définir ces personnes et d'autres personnes à déterminer au niveau abstrait et à développer des mécanismes spécifiques efficaces pour leur mise en œuvre. Dans cette conférence, nous examinerons de nombreux exemples de l'application de ce principe.
Développer un nouveau niveau d'abstraction (1), déterminez les objets abstraits avec lesquels il est nécessaire de manipuler et les opérations qui doivent être effectuées au-dessus d'elles; (2) soumettre des données dans certaines structures de données et mettre en œuvre des opérations; (3) et (surtout) s'assurer que ces objets qu'il est pratique d'utiliser pour résoudre des tâches appliquées. Ces éléments sont applicables aux types de données simples, de sorte que les mécanismes de base destinés à soutenir les types de données considérés dans des "structures de données élémentaires" peuvent être adaptés à nos fins. Cependant, la langue C ++ offre une expansion importante du mécanisme des structures appelé classe (classe). Les classes sont extrêmement utiles lors de la création de niveaux d'abstraction et sont donc considérés comme l'outil principal utilisé à cet effet dans le reste du livre.
Définition 4.1. Type de résumé Les données (ATD) sont un type de données (ensemble de valeurs et un ensemble d'opérations pour ces valeurs), l'accès auquel est effectué uniquement via l'interface. Le programme utilisant ATD s'appelle un client et le programme contenant la spécification de ce type de données est mis en œuvre.
C'est le mot qui ne fait que le type de données abstrait: dans le cas d'ATD, les programmes clients n'ont aucun accès aux valeurs de données, à l'exception des opérations décrites dans l'interface. La présentation de ces données et les fonctions qui implémentent ces opérations sont dans la mise en œuvre et sont entièrement séparées par l'interface du client. Nous disons que l'interface est opaque: le client ne peut pas voir la mise en œuvre via l'interface.
Dans les langues C ++, cette différence est généralement effectuée un peu plus claire, car il est le plus facile de créer une interface, y compris présentation des donnéesMais spécifier cet accès direct aux données n'est pas autorisé aux programmes clients. En d'autres termes, les développeurs de logiciels clients peuvent savoir présentation des donnéesMais en aucun cas, je ne peux l'utiliser.
À titre d'exemple, tenez compte de l'interface de type de données pour les points (Programme 3.3) à partir de la section 3.1 «Structures de données élémentaires». Cette interface est clairement déclarée que des points sont présentés comme des structures constituées d'une paire de nombres avec un point flottant, notés x et y. Une utilisation similaire de types de données est courante dans grands systèmes logiciel: Nous élaborons un ensemble d'accords de présentation de données (ainsi que de définir un certain nombre d'opérations connexes) et nous apportons ces règles disponibles via l'interface afin que vous puissiez utiliser des programmes clients faisant partie d'un grand système. Le type de données assure la cohérence de toutes les parties du système avec la représentation des principales structures de données à l'échelle du système. Peu importe la qualité d'une telle stratégie, il a une faille: si vous devez changer présentation des donnéesIl sera nécessaire de modifier tous les programmes clients. Le programme 3.3 nous donne à nouveau un exemple simple: l'une des raisons du développement de ce type de données est la commodité des programmes clients de travail avec des points et nous nous attendons, si nécessaire, les clients auront accès à des coordonnées distinctes. Mais nous ne pouvons pas aller à une autre présentation de données (dire, aux coordonnées polaires ou aux coordonnées en trois dimensions, voire d'autres types de données pour les coordonnées individuelles) sans modifier tous les programmes clients.
En revanche, le programme 4.1 contient la mise en place d'un type de données abstraite correspondant au type de données du programme 3.3, mais à l'aide de la classe de classe C ++, qui est immédiatement définie à la fois les données et les opérations associées. Le programme 4.2 est un programme client qui fonctionne avec ce type de données. Ces deux programmes effectuent les mêmes calculs que les programmes 3.3 et 3.8. Ils illustrent un certain nombre de propriétés principales des classes que nous considérons maintenant.
Lorsque nous écrivons une définition dans le programme comme INT I, nous spécifions le système à réserver une zone de mémoire pour les données (intégrées) Int, à laquelle vous pouvez contacter par nom i. En C ++, il existe un objet à terme pour ces entités. Lors de l'enregistrement dans un programme d'une telle définition que le point P, il est dit que l'objet de la classe de points est créé sur lequel vous pouvez contacter par nom P. Dans notre exemple, chaque objet contient deux éléments de données, avec les noms X et Y. Comme dans le cas des structures, ils peuvent être traités par nom comme P.Y.
Les éléments de données X et Y sont appelés données de membre de classe. La classe peut également identifier les membres qui implémentent des opérations associées à ce type de données. Par exemple, une classe définie dans le programme 4.1 a deux fonctions membres avec des noms de points et de distance.
Les programmes clients, tels que le programme 4.2, peuvent appeler des fonctions membres associées à un objet, en spécifiant leurs noms de la même manière que les noms de données dans certaines structures de structure. Par exemple, l'expression p.distance (Q) calcule la distance entre les points P et Q (la même distance doit renvoyer et appeler Q.Distance (P)). La fonction Point () est la première fonction du programme 4.1 - est une fonction membre spéciale appelée Constructeur: elle a le même nom que la classe, et on l'appelle lorsque vous souhaitez créer un objet de cette classe.
Programme 4.1. Mise en œuvre de la classe de points (point)
Cette classe définit un type de données composé d'un ensemble de valeurs «paires de nombres de points flottants» (on suppose qu'elles sont interprétées comme des points sur un plan décartitien), ainsi que deux fonctions membres définies pour toutes les instances. de la classe de points: point de fonction (), qui est un concepteur initialisation des coordonnées par des valeurs aléatoires de 0 à 1, ainsi que la fonction de distance (point), calculant la distance à un autre point. Présentation des données Il s'agit d'un privé (privé) et uniquement des fonctions membres peuvent se référer à cela ou le modifier. Les fonctions des membres eux-mêmes sont accessibles au public (public) et sont disponibles pour tout client. Le code peut être enregistré, par exemple, dans le fichier nommé point .CXX.
#Inclure.
Programme 4.2. Programme client pour la classe de points (trouvant le point le plus proche)
Cette version du programme 3.8 est un client qui utilise le point ATD défini dans le programme 4.3. La nouvelle opération crée un tableau d'objets POINT (appelant le constructeur Point () pour initialiser chaque objet avec des valeurs de coordonnées aléatoires). L'expression A [I] .Distance (A [J]) provoque la fonction Membre de distance pour un objet [i] avec l'argument A [J].
#Inclure.
La détermination du point P dans le programme client conduit à l'attribution de la zone de mémoire sous un nouvel objet, puis (à l'aide de la fonction Point ()) à l'affectation à chacun de ses deux éléments de ces valeurs aléatoires dans la gamme de 0 à 1.
Ce style de programmation, parfois appelé programmation orienté objet, est entièrement pris en charge par la conception de la classe C ++. La classe peut être considérée comme une expansion du concept de structure où les données sont non seulement combinées, mais les opérations avec ces données sont déterminées. Il peut y avoir beaucoup d'objets différents appartenant à une classe, mais tous sont similaires au fait que leurs données membres peuvent prendre le même ensemble de valeurs et que le même ensemble d'opérations peut être effectué avec ces membres de données - en général Ce sont des instances du même type de données. Dans la programmation orientée objet, les objets sont conçus pour gérer leurs données de membre (contrairement à l'utilisation de fonctions indépendantes pour traiter les données stockées dans des objets).
Nous considérons l'exemple décrit ci-dessus l'exemple d'une petite classe juste pour se familiariser avec les principales caractéristiques des classes; Par conséquent, il est loin d'être complet. En vrai code pour la classe du point, nous aurons beaucoup plus d'opérations. Par exemple, dans le programme 4.1, aucune opération ne vous permettra de reconnaître les valeurs des coordonnées X et Y. Comme nous le verrons, l'ajout de ces opérations et d'autres est une tâche assez simple. Dans la partie 5, nous examinerons dans des classes plus détaillées pour le point et d'autres abstractions géométriques, telles que des lignes et des polygones.
Dans la langue C ++ (mais pas en C), les structures peuvent également être des fonctions connexes. La distinction clé entre les classes et les structures est associée à l'accès à des informations caractérisées par des mots-clés.
Bonjour, Habravhan!
Le prochain message est une présentation de ma réflexion sur la nature des classes et des ATD. Ces reflets sont complétés par des citations intéressantes des livres du développement logiciel Gourou
introduction
Commençons par le fait que nous parlons sans heurts à la définition de ATD. ATD, tout d'abord, est un type de données, ce qui signifie comme suit: la présence de certaines opérations disponibles sur les éléments de ce type;
Ainsi que des données relatives auxquelles ces opérations sont effectuées (plage de valeurs).
Que signifie le mot "abstrait"? Tout d'abord, le concept d'abstrait «d'abstrait» signifie se concentrer sur quelque chose d'important et, en même temps, nous devons être distraits d'un peu important, pour le moment, les détails. La définition de l'abstrait est bien divulguée dans le livre de livres de livres ("Grady Boch"). Sonne la définition comme ceci:
L'abstraction est l'allocation et la transmission de la combinaison d'objets de propriétés communes qui définissent leurs frontières de concept et distinguent tous les autres types d'objets.
En d'autres termes, l'abstraction vous permet de "jeter la lumière" aux données dont nous avons besoin et, avec le "partage" de ces données que nous ne sommes pas importants.
Alors, que se passera-t-il si de fusionner le concept de "type de données" et de "abstraction" ensemble? Nous recevrons un type de données qui nous fournit un certain ensemble d'opérations garantissant que le comportement de ce type de données, ainsi que ce type de données masquera ces données avec lesquelles ce comportement est mis en œuvre. D'ici, nous arrivons au concept de l'ATD:
ATD est un type de données qui cachent sa réalisation interne des clients.
Il est surprenant que, en appliquant ATD Abstraction, nous permet de ne pas penser à des points de mise en œuvre de bas niveau, mais de travailler avec l'essence de haut niveau du monde réel (Steve McConnell).
Je pense que lorsque vous développez ATD, vous devez d'abord déterminer l'interface, car l'interface ne doit pas dépendre de la représentation interne des données de l'ATD. Après avoir déterminé les opérations qui déplacent l'interface, vous devez vous concentrer sur les données qui mettront en œuvre le comportement spécifié de l'ATD. En conséquence, nous obtenons une certaine structure de données - le mécanisme vous permet de stocker et de traiter des données. Dans le même temps, la beauté de l'ATD est que si nous voulons modifier la présentation interne des données, nous n'aurons pas à errer tout au long du programme et changera chaque ligne du code qui dépend des données que nous souhaitons changer. . ATD encapsule ces données, ce qui vous permet de modifier le travail des objets de ce type et non de l'ensemble du programme.
Avantages de l'ATD
L'utilisation de ATD présente de nombreux avantages (tous les avantages décrits peuvent être trouvés dans le livre de Steve McConnell "Code parfait"):
- Encapsulation des détails de vente.
Cela signifie qu'une fois l'encapsulation des détails de la mise en œuvre du travail ATD, nous fournissons l'interface client, avec laquelle il peut interagir avec ATD. En modifiant les détails de la mise en œuvre, la présentation des clients sur les travaux de l'ATD ne changera pas.
- Complexité réduite.
En abstraction des détails de la vente, nous sommes concentrés sur l'interface, c'est-à-dire sur ce qui peut être fait par ATD, et non sur la manière dont cela se fait. De plus, ATD nous permet de travailler avec l'essence du monde réel.
- Limiter la zone d'utilisation des données.
En utilisant ATD, nous pouvons être certains que les données représentant la structure interne de l'ATD ne dépendent pas d'autres sections du code. Dans le même temps, l'indépendance de l'ATD est mise en œuvre.
- Informatique haute interface.
ATD vous permet de présenter l'ensemble des interfes en termes d'entités du domaine, ce qui vous convient, augmente la lisibilité et l'informativement de l'interface.
Steve McConnell recommande de soumettre des types de données de faible niveau en tant que ATD, tels qu'une pile ou une liste. Demandez-vous quelle est cette liste. S'il représente une liste des employés de la banque, envisagez ATD comme une liste des employés de la banque.
Nous avons donc compris ce que ATD est et appelé les avantages de son utilisation. Maintenant, il convient de noter que lorsque vous développez des cours dans l'OOP, il convient de penser, tout d'abord sur ATD. En même temps, Steve McConnell l'a dit, vous n'êtes pas programmé dans la langue, mais en utilisant la langue. Ceux-ci, vous programmerez le départ de la langue, sans se limiter aux pensées en termes de tableaux ou de types de données simples. Au lieu de cela, vous penserez à un niveau élevé d'abstraction (par exemple, en termes de feuilles de calcul ou de listes d'employés). La classe n'est rien de plus qu'une addition et un moyen de mettre en œuvre le concept ATD. Nous pouvons même soumettre une classe comme formule:
Classe \u003d ATD + Héritage + polymorphisme.
Alors, pourquoi suivre l'ATD, lors du développement de cours. Parce que, d'abord, nous devons décider quelles opérations seront l'interface de la future classe, quelles données sont cachées et comment fournir un accès ouvert. Nous devons penser à fournir une interface élevée, une facilité d'optimisation et une vérification de code, ainsi que sur la manière de fournir la bonne abstraction de pouvoir réfléchir aux essences du monde réel, et non sur des éléments de mise en œuvre de bas niveau. Je crois que c'est après la définition de ATD, nous devons penser à des problèmes d'héritage et de polymorphisme.
Il convient de noter que le concept ATD a trouvé une application gyroche dans l'OOP, car ce concept complète l'OOP et vous permet de faire la complexité des programmes dans les exigences mondiales rapides pour les logiciels.
J'ai écrit cet article afin d'attirer l'attention des développeurs sur l'ATD afin d'améliorer la qualité du travail et le développement de logiciels.
Sources d'occasion:
Steve McConnell - "Code parfait";
Robert Sedzhvik - "Algorithmes sur Java".
L'abstrait est habituel appelé type de données, explicitement, n'est pas disponible dans la langue de programmation, dans ce sens, ce concept est relatif - le type de données manquant dans une langue de programmation peut être présent dans un autre.
Type de données abstraite (ATD) est déterminé indépendamment de la méthode de sa mise en œuvre:
plusieurs valeurs possibles de ce type,
et un ensemble d'opérations avec les valeurs de ce type.
L'utilisation de l'ATD peut être limitée à l'étape de développement logiciel, mais pour son utilisation explicite dans le programme, il est nécessaire de disposer de sa mise en œuvre sur la base des types de données existants (et précédemment mis en œuvre) dans le langage de programmation:
méthode de représentation des valeurs de ce type,
et la mise en œuvre des opérations avec les valeurs de ce type.
ATD n'est pas prédéterminé dans la langue de programmation, et même en outre, les opérations de conception de tels types prédéterminées dans le décalage de la langue au développeur de programmeur la question de la méthode de la présentation des valeurs de ce type et de la mise en œuvre des opérations avec les valeurs De ce type. Et par conséquent, pour ces types de données, la question du choix des définitions et des méthodes de mise en œuvre du type d'opérations constructeur (valeurs et entrepôts de données) de ce type sélecteur et modificateur les composants (valeurs et entrepôts de données) de ce type sont attribués au développeur de programmeur.
Dans le concept de ATD, les concepts ont un statut spécial interface , Open User, et ventes caché de lui. Le rôle particulier de ces concepts dans le concept ATD est lié à la disposition fondamentale de l'indépendance du concept de l'ATD de la méthode de sa mise en œuvre.
Dans les "langages de programmation pratiques modernes", une opération de conception de type prédéfinie est généralement utilisée pour concevoir ATD. classer Ce qui donne un programmeur à un programmeur non seulement les moyens de regrouper des données et des opérations (avec ces données) dans un seul ensemble, mais également des moyens d'encapsulation, d'héritage et de polymorphisme pour contrôler les méthodes de conception et d'accès à ces données. Notez que la classe décrit une implémentation possible de l'ATD, l'affichage de la classe dans l'ATD est exprimé par la fonction d'abstraction, mais le rapport opposé n'est généralement pas fonctionnel, les implémentations du même ATD peuvent être multiples.
Dans les études sur des types de données abstraites, un rôle important a été reconnu à un stade précoce. paramétrage du type " En effet, par exemple, la "pile" ATD ne dépend pas du type d'éléments de pile, mais il est impossible de mettre en œuvre cette ATD aux "éléments d'une sorte de type identique". Dans le langage de programmation ADA, les moyens appropriés de conception de types de données paramétrés ont été inclus initialement et dans les «langages de programmation pratiques modernes», ce qui signifie que depuis que le développement de la bibliothèque STL est apparu. Aujourd'hui, le concept de "programmation généralisée" occupe une position significative dans la programmation pratique due à l'inclusion dans "Langues de programmation pratiques" moyens de construire des types de données paramétrés (modèles, modèle. , générique) .
Tout ce qui précède signifie qu'avec un point de vue méthodologique et théorique, une définition précise plus détaillée du concept de «type de données abstrait» est nécessaire. En théorie, le concept de "type de données abstrait" est généralement défini comme système algébrique multi-noyau (multi-axe) En plus de l'ensemble des valeurs possibles (transporteur) et d'un ensemble d'opérations sur de telles valeurs, des concepts sont alloués:
La variété et la signature - ces concepts vous permettent de classer et des éléments du transporteur et des opérations avec eux par leurs types (pour les opérations - par les types de leurs arguments et la valeur renvoyée).
Prédicats - relations sur les éléments du transporteur. Cela vous permet de déterminer la zone des valeurs possibles en imposant des restrictions (exigences) sur des valeurs valides, ainsi que dans une interprétation naturelle de travailler avec des expressions logiques arbitraires, sans les obliger à les interpréter comme des fonctions d'accessoires pour les ensembles ou comme des opérations multiples.
Sur cette base, il est possible de prendre en compte des types de données abstraites avec un point de vue logique logique holistique, y compris des questions sur les concepteurs (types et valeurs), les sélecteurs et les modificateurs de propriétés pour des objets de ce type.
Les concepts de la "structure de données" et du "type de données abstrait" dans quelque chose de très proche. Vous pouvez bien sûr supposer que ces concepts ne sont que deux vues sur la même chose. La méthode de représentation des valeurs ATD est toujours basée sur une structure de données, moins ou plus complexe, et la mise en œuvre d'opérations avec de telles valeurs dépend naturellement de la présente structure de données sélectionnée. D'autre part, la structure de données concernait un grand désir que nous pouvons toujours émettre en tant que ATD.
Mais nous allons toujours distinguer ces deux concepts, donné:
Le type de données abstraite - implique un certain niveau d'abstraction afin de résoudre le type de données d'application (orienté objet) sans référence aux méthodes de sa mise en œuvre, et il est possible d'activer ce type de données dans la bibliothèque d'applications, bien, à moins pour le développement spécifique d'un système logiciel spécifique. ATD peut avoir plusieurs implémentations alternatives basées sur diverses structures de données.
La structure de données est plutôt un diagramme de l'organisation des données et de la gestion, qui implique une concrétisation appropriée lorsqu'il est utilisé dans des situations spécifiques lors de la résolution de tâches spécifiques.
Les types de données abstraits, tout d'abord, incluent naturellement des systèmes algébriques de base mathématiques - séquences, ensembles, relations et mappages (relations fonctionnelles, fonctions). Mais dans la programmation de premier plan, ce n'est pas une étude des propriétés communes de ces concepts mathématiques et des possibilités de leur utilisation dans le développement de modèles de résolution des objectifs du sujet, des algorithmes de résolution de ces tâches et de la mise en œuvre effective de les algorithmes développés. Et par conséquent, sous la forme de ATD, les variantes limitées de ces systèmes algébriques de base sont généralement élaborées d'un côté et, d'autre part, étendues par des ensembles spécialisés d'opérations représentant un intérêt pragmatique sur le point de vue de la demande.
Ministère de l'éducation et de la science de la Fédération de Russie
Établissement d'enseignement budgétaire des États fédéraux
Éducation professionnelle supérieure
Recherche nationale Université nucléaire "Mephi"
Dimitrovgrad Engineering et Institut technologique
département Informatique
Protéger la défense "" 2012
Diriger département Rakov O.A.
Travail de cours
par discipline"Programmation orientée objet"
Matière:"Types de données abstraites. Listes "
Effectué: Étudiant c. WT-31
Shayakov A.f.
Chef: Art. Conférencier département.
Alenin V. A.
Normocontroller: Art. Conférencier département.
Alenin V. A.
Évaluation:
Date de protection:
Dimitrovgrad, 2012.
Ministère de l'éducation et de la science de la Fédération de Russie
Établissement d'enseignement budgétaire des États fédéraux
Éducation professionnelle supérieure
Recherche nationale Université nucléaire "Mephi"
Dimitrovgrad Engineering et Institut technologique
pour cours
Discipline: Programmation orientée objet
Sujet: Types de données abstraites. Listes
Artiste: Shayakov A.f.
Leader: Alenin V.a.
1.Toresome part:
Types de données abstraites. Le concept de programmation orientée objet. Listes connectées individuelles linéaires.
2. Partie pratique:
En C ++, écrivez un programme avec une structure orientée objet pour implémenter des listes connectées à une seule connexion linéaire.
Termes de performance à l'horaire:
Partie théorique - 15% sur 5 semaines
Partie pratique - 80% sur 7 semaines
Section expérimentale - ____% à ____ Semaine
Protection - 100% sur 10 Semaine
Conditions d'enregistrement:
Le règlement et la note explicative des travaux de cours doivent être représentés par des copies électroniques et solides;
Le volume du rapport doit comporter au moins 20 pages dactylographiées sans applications comptables.
RPZ abonna du responsable de la normale
Officier _________________
Artiste ____________________________
Date d'émission "_____" ___________ 2012
Shayakov A.F.tea: Types de données abstraites. Listes, Terme Document / Dithi, №230105.65-Dimitrovgrad, 2012. - 29 pp., Fig. 11, Bible. Nom 10, Applications 1.
Mots-clés: listes connectées à une ligne linéaire, C ++, programmation orientée objet.
Objet de recherche - Listes connectées à une seule personne.
L'objectif du travail consiste à étudier des listes connectées linéaires, à écrire un programme en C ++ avec une structure orientée objet pour les implémenter.
CONCLUSIONS: Dans ce document, des listes linéaires sur une connexion one ont été entièrement étudiées, ainsi que des méthodes de leur présentation en mémoire. Le programme écrit en C ++ correspond parfaitement à une structure orientée objet, correctement et efficacement ses tâches principales - implémente des listes connectées à une seule connexion linéaire.
Introduction 6.
1 partie théorique 7
1.1 Types de données abstraites. Listes linéaires 7.
1.2 Le concept de programmation orientée objet 8
2 partie pratique 15
3 tests 23.
Conclusion 25.
Références 26.
Annexe A 27.
introduction
Souvent, dans le processus de travail avec des données, il est impossible de déterminer la quantité de mémoire nécessaire à leur stockage, la mémoire doit être distribuée lors de l'exécution du programme car elles ont besoin de blocs distincts. Les blocs sont associés à l'autre à l'aide des pointeurs. Cette méthode d'organisation de données s'appelle une structure de données dynamique, car elle est placée dans la mémoire dynamique et ses changements de taille lors de l'exécution du programme.
Des structures dynamiques dans cet article, des listes linéaires sont utilisées. La structure dynamique, contrairement à un tableau ou à un enregistrement, peut occuper des zones de RAM non adéquates.
Les structures dynamiques sont largement utilisées pour des données plus efficaces avec des données, dont la taille est connue, en particulier pour la résolution de tâches de tri.
L'élément de toute structure dynamique est composé de deux parties: des informations, pour des raisons de stockage dont la structure et les pointeurs sont créées garantissant la connexion des éléments les uns avec les autres.
Partie théorique
1.1About types de données. Listes linéaires
Le concept de types de données abstraites est essentiel dans la programmation. L'abstraction implique la séparation et la prise en compte indépendante de l'interface et de la mise en œuvre.
L'abstraction des données implique la définition et la prise en compte des types de données abstraits (ATD) ou, qui sont les mêmes types de données saisis par l'utilisateur.
Le type de données Abstract est un ensemble de données avec une variété d'opérations pouvant être effectuées au-dessus de ces données.
Listes linéaires
Dans la liste linéaire, chaque élément est associé aux éléments suivants et, éventuellement, avec le précédent. Dans le premier cas, la liste s'appelle une personne connectée, dans la seconde - double d'esprit. Si le dernier élément se lie le pointeur à la première, il allumera la liste des anneaux.
Chaque élément de la liste contient une clé identifiant cet élément. La clé arrive généralement soit un entier ou une chaîne et fait partie du champ de données. En tant que clé du processus de travail avec une liste, différentes parties du champ de données peuvent être. Les clés des différents éléments de la liste peuvent correspondre.
Les opérations suivantes peuvent être effectuées au-dessus des listes:
formation initiale de la liste (création du premier élément);
ajouter un élément à la fin de la liste;
lire un élément avec une clé donnée;
élément d'insertion dans un emplacement de liste spécifié (avant ou après un élément avec une clé spécifiée);
supprimer un élément avec une clé donnée;
commander une liste de la clé.
Pour travailler avec une liste dans le programme, il est nécessaire de déterminer le pointeur à son début. Pour simplifier l'ajout de nouveaux éléments à la fin de la liste, vous pouvez également démarrer le pointeur à la fin de la liste.
1.2 Positionnement Programmation orientée objet
Par définition de l'autorité dans le domaine des méthodes axées sur les objets pour le développement de notes, BUCHA "Programmation orientée objet (OOP) est une méthodologie de programmation basée sur la présentation du programme sous la forme d'un ensemble d'objets, chacun desquels La mise en œuvre d'une certaine classe (un tel type spécial) et des classes forment une hiérarchie sur les principes d'héritage. "
La méthodologie orientée objet ainsi que la méthodologie structurelle a été créée pour discipliner le processus de développement de grandes complexes logiciels et de réduire ainsi leur complexité et leur coût.
La méthodologie orientée objet poursuit les mêmes objectifs que la structure, mais les résout d'un autre point de départ et vous permet dans la plupart des cas de gérer des projets plus complexes que la méthodologie structurelle.
Comme on le sait, l'un des principes de la complexité du projet est la décomposition. Comté boch alloue deux types de décomposition: algorithmique (il appelle donc une décomposition soutenue par des méthodes structurelles) et orienté objet, la différence entre laquelle consiste, à son avis, dans ce qui suit: "La séparation des algorithmes concentre l'attention sur la procédure de la procédure de événements survenants et la séparation des objets attachent une importance particulière à des facteurs ou à des actions, ou d'être des objets de l'application de ces actions. "
En d'autres termes, la décomposition algorithmique prend en compte la structure de la relation entre des parties d'un problème complexe et la décomposition orientée objet porte davantage l'attention sur la nature des relations.
En pratique, il est recommandé d'appliquer les deux types de décomposition: lors de la création de grands projets, il est conseillé d'appliquer une approche orientée objet pour créer une hiérarchie commune d'objets reflétant l'essence d'une tâche programmable, puis utilisez la décomposition algorithmique. sur les modules pour simplifier le développement et la maintenance du progiciel.
La programmation OO est sans aucun doute l'une des destinations les plus intéressantes des programmes de développement professionnel.
Objets et classes
Les blocs de base d'un programme orienté objet sont des objets et des classes. L'objet de contenu peut être représenté comme quelque chose de sensible ou imaginaire et ayant un comportement bien défini. Ainsi, l'objet peut soit voir ou toucher, soit au moins savoir que c'est, par exemple, est présenté sous la forme d'informations stockées dans la mémoire de l'ordinateur. Nous donnons la définition de l'objet, adhérant à l'opinion de la Gradibach: "L'objet est essentiellement tangible, qui manifeste clairement son comportement."
L'objet fait partie de la réalité environnante, c'est-à-dire qu'il existe dans le temps et dans l'espace (pour la première fois que le concept d'un objet dans la programmation a été introduit à Simula). Formellement, l'objet est assez difficile à déterminer. Cela peut être fait à travers certaines propriétés, à savoir: l'objet a un état, un comportement et peut être identifié de manière unique (en d'autres termes, a un nom unique).
La classe est beaucoup d'objets qui ont une structure commune et un comportement général. Classe - Description (abstraction), qui montre comment construire une variable de temps et d'espace existante de cette classe, appelée objet. La signification des propositions "Description des variables de classe" et "Description des objets de classe" est la même.
L'objet a une condition, un comportement et un passeport (moyens pour son identification sans ambiguïté); La structure et le comportement des objets sont décrits dans des classes dont ils sont variables.
Nous définissons maintenant les concepts d'état, de comportement et d'identification de l'objet.
L'état de l'objet combine tous ses champs de données (composant statique, i.e. constante) et les valeurs actuelles de chacun de ces champs (composant dynamique, c'est-à-dire habituellement changeant).
Le comportement exprime la dynamique des modifications de l'état de l'objet et de sa réaction aux messages entrants, c'est-à-dire Comme un objet change ses États et interagit avec d'autres objets.
Identification (reconnaissance) d'un objet est une propriété qui vous permet de distinguer un objet d'autres objets de la même classe ou d'autres classes. L'identification est effectuée au moyen d'un nom unique (passeport) que l'objet est doté du programme, cependant, comme toute autre variable.
Il a déjà été dit ci-dessus que la procédure (ainsi que l'approche modulaire) nous permet de créer des programmes composés d'un ensemble de procédures (sous-routines) qui implémentent les algorithmes spécifiés. D'autre part, une approche orientée objet représente des programmes sous la forme d'un ensemble d'objets interagissant les uns avec les autres. L'interaction des objets est effectuée par des messages. Supposons que notre objet soit un cercle. Ensuite, le message envoyé à cet objet peut être comme suit: "Dessinez-vous." Lorsque nous disons que le message est transmis à l'objet, nous appelons en fait une fonction de cet objet (fonction de composant). Donc, dans l'exemple ci-dessus, nous appellerons une fonction qui dessinera un cercle sur l'écran d'affichage.
Encapsulation
L'encapsulation est l'un des principes fondamentaux de la programmation orientée objet, dont l'idée est que toutes les propriétés et méthodes sont combinées dans un certain objet.
Le nom du terme "encapsulation" provient de l'encapsulation de mot anglais, qui, dans la traduction littérale, signifie "sceller dans la capsule" ou "couvrant la coque". Ainsi, l'objet (capsule) entre en soi des méthodes et des propriétés (contenu).
Le concept d'encapsulation peut être considéré dans un sens plus large, loin du cadre de la programmation orientée objet dans son ensemble. Si nous parlons d'encapsulation au niveau maximum possible d'abstraction, l'encapsulation peut être représentée à mesure que la capacité d'un objet à entrer dans un certain ensemble d'autres objets. Donc, appliquée au programme informatique, on peut dire qu'elle encapsule plusieurs modules en soi, chacun d'eux, chacun, à son tour, encapsule certains objets qui encapsulent des méthodes et des propriétés qui peuvent également être des objets, etc.
Basé sur tout ce qui précède, une structure d'arbre de plus, dans laquelle tout nœud d'arbres encapsule tous ses enfants immédiats, ce qui peut être comme des feuilles (primitives, qui ne peuvent rien encapsuler) ainsi que d'autres nœuds peuvent être considérés comme une autre présentation de l'encapsulation.
Et pourtant, si nous parlons de programmation orientée objet, l'encapsulation consiste à combiner des données et des méthodes dans l'objet.
Parfois, parlant d'encapsulation dans la programmation orientée objet, le concept d'encapsulation est égal au concept de "boîte noire" ou de cachette de données, mais ce n'est pas la même chose. Oui, dans certaines langages de programmation orientés objet à l'aide d'encapsulation, le développeur peut faire son objet avec une boîte noire, mais celle-ci est mise en œuvre à l'aide de modificateurs d'accès qui ne sont pas dans toutes les langues de programmation orientées objet. Le concept d'encapsulation est beaucoup plus large. Et encore plus, nous pouvons faire toutes les propriétés et toutes les méthodes disponibles de l'extérieur, c'est-à-dire que la boîte noire et la parole ne peuvent pas aller, mais l'encapsulation sera toujours présente dans n'importe quel objet. Par conséquent, la dissimulation des données au moyen de modificateurs d'accès est une conséquence de l'encapsulation, mais elles ne sont pas identiques à des concepts égaux.
Premièrement, grâce à l'encapsulation, les objets ont cessé d'être simplement des structures de données utilisateur, dont le but principal est de simplement être logiquement combiné plusieurs types de données distincts dans un nouveau type de données composé. Grâce à l'encapsulation, chaque objet peut désormais contenir des données décrivant l'état de l'objet et son comportement décrit sous la forme de méthodes. En d'autres termes, l'objet dans la programmation orientée objet a cessé d'être un type de données passive primitif, qui est complètement éliminé sur l'environnement externe, mais a commencé à avoir son propre comportement, vous pouvez même dire que vous pouvez dire une volonté et l'esprit, la capacité de Répondez activement aux influences externes et à modifier son état et en fonction de ses propres lois et règles.
Deuxièmement, l'encapsulation nous donne la possibilité de contrôler l'accès aux données d'objet. Limitant la visibilité peut également être considéré comme une manifestation de son propre objet - l'objet lui-même décide que de son comportement ou de son comportement à rendre accessible à tous, qui est disponible uniquement pour un certain cercle d'objets, et qu'est-ce que c'est un purement intime. , qu'est-ce qui ne connaîtra pas d'autre objet. Pourquoi, pour que seul l'objet lui-même sache exactement comment cela peut fonctionner avec lui et comme non. Vous pouvez même dire à propos de la nouvelle philosophie de programmation, où les objets sont davantage sur les articles sur lesquels certaines actions sont effectuées et, si vous pouvez le dire, une nouvelle forme d'esprit synthétique abstrait, interagissant avec lequel vous pouvez obtenir le résultat souhaité.
Et encore une fois, je répète que c'est grâce à l'encapsulation qu'un objet peut être doté d'une certaine volonté, la raison, la capacité de réagir à l'impact externe, et non un stockage de données passives.
Héritage
L'héritage est l'un des quatre mécanismes les plus importants de la programmation orientée objet (avec encapsulation, polymorphisme et abstraction), ce qui vous permet de décrire une nouvelle classe sur la base d'un (parental) déjà existant, tandis que les propriétés et les fonctionnalités de la Les cours des parents sont empruntés par la nouvelle classe.
En d'autres termes, la classe Heir implémente la spécification d'une classe existante (classe de base). Cela vous permet de gérer les objets de la classe Heir de la même manière que les objets de la classe de base.
Types d'héritage
Héritage simple
La classe à partir duquel l'héritage est survenu s'appelle basique ou parent (BaseClass anglais). Les classes survenues de la base sont appelées des descendants, des héritiers ou des classes dérivées (eng. Dériveclass).
Dans certaines langues, des classes abstraites sont utilisées. Une classe abstraite est une classe contenant au moins une méthode abstraite, elle est décrite dans le programme, comporte des champs, des méthodes et ne peut pas être utilisé pour créer directement un objet. C'est-à-dire que vous ne pouvez hériter que de la classe abstraite. Les objets sont créés uniquement sur la base de classes dérivées héritées de résumé.
Par exemple, une classe abstraite peut être la classe de base "employée de l'université", à partir de laquelle les grades "étudiants diplômés", "professeur" et ainsi de suite. Puisque les dérivés ont partagé des champs et des fonctions (par exemple, l'année de naissance "Champ), alors ces membres de la classe peuvent être décrits dans la classe de base. Le programme crée des objets basés sur des grades "étudiant diplômé", "professeur", mais il n'a aucun sens de créer un objet basé sur la classe "employé de l'université".
Héritage multiple
Avec plusieurs héritages, la classe peut avoir plus d'un ancêtre. Dans ce cas, la classe hérite des méthodes de tous les ancêtres. Les avantages de cette approche dans une plus grande flexibilité. Plusieurs héritages sont implémentés en C ++. D'autres langues fournissant cette opportunité, vous pouvez marquer Python et EIFEL. Héritage multiple est pris en charge dans la langue UML.
L'héritage multiple est une source potentielle d'erreurs pouvant survenir en raison de la présence des mêmes méthodes de méthodes dans les ancêtres. Dans les langues qui sont positionnées comme les héritiers C ++ (Java, C #, etc.), il a été décidé de refuser de donner aux interfaces de multiples héritage. Presque vous pouvez toujours faire sans l'utilisation de ce mécanisme. Toutefois, si un tel besoin est de résoudre les conflits pour utiliser des méthodes héritées avec le même nom, par exemple, par exemple, d'appliquer une opération d'expansion de visibilité - "::" - Appeler la méthode spécifique d'un parent particulier.
Tentative de résoudre le problème des mêmes méthodes de méthodes dans les ancêtres a été entreprise dans la langue de l'Eifel, dans laquelle, lors de la description d'une nouvelle classe, il est nécessaire d'indiquer explicitement les membres importés de chacune des classes héritées et de leur nom dans le classe enfant.
La plupart des langages de programmation modernes orientées objet (C #, C ++, Java, Delphi, etc.) prend en charge la possibilité de hériter simultanément de l'ancêtre de classe et de mettre en œuvre les méthodes de plusieurs interfaces dans la même classe. Ce mécanisme vous permet de remplacer en grande partie de multiples méthodes d'interface de héritage doit être remplacée explicitement, ce qui élimine les erreurs tout en héritant la fonctionnalité des mêmes méthodes d'ancêtres différents.
Partie pratique
La structure orientée objet du programme est utilisée pour résoudre la tâche. Le programme est représenté par deux classes et le fichier CPP principal contenant l'interface utilisateur pour la commodité de travail avec des listes.
Class Clist est une liste linéaire unique émincée composée d'objets de classe de celement.
La classe Celement a la structure suivante:
celement * Suivant;
~ Celement (nul);
void setdata (int);
vOID SETERF (Celement *);
celement * getref ();
Le champ INT de type de données contient une valeur numérique de l'élément de liste, le type de champ suivant Celement * est un lien vers l'élément de liste suivant. Les méthodes SetData et GetData sont utilisées pour accéder au champ de données total de la classe afin d'obtenir et de définir respectivement la valeur de ce champ. La méthode SETREF est utilisée pour définir la référence de la liste actuelle sur l'élément suivant et GetRef d'aller à l'élément suivant.
Épelement annulé :: Sedata (int SD)
intelement :: getdata ()
retirez-les-\u003e données;
vide celement :: Setref (Celement * RF)
celement * Celement :: getref ()
retirez-la-\u003e Suivant;
La mise en œuvre de ces méthodes est extrêmement simple, qui est constatée à partir de leurs codes de programme présentés ci-dessus.
Considérez maintenant la structure du clist de classe
#Include "celement.h"
celement * tête;
annuler ajouter (int);
insert vide (int, int);
vide supprimer (int);
void removeall ();
Cette classe contient un lien vers l'élément de tête de la liste de la liste, telle que celement *. Stocker cette référence est nécessaire pour une exécution correcte des opérations pour l'ajout, la suppression de données et imprimer une liste. Le fait est que lorsque lors de l'une des opérations ci-dessus, une liste des éléments de liste a lieu pour atteindre le souhaité souhaité, car la liste n'a aucun accès arbitraire aux éléments, donc le buste du rationnel de la "tête" de la "tête" du liste. En plus du lien vers le début de la liste, chaque objet de cette classe aura le champ Elcount, qui contient le numéro des éléments de la liste.
Poursuivre l'examen de cette classe avec l'étude des méthodes implémentées pour travailler avec des listes.
Ajouter une méthode - Ajouter des données à la fin de la liste.
En tant que paramètre, cette méthode prend une valeur numérique (variable XD), que vous souhaitez enregistrer sur l'élément de la liste ajoutée.
void Clist :: Ajouter (int xd)
C'est comment créer un nouvel élément et définir la valeur de son champ numérique:
celement * Temp \u003d Newcentiment;
temp-\u003e setdata (XD);
Après avoir vérifié le numéro des éléments de la liste, si la liste est vide, l'élément de tête est créé, sinon le composant "ordinaire" de la liste est créé:
si (elcount \u003d\u003d 0)
temp-\u003e Setref (null);
temp-\u003e Setref (null);
p-\u003e SETREF (TEMP);
On peut noter que dans la conception ci-dessus, la méthode de Celement Class Setref est utilisée, ce qui est nécessaire pour définir la référence à l'élément de liste suivant, sinon la liste ne sera pas liée, qui est chargée de la perte de données et du fonctionnement incorrect du programme. .
Lorsque vous démarrez le programme décrit ci-dessus, il est utilisé en série ajoutant des éléments à la liste avec laquelle vous pouvez alors travailler pour arrêter l'entrée à ligne de commande Au lieu de la valeur numérique de l'élément, entrez la commande "Stop" (voir la figure 1).
Figure 1 - Le processus d'ajout d'éléments à la liste
Après avoir entré la commande "Stop", la liste des impressions et le programme passe au mode de veille de la commande (voir la figure 2).
Figure 2 - Liste imprimée
Méthode d'impression - Liste d'impression.
Pour imprimer, il est important de connaître le début de la liste pour imprimer séquentiellement les valeurs de tous les éléments de la liste. Par conséquent, un lien vers la liste "Head" est défini sur la variable TEMP, après laquelle la liste de l'existence de la La liste est cochée et le message correspondant est affiché s'il n'est pas confirmé si la liste n'est pas vide, elle s'affiche:
void Clist :: Imprimer ()
celement * temp \u003d la tête;
si (Temp \u003d\u003d null) COUT TOUT (TEMP! \u003d NULL)
tEMP \u003d TEMP-\u003e GETREF ();
Del méthode - Suppression de l'élément de la liste initiale.
Pour supprimer l'élément initial, vous devez d'abord déplacer le lien vers le composant suivant de la liste, ce qui en fait le premier de cette manière, puis supprimez l'élément souhaité:
voidClist :: del ()
celement * temp \u003d la tête;
tête \u003d tête-\u003e getref ();
Méthode RemoveAll - Suppression de la liste complète.
Cette méthode est basée sur ce qui précède et consiste à éliminer séquentiellement les éléments initiaux de la liste jusqu'à ce que la liste complète soit supprimée.
clist annulé :: removeall ()
tandis que (elcount! \u003d 0)
Pour commencer cette méthodeDans le menu Travail, vous devez entrer la commande "Dellist" (voir la figure 3).
Figure 3 - Entrez la commande pour nettoyer la liste
Et si l'utilisateur est vraiment confiant dans ses actions, vous devez accepter la proposition du programme, après quoi la liste complète est supprimée (voir la figure 4).
Figure 4 - Liste vierge
Supprimer la méthode - Suppression d'un élément de liste spécifique.
Méthode moins radicale que la précédente. Un seul spécifié en tant que paramètre, l'élément de liste est supprimé. Cela se produit comme suit: le programme vérifie d'abord l'exactitude du paramètre entré si le numéro de l'élément est inférieur à un ou plusieurs. le total Éléments de liste, il affiche un message d'erreur s'il n'y a aucune plainte sur le programme à entrer dans le programme, les références nécessaires des éléments situés à côté de la suppression sont transférées de sorte que la liste reste associée, après quoi l'élément souhaité est supprimé.
void Clist :: Supprimer (int Del)
celement * Cur \u003d Head, * de;
si ((del\u003e \u003d 1) && (del
tête \u003d tête-\u003e getref ();
tandis que (J! \u003d Del-1)
cur \u003d Cur-\u003e Getref ();
dE \u003d CUR-\u003e GETREF ();
cur-\u003e Setref (DE-\u003e GETREF ());
coutSystem ("Pause");
Pour lancer cette méthode, dans le menu Liste de travail, vous devez entrer la commande "Supprimer". Ensuite, entrez le numéro de l'élément étant supprimé ou la commande "Back" pour annuler la suppression (voir la figure 5).
Figure 5 - Processus d'élimination de l'élément de la liste
La liste après avoir retiré le quatrième élément ressemblera à ceci (voir la figure 6).
Figure 6 - Liste après avoir retiré un élément
Méthode d'insertion - Insérez un nouvel élément dans lieu spécifié dans la liste.
En tant que paramètres, cette méthode accepte: la position de l'élément ajouté et sa valeur numérique. Le nouvel élément augmentera exactement à l'emplacement spécifié, de sorte que les éléments situés à droite du courant seront déplacés vers une position. Lors de l'ajout d'un nouvel élément en haut de la liste, vous devez simplement transférer le lien de cet élément à l'autre, connectant ainsi la liste et spécifier le lien à l'élément initial. Une situation légèrement différente se produit lors de l'ajout d'un nouvel élément entre les deux déjà existants, à cet égard, à l'aide d'un cycle pour atteindre le lieu d'insertion de l'élément, puis attachez avec les nouveaux composants d'élément qui sont à droite et à gauche de il. Après tout, quoi, par exemple, vous devez faire s'il est nécessaire d'allonger la chaîne: il est nécessaire de le casser, puis de fixer un nouveau lien vers la première partie de la chaîne, de fixer au même lien vers La seconde, quelque chose de similaire est implémenté dans cette méthode. Il convient de noter que lors de la spécification d'une position incorrecte à ajouter, ce qui est inférieur à un seul ou plusieurs du nombre total d'éléments, le programme donnera le message d'erreur approprié.
clist vide :: insert (int Pos, int Val)
celement * Cur \u003d Tête;
celement * TEMP \u003d nouveau celement;
temp-\u003e setdata (val);
si ((POS\u003e \u003d 1) && (POS
temp-\u003e settref (tête);
tandis que (J! \u003d POS-1)
cur \u003d Cur-\u003e Getref ();
p \u003d cur-\u003e getref ();
cur-\u003e Setref (TEMP);
temp-\u003e Setref (p);
coutSystem ("Pause");
Pour démarrer cette méthode, vous devez entrer la commande "Insérer" dans le menu Travail. Ensuite, entrez la position et la valeur numérique de l'élément ajouté ou la commande "BACK" pour annuler la suppression (voir la figure 7).
Figure 7 - Processus d'insertion des éléments
La liste après avoir ajouté à la troisième position de l'élément avec la valeur 111, la liste se ressemblera comme suit (voir la figure 8).
Figure 8 - Liste après ajout d'un article
Dans le processus de description, le menu de travail avec une liste a été mentionné plus d'une fois, il reste à noter que ce menu facilite la tâche de fonctionner avec la liste. L'algorithme de son travail consiste à faire du vélo des mêmes méthodes, à imprimer une liste par exemple jusqu'à ce qu'une commande spécifique soit entrée. La liste des commandes disponibles est visible en entrant "Aide" dans la console (voir la figure 9)
Figure 9 - Commandes disponibles
Le menu entièrement programmé est présenté à l'annexe A.
Essai
Souvent, dans le processus de travail, des situations se posent liées à des informations incorrectes saisie de donnéesCe qui peut causer une défaillance du programme? Bien entendu, dans chaque programme doit être mis en œuvre des algorithmes pour la protection contre un utilisateur inexpérimenté, un programme d'alerte de l'échec. Examinez comment ces algorithmes dans le programme créé fonctionnent.
L'entrée initiale de la liste est implémentée ci-dessous par le code ci-dessous:
si (Atoi (SS)! \u003d NULL)
myList.add (ATOI (SS));
Avant d'appeler la méthode Ajouter un nouvel élément à la liste, la ligne entrée est cochée. La fonction ATOI traduit la valeur de la chaîne en numérique et renvoie NULL si la chaîne entrée n'est pas un nombre. Ainsi, lorsque vous entrez, toutes les lignes ne sont pas des chiffres, à l'exception de la ligne avec la commande d'arrêt d'entrée (voir la figure 10).
Figure 10 - Entrez des données incorrectes
Après avoir entré de telles données, la liste ressemblera à ceci (voir la figure 11).
Figure 11 - Liste reçue
Le programme continue de fonctionner correctement après, même après avoir entré des données erronées. Des méthodes similaires de lutte contre des données incorrectes sont utilisées, avec d'autres opérations d'entrée présentes dans le programme.
Conclusion
Dans cet article, les concepts de types de données abstraits ont été obtenus, les principes de leur présentation dans les langages de programmation modernes, en C ++ en particulier. Dans la plupart des langues impératives modernes, le concept principal utilisé pour décrire les abstractions dans le code du programme est une approche orientée objet. La programmation orientée objet (OOP) également, comme l'approche de la programmation sur la base de l'ATD est, dans une certaine mesure, le développement d'idées sur la programmation modulaire. Les modules sont composants du programmequi ont deux propriétés importantes:
Modules masque les détails de vente.
Les modules peuvent être réutilisés dans diverses parties du programme.
David Parnas Dans son travail de 1972, représentait des modules comme des machines abstraites stockées en eux-mêmes et leur permettant de changer cet état au moyen d'un certain ensemble d'opérations. Ce concept est basique, tant pour le concept de types de données abstraits que de programmation orientée objet. Après avoir tenu des parallèles entre le travail de parnasse et les concepts modernes de l'OOP, il est facile de remarquer la relation des concepts de la classe et du module.
Dans ce travail, des listes linéaires connectées à une seule personne, qui sont un type de données abstraites, sont représentées par les modules développés, pour accéder aux états dont sont également mises en œuvre par des opérations spéciales, appelées méthodes dans la programmation orientée objet.
Bibliographie
1. Méthodes d'objet Ian Graham. Principes et pratiques \u003d Méthodes orientées objet: principes et pratiques. - 3ème éd. - M.: Williams, 2004. - P. 880.
2. Anthony Synthesus PROGRAMMATION SIMPLE SOIRE SOI SEULE PROGRAMMATION OBJECTÉE POUR 21 DAYS \u003d SAMS Enseigne-t-elle la programmation orientée objet en 21 jours. - M.: Williams, 2002. - P. 672.
3. Bertrand Meyer Construction de systèmes logiciels orientés objet + CD. Internet Technologies de l'Université de l'information - Intuit.ru, Édition russe, 2005
4. Billig V.A. Principes de base de la programmation sur C #. Technologies de l'Université d'information sur Internet - Intuit.ru, 2006
5. «Nouvelles langues de la programmation et des tendances de leur développement», Ushkova V., 2005
6. Biren Stutrap "C ++ Langue de programmation" Edition spéciale ou 3ème édition ED. Binin, Nevsky Dialect, ISBN 5-7989-0226-2, 5-7940-0064-3, 0-201-70073-5
7. Biern Sturastrup "Conception et évolution de C ++". DMK Press, Peter, ISBN 5-469-01217-4, 0-201-54330-3
8. Bjarne Sturastrup "Principes de programmation et pratique d'utilisation C ++". "I.D. Williams", 2011, ISBN 978-5-8459-1621-1 (RUS.)
9. Gradidi bus et autres. Analyse et conception orientée objet avec des exemples d'applications "2 soit 3ème édition. Binom, Nevsky Dialect, Williams ISBN 978-5-8459-1401-9, 0-201-89551-X, 0-8053-5340-2, 5-7989-0067-3, 5-7940-0017-1
10. Scott Meyers "Utilisation efficace de C ++. 50 Recommandations pour améliorer vos programmes et projets" DMK, Peter, ISBN 0-201-92488-9, 5-93700-006-4, 5-469-01213-1
Annexe A.
Code du logiciel de menu
#Include "clist.h"
#Include "string.h"
utilisation de Namespace STD;
coutwhile (Strstr (SS, "STOP") \u003d\u003d NULL)
si (Atoi (SS)! \u003d NULL)
myList.add (ATOI (SS));
système ("CLS");
tandis que (strtstr (com, "sortie") \u003d\u003d null)
coutmylist.Print ();
si (strtstr (com, "aide")! \u003d Null) com_ind \u003d 1;
si (Strstr (com, "Ajouter")! \u003d null) com_ind \u003d 2;
si (strtstr (com, "insert")! \u003d null) com_ind \u003d 3;
si (Strstr (com, "Supprimer")! \u003d null) com_ind \u003d 4;
si (strtstr (com, "delliste")! \u003d null) com_ind \u003d 5;
interrupteur (com_ind)
système ("CLS");
système ("CLS");
coutcoutCoutCoutCoutCoutCom_ind \u003d 0;
si (Strstr (SS, "Retour") \u003d\u003d NULL)
si (Atoi (SS)! \u003d NULL)
myList.add (ATOI (SS));
système ("CLS");
// Insérer des éléments.
si (Strstr (SS, "Retour") \u003d\u003d NULL)
si (Atoi (SS)! \u003d NULL)
système ("CLS");
si (Strstr (SS, "Retour") \u003d\u003d NULL)
si (Atoi (SS)! \u003d NULL)
myist.insert (POS, ATOI (SS));
système ("CLS");
// Supprimer des éléments.
si (Strstr (SS, "Retour") \u003d\u003d NULL) est déterminé par de nombreuses valeurs cette et un ensemble d'opérations ... Structures connectées données – lister. Structure données - Ceci est une totalité d'éléments donnéesentre lequel ... dans la mémoire de l'ordinateur est appelé abstrait ou logique. Plus souvent ...
Plusieurs un type données. Ensemble
Conférence \u003e\u003e Informatique, programmation... un type Simple les types données. Plusieurs les types Décrit dans la section les types ... Wu peut être décrit. Abstrait Structures de calcul décrivant l'entrée ... Autres cas les types Tous les composants lister Doit correspondre à S. taper Composants de fichier. ...
Bases orientées objet donnéesTravailler dans des réseaux distribués
Résumé \u003e\u003e InformatikaDéveloppement de zones de programmation Langues avec abstrait les types données et langages de programmation orientés objet. ... les types données - Liste et tableau. Chaque littéral est identifié de manière unique par l'index dans la matrice et le numéro de séquence dans lister ...
Abstrait Modèles de sécurité de l'information
Résumé \u003e\u003e InformatikaProtection des informations ................................................... ........17 Abstrait Modèles de protection de l'information ... Régulation des interactions avec les deux les types données (Règles de certification): Tous ... diverses variations et ajouts à l'existant lister. Niveaux de sécurité - Défini ...
Tous les types de données intégrés sont abstraits, bien qu'ils les appellent rarement.
Abstraction concept
L'abstraction est un jugement ou une idée d'un certain objet qui ne contient que des propriétés importantes dans ce contexte. L'abstraction vous permet de combiner les instances d'objets du groupe, à l'intérieur desquelles les propriétés générales des objets ne peuvent pas être prises en compte, c'est-à-dire résumé d'eux. L'abstraction est un moyen efficace contre la complexité de la programmation qui permet au programmeur de se concentrer sur les propriétés essentielles des objets. Types d'abstractions: abstraction du processus et abstraction de données.
Processus d'abstraction.Tous les sous-programmes sont des abstractions de processus, ils définissent la méthode par laquelle le programme établit qu'il est nécessaire d'effectuer un processus sans spécifier les détails de la manière dont cela devrait être fait. La capacité de résumé de nombreuses parties de l'algorithme, qui est exécutée par le sous-programme, vous permet de créer, de lire et de comprendre de grands programmes. Toute abstraction de données sont des opérations définies comme abstraction de processus.
Abstraction des données.Le type de données abstrait est l'encapsulation qui ne contient que des représentations de données d'un type particulier et de sous-programme qui effectue des opérations avec des données de ce type. En utilisant le contrôle d'accès, des détails insignifiants de la description de type peuvent être masqués à partir de modules externes qui utilisent ce type. Les modules logiciels utilisant un type de données abstrait peuvent déclarer des variables de ce type, même si le type de type réel est masqué. Une instance d'un type de données abstrait est appelée objet.
La raison pour laquelle la création de l'abstraction du type de données et de l'abstraction du processus est un moyen contre la complexité, la manière de rendre des programmes volumineux et / ou complexes plus gérables.
Encapsulation
Séparer le programme sur les conteneurs de syntaxe contenant des groupes de sous-routines et de données associées logiquement. Ces conteneurs syntaxiques sont appelés modules et le processus de développement est la modularisation.
Établissant un programme des ensembles de sous-routine et de données, chacun d'entre eux peut être compilé séparément, sans réactiver le reste du programme. Cet ensemble s'appelle une unité de compilation.
L'encapsulation est un moyen de fusionner dans un seul sous-programme et des données qu'ils traitent. L'encapsulation, qui est compilée séparément, ou quelle que soit l'autre, constitue la base du système abstrait et de l'organisation logique de l'ensemble des calculs appropriés.
Types de données abstraites définies par l'utilisateur
Abstract Les types de données définis par l'utilisateur doivent avoir les propriétés suivantes:
1) La détermination de type permettant aux modules logiciels de déclarer des variables de ce type, tout en créant une représentation réelle de ces variables en mémoire.
2) Ensemble d'opérations pour les manipulations avec des objets ce type.
Définition formelle d'un type de données abstraite dans le contexte des types définis par l'utilisateur: un type de données abstrait est un type de données qui répond aux deux conditions suivantes.
La présentation (définition de type) et les opérations sur les objets de ce type sont contenues dans une seule syntaxe, les variables de ce type peuvent être créées dans d'autres modules.
La présentation de ce type d'objets est masquée de modules logiciels à l'aide de ce type, vous pouvez effectuer des opérations directement fournies dans le type de type.
L'emballage du type et des opérations dans une unité syntaxique distincte vous permet d'organiser un programme sous la forme d'unités logiques pouvant être compilées séparément. Deuxièmement, il est possible de modifier les présentations d'objets de ce type ou de ce fonctionnement avec eux dans une partie distincte du programme. À la partie cache de la présentation du type, il y a des avantages. Les clients ne peuvent pas "voir" des détails de la présentation des objets et leur code ne dépend pas de cette présentation. Ainsi, les présentations d'objets peuvent être modifiées à tout moment sans nécessiter de modifications au code du client. Un autre avantage évident et important de la dissimulation d'informations est une fiabilité accrue. Les clients ne peuvent pas modifier directement les principales représentations des objets délibérément, ni par hasard, augmente donc l'intégrité de tels objets. Les objets ne peuvent être modifiés qu'à l'aide des opérations fournies pour cela.
Type de développement de types
Il devrait y avoir une occasion de rendre le nom de type et les en-têtes de sous-programmes visibles dans les clients d'abstraction. Cela permet aux clients de déclarer les variables du type abstrait et de les manipuler avec des valeurs. Malgré le fait que le nom de type doit être visible de l'extérieur, sa définition doit être cachée.
Il existe très peu d'opérations incorporées qui peuvent être effectuées avec des objets de types abstraits, contrairement aux opérations fournies par la détermination du type. Ces opérations comprennent des affectations, ainsi que des contrôles sur l'égalité et les inégalités. Si la langue ne permet pas aux utilisateurs de surcharger l'opération d'affectation, il doit être intégré. Les chèques d'égalité et d'inégalité dans certains cas doivent être prédéterminés à l'avance et dans d'autres - non. Le développeur de type doit définir les opérations pour la plupart des types de données abstraites elles-mêmes.
Les langages de SmallTalk, C ++ et Java prennent directement en charge les types de données abstraits.
Types de données abstraites en C ++
Les langues ADA et MODULA-2 fournissent une encapsulation pouvant être utilisée lors de la modélisation des types de données abstraits, en C ++, le concept d'une classe qui prend en charge directement les types de données abstraits est saisi. Dans les classes C ++, ce sont des types, et les paquets de langue ADA et les modules de langue modula-2 ne sont pas. Les packages et les modules sont importés en permettant à un programme d'importation de déclarer des variables de tout type défini dans l'emballage ou le module. Dans le programme en C ++, des variables sont déclarées en tant qu'entités ayant le type de cette classe. Ainsi, les classes sont beaucoup plus comme des types intégrés que les packages ou les modules. L'unité logicielle qui voit le package dans la langue ADA ou le module de MODULA-2 a accès à toutes les entités ouvertes simplement par leurs noms. L'unité logicielle C ++, qui annonce une instance de la classe, a également accès à toutes les entités ouvertes de cette classe, mais uniquement à travers une instance de cette classe.
