Le composant orienté objet de la langue C ++ a des fonctionnalités très puissantes. En C ++, une machine de classe développée vous permet de mettre en place des types de données personnalisés. La surcharge d'opérateurs embarqués pour les types d'utilisateurs vous permet de profiter de ces types avec toutes les fonctionnalités fournies dans la langue des types embarqués. Cela donne des termes pour lire le système de types intégrés de langue C ++ extensible.
La classe de langue C ++ est une généralisation des langues de la S. des structures de la langue avec la classe diffère à deux égards. Premièrement, dans la classe, non seulement des données, mais les fonctions sont combinées. Deuxièmement, les éléments de classe sont dotés de droits d'accès. La combinaison de données et de fonctions vous permet de relier les données et les opérations qui doivent être effectuées avec eux, les droits d'accès vous permettent d'encapsuler (masquer) la mise en œuvre de la classe.
Dans la langue C ++, les types d'utilisateurs peuvent être dotés des propriétés de l'héritage et du polymorphisme. Cela permet au programmeur de développer des systèmes logiciels hiérarchiques.
Le fait qu'il existe une norme approuvée en 1998, qui définit la syntaxe C ++ et sa bibliothèque standard.
Notez que dans la programmation orientée objet L'attention de l'attention est l'attention des données et non des algorithmes comme se produit dans la programmation procédurale.
Programmation généralisée
La base de la programmation généralisée est l'utilisation de modèles dites de fonctions et de modèles de classe. L'utilisation de tels modèles est associée au fait que les algorithmes de traitement de données sont souvent faiblement dépendants du type de données qu'ils traitent. Les informations sur le type de données qui doivent être traitées dans ce cas sont facilement transmises via les paramètres appelés types généralisés. Donnons un exemple de modèle de fonction destiné à l'échange de valeurs de deux variables.
modèle.
Le code de programme ci-dessus commence par la définition du modèle de fonction SWAP (). Le modèle de fonction est différent de la définition de la fonctionnalité habituelle par la présence d'un préfixe supplémentaire, qui commence par la plaquette de référence réservée. Les crochets angulaires contiennent la dite liste des paramètres de modèle. Dans cet exemple, cette liste ne contient qu'un seul élément constitué d'un dictionnaire réservé du modèle du paramètre de modèle. Le mot réservé Shallows selon lequel le paramètre Modèle est totalement rempli à la catégorie des types généralisés (d'autres variétés de paramètres de modèle).
Dans la fonction d'appel qui
Sur le chemin de la programmation orientée objet
Il est bien connu que la complexité de la programmation est principalement due à la complexité des tâches résolues. La principale façon de surmonter ces difficultés est la décomposition de la tâche. La décomposition consiste à remplacer le problème initial avec un ensemble d'autres tâches moins complexes dont la décision commune devrait être donnée au résultat attendu.
Il convient de considérer le fait que la décomposition ne conduit pas au succès. En pratique, il est souvent nécessaire de faire face à la situation lorsque la partie du programme responsable de la décision de subats individuels fonctionne, et l'ensemble du programme n'est généralement pas. Cela se produit s'il existe de fortes interconnexions entre des parties individuelles du programme.
L'utilisation de l'abstraction vous permet de faire une solution à des tâches individuelles relativement indépendantes. En effet, l'abstraction est associée à la mise en évidence dans certains phénomènes, événement ou objet des caractéristiques essentielles. Cela devrait finalement aider à réduire la relation entre les composants individuels du programme.
Au début des langages de programmation, la soi-disant abstraction d'action ou abstraction procédurale. L'abstraction de l'action est mise en œuvre à l'aide de sous-routines (langue c).
Il existe deux types principaux d'abstractions:
Action d'abstraction (abstraction de procédure).
Abstraction essentielle (type de données abstrait).
L'abstraction d'action ou une abstraction procédurale est mise en œuvre dans la langue C ++ à l'aide de l'appareil de fonction. En utilisant des fonctions, le programmeur a la capacité d'élargir que de nombreuses opérations intégrées fournies par la langue.
Lorsque l'utilisation de la programmation procédurale est la seule méthode d'abstraction prise en charge. Considérons des facteurs fournissant un soutien à la langue de construction:
la présence d'une conception spéciale de syntaxe conçue pour implémenter l'abstraction (définition de la fonction).
la possibilité de séparer l'interface des ventes.
cacher la mise en œuvre de l'algorithme qui implémente l'action du client.
L'abstraction de l'entité est étroitement liée au problème de la création de types de données utilisateur. Le fait est que, dans la pratique, il se pose souvent la nécessité de modéliser les concepts qui existent dans le domaine pour lequel le programme est en cours d'élaboration. Cela conduit à la nécessité d'avoir un appareil qui vous permet de créer des types de données utilisateur. Il est intéressant d'examiner la question de la question suivante: vous ne pouvez pas non plus dans la langue de type langue avec la mise en œuvre de l'abstraction d'entités. Depuis l'énoncé précédemment, vous pouvez noter un fait important qui peut affecter négativement la tentative de mise en œuvre d'une abstraction: dans la langue, il n'y a pas de conception syntaxique conçue à ces fins.
Premièrement, considérez une question très importante, comment pouvez-vous décrire l'abstraction d'entités. Pour ce faire, nous nous tournons vers le concept qui est souvent utilisé dans la programmation moderne. Nous parlons d'un type de données abstrait.
Dernière mise à jour: 09/28/2017
Avec la sortie de la version 2.0 cadre .Net a commencé à maintenir les types généralisés (Generics), ainsi que la création de méthodes généralisées. Pour comprendre les caractéristiques de ce phénomène, examinez d'abord le problème qui pourrait survenir avant l'apparition des types généralisés. Regardons l'exemple. Supposons que nous définissions une classe pour soumettre un compte bancaire. Par exemple, il pourrait ressembler à ceci:
Compte de classe (Public Int ID; Ensemble;) Public int Somme (Obtenir; Set;)))
La classe de compte définit deux propriétés: ID est un identifiant unique et une somme - le montant sur le compte.
Ici, l'identifiant est défini comme une valeur numérique, c'est-à-dire que les comptes bancaires seront des valeurs 1, 2, 3, 4, etc. Cependant, les valeurs de chaîne sont également souvent utilisées pour l'identifiant. Et dans les valeurs numériques et de chaîne ont ses avantages et ses inconvénients. Et au moment de la classe d'écriture, nous ne pouvons pas savoir exactement qu'il est préférable de choisir de stocker les chaînes d'identifiant ou les chiffres. Ou peut-être que cette classe sera utilisée par d'autres développeurs qui peuvent avoir leur propre opinion sur cette question.
Et à première vue, pour sortir une telle situation, nous pouvons définir une propriété d'identification comme une propriété de type d'objet. Étant donné que le type d'objet est un type universel, à partir duquel tous les types héritent, respectivement, dans les propriétés de ce type, nous pouvons sauver des chaînes et des chiffres:
Compte de classe (ID d'objet public (GET; SET;) PUBLIC INT SUM (GET; SET;)))
Ensuite, cette classe peut être utilisée pour créer des comptes bancaires dans le programme:
Compte de compte1 \u003d nouveau compte (somme \u003d 5000); Compte de compte2 \u003d nouveau compte (somme \u003d 4000); Compte1.id \u003d 2; Compte2.id \u003d "4356"; int ID1 \u003d (int) compte1.Id; String ID2 \u003d (String) Compte2.Id; Console.writeine \u200b\u200b(ID1); Console.writine (ID2);
Tout semble être merveilleux, mais une telle solution n'est pas très optimale. Le fait est que dans ce cas, nous sommes confrontés à des phénomènes tels que l'emballage (boxe) et déballage (non-boxing).
Donc, lors de l'attribution d'un ID d'identifiant ID, la valeur de l'int, cette valeur est emballée sur le type d'objet:
Compte1.id \u003d 2; // Emballage dans les valeurs INT en type d'objet
Pour revenir pour obtenir des données dans la variable de type INT, vous devez effectuer un déballage:
Int ID1 \u003d (int) compte1.Id; // déballage dans le type int
L'emballage (boxe) implique la conversion d'un objet de type significatif (par exemple, type INT) sur le type d'objet. Lors de l'emballage, l'environnement CLR de langue générale enveloppe une valeur à un objet de type System.Object et l'enregistre dans un tas contrôlé (HYPE). Déballage (non-boxing), au contraire, suppose la conversion d'objet du type d'objet à type important. L'emballage et le déballage entraînent une réduction des performances, car le système doit être nécessaire pour effectuer les transformations nécessaires.
En outre, il y a un autre problème - le problème de la sécurité de type. Nous aurons donc une erreur lors de l'exécution du programme, si vous écrivez comme suit:
Compte de compte2 \u003d nouveau compte (somme \u003d 4000); Compte2.id \u003d "4356"; int ID2 \u003d (int) compte2.Id; // exception InvalidcasteException
Nous ne savons peut-être pas ce que représente exactement l'objet, et lorsque vous essayez d'obtenir un numéro dans ce cas, nous rencontrerons une exception invalide.
Ces problèmes ont été conçus pour éliminer les types généralisés. Les types généralisés vous permettent de spécifier un type spécifique qui sera utilisé. Par conséquent, je définirai le compte de classe comme conservé:
Compte de classe
Supports d'angle dans le compte de description Class
Par exemple, au lieu de paramètre T, vous pouvez utiliser l'objet Int, c'est-à-dire le numéro représentant le numéro de compte. Il peut également s'agir d'un objet de chaîne ou d'une autre classe ou structure:
Compte
Étant donné que la classe de compte est généralisée, alors lors de la détermination de la variable après le type de type des supports angulaires, vous devez spécifier le type qui sera utilisé à la place du paramètre universel T. Dans ce cas, les objets de compte sont saisis par int et chaîne:
Compte
Par conséquent, le premier objet de l'ID de propriété Account1 aura un type int, et l'objet Account2 est le type String.
Lorsque vous essayez d'attribuer la valeur de l'ID de variable d'un autre type, nous obtiendrons une erreur de compilation:
Compte
Ainsi, nous évitons les problèmes de sécurité. Ainsi, en utilisant une option de classe généralisée, nous réduisons le temps nécessaire pour effectuer et le nombre d'erreurs potentielles.
Les valeurs par défaut
Parfois, il est nécessaire d'attribuer une certaine valeur initiale, y compris NULL pour assigner des paramètres universels variables. Mais nous ne pouvons pas l'affecter directement:
T id \u003d null;
Dans ce cas, nous devons utiliser l'opérateur par défaut (T). Il attribue des types de référence sous forme de valeur null et les types de valeurs sont 0:
Compte de classe
Domaines statiques des classes généralisées
Lors de la frappe d'une classe généralisée, un certain type créera un ensemble de membres statiques. Par exemple, la classe de compte définit le champ statique suivant:
Compte de classe
Maintenant, préférez les types de classe de classe AT et la chaîne:
Compte
En conséquence, pour compte
Utiliser plusieurs paramètres universels
Les généralisations peuvent utiliser plusieurs paramètres universels en même temps, ce qui peut représenter différents types:
Transaction de classe.
Ici, la classe de transation utilise deux paramètres universels. Appliquer cette classe:
Compte
Ici, l'objet de transaction est saisi par types de comptes
Méthodes généralisées
Outre des classes généralisées, vous pouvez également créer des méthodes généralisées qui utiliseront également des paramètres universels. Par example:
Programme de classe (String args) (int x \u003d 7; int y \u003d 25; échange
Ici, il est défini une méthode de swap transmise qui prend les paramètres sur le lien et modifie leurs valeurs. Dans ce cas, peu importe quel type de ces paramètres représentent.
Dans la méthode principale, appelez la méthode Swap, tapez-la avec un type spécifique et transmettez-la de certaines valeurs.
Ensuite, sous la forme de polymorphisme paramétrique dans et ses descendants, puis dans de nombreuses langues orientées objet, telles que C ++, Java, objet Pascal, Eiffel, Langues pour la plate-forme .NET et d'autres.
Méthodologie de la programmation généralisée
la programmation Généralisée est considérée comme une méthode de programmation basée sur la séparation des structures et des algorithmes données par l'utilisation de descriptions abstraites des exigences. Les descriptions des exigences abstraites sont une extension du concept de type de données abstraite. Au lieu de décrire un type distinct dans la programmation généralisée, une description des types de familles ayant une interface commune et un comportement sémantique est utilisée (eng. Comportement sémantique). Un ensemble d'exigences décrivant l'interface et le comportement sémantique est appelé concept (eng. concept). Ainsi, l'algorithme écrit dans un style généralisé peut être utilisé pour tous les types qui le satisfont de leurs concepts. Une telle opportunité s'appelle polymorphisme.
Dire ce type des modèles Concept (est un modèle de concept) s'il répond à ses exigences. Concept est clarification Un autre concept, s'il complète ce dernier. Les exigences de concept contiennent les informations suivantes:
- Expressions admissibles (Anglais Expressions valides) - Programmation des expressions linguistiques qui doivent être compilées avec succès pour des types qui simulent le concept.
- Types associés (Anglais. Types associés) - Types auxiliaires ayant une certaine attitude envers le concept de modélisation de type.
- Invariants (Eng. Invariants) - Ces caractéristiques des types qui doivent être constamment véridiques pendant l'exécution. Généralement exprimé sous forme de conditions préalables et de postlasie. Le non-respect des conditions préalables implique l'imprévisibilité de l'opération correspondante et peut conduire à des erreurs.
- Garanties de complexité (ENG. Garanties de complexité) - le temps maximum pour effectuer une expression autorisée ou exigences maximales À diverses ressources lors de l'exécution de cette expression.
Approche alternative de la définition de la programmation généralisée qui peut être appelée programmation de type de données résumée (Anglais. DataType Programmation générique) a été proposée par Richard Berry et Lambert Meertenc. Ce sont les paramètres des types de données sont les paramètres des programmes généralisés. Pour ce faire, dans le langage de programmation est introduit nouveau niveau Abstraction, nommément paramétrisation par rapport aux classes d'algèbres avec une signature variable. Bien que les théories des deux approches ne dépendent pas du langage de programmation, l'approche de la chaîne de masse - Stepanova, qui met l'accent sur l'analyse des concepts, faite C ++ avec sa plate-forme principale, tandis que la programmation généralisée des types de données utilise presque exclusivement haskell et ses options.
Mécanisme général
Les moyens de programmation généralisée sont mis en œuvre dans les langages de programmation sous la forme de certains outils syntaxiques qui permettent de décrire les données (types de données) et les algorithmes (procédures, fonctions, méthodes), paramétrés par types de données. La fonction ou le type de données décrit explicitement les paramètres formels-types. Cette description est généralisée et sous sa forme d'origine est directement utilisée ne peut pas être.
Dans ces endroits du programme, où le type généralisé ou la fonction est utilisée, le programmeur doit spécifier explicitement le paramètre de type réel spécifiant la description. Par exemple, une procédure de réarrangement généralisée dans les lieux de deux valeurs peut avoir un type de paramètre qui détermine le type de valeurs qu'elle change dans des endroits. Lorsque le programmeur doit être échangé par deux valeurs entières, il provoque une procédure avec un paramètre "entier" et deux paramètres - entiers lorsque deux lignes - avec le paramètre "chaîne" et deux paramètres - lignes. Dans le cas des données, le programmeur peut, par exemple, décrire la "liste" de type généralisée avec un paramètre de type qui détermine le type de valeurs stockées dans la liste. Puis, en décrivant les listes réelles, le programmeur doit spécifier un type généralisé et paramètre de type, obtenant ainsi une liste désirée avec la même description.
Le compilateur, rencontrant un appel à un type ou une fonction généralisée, exécute les procédures de contrôle de type statique nécessaires, évalue la possibilité de spécification spécifiée et une évaluation positive génère le code, substituant le type de paramètre réel à la place du paramètre de type formel. dans la description généralisée. Naturellement, pour l'utilisation réussie de descriptions généralisées, les types de paramètres réels doivent satisfaire certaines conditions. Si la fonction généralisée compare les valeurs valeur paramètre, tout type spécifique utilisé, il doit prendre en charge l'opération de comparaison si les valeurs des paramètres variables de type doivent fournir une affectation spécifique.
Programmation généralisée dans les langues
C ++.
Dans la langue C ++, la programmation généralisée est basée sur le concept de "modèle", noté mot-clé modèle.. Largement utilisé dans bibliothèque standard C ++ (voir STL), ainsi que dans les bibliothèques de Boost tiers, Loki Bibliothèques. Une grande contribution à l'émergence de moyens développés de programmation généralisée en C ++ Alexander Stepanov.
À titre d'exemple, nous donnons une fonction de modèle (généralisation) qui retourne plus important Des deux.
// Description du modèle de fonction Modèle.< typename T > T max (t x, t y) (si (x< y ) return y ; else return x ; } ... // Appliquer une fonction spécifiée par le modèle Int A \u003d max (10, 15); ... double f \u003d max (123.11, 123.12); ...
ou modèle (généralisation) d'une classe de littérature:
modèle.< class T > Liste de classe (/ * ... * / Public: Void Ajouter (Const T & Element); Bool Trouver (const t & Element); / * ... * /);
Java.
Java fournit des outils de programmation généralisés basés sur C ++, à commencer par la version J2SE 5.0. Dans cette langue il y a génériques. ou "Type T Conteurs" est un sous-ensemble de programmation généralisée.
.Rapporter
// http://digitalmars.com/d/2.0/template.html. Modèle FOO (T, R ...) // Type T-Type, R - Ensemble de types (Void Foo (T T, R R) (Writeln (T). Statique Si (r longueur) // si plusieurs arguments foo (R); // faire le reste des arguments )) Main () void (foo (1, "a", 6,8);) / ++++++++++++++++++++++++++++++ +++++++++++++++++ +++++ /
Les moyens de programmation généralisée sont mis en œuvre dans les langages de programmation sous la forme de certains outils syntaxiques qui permettent de décrire les données (types de données) et les algorithmes (procédures, fonctions, méthodes), paramétrés par types de données. La fonction ou le type de données décrit explicitement les paramètres formels-types. Cette description est généralisée et sous sa forme d'origine est directement utilisée ne peut pas être.
Dans ces endroits du programme, où le type généralisé ou la fonction est utilisée, le programmeur doit spécifier explicitement le paramètre de type réel spécifiant la description. Par exemple, une procédure de réarrangement généralisée dans les lieux de deux valeurs peut avoir un type de paramètre qui détermine le type de valeurs qu'elle change dans des endroits. Lorsque le programmeur doit être échangé par deux valeurs entières, il provoque une procédure avec un paramètre "entier" et deux paramètres - entiers lorsque deux lignes - avec le paramètre "chaîne" et deux paramètres - lignes. Dans le cas de données, le programmateur peut, par exemple, décrire le type généralisé « liste » avec un paramètre de type qui détermine le type de valeurs stockées dans la liste. Ensuite, lorsque vous décrivez les listes réelles, le programmeur doit spécifier un type et un type de paramètre généralisé, obtenant ainsi toute liste souhaitée avec la même description.
Le compilateur, rencontrant un appel à un type ou une fonction généralisée, exécute les procédures de contrôle de type statique nécessaires, évalue la possibilité de spécification spécifiée et une évaluation positive génère le code, substituant le type de paramètre réel à la place du paramètre de type formel. dans la description généralisée. Naturellement, pour l'utilisation réussie de descriptions généralisées, les types de paramètres réels doivent satisfaire certaines conditions. Si la fonction généralisée compare les valeurs de paramètre de valeur, tout type spécifique utilisé doit prendre en charge l'opération de comparaison si les valeurs de paramètre de type variable doivent fournir une affectation spécifique.
Méthodes de mise en œuvre
Deux moyens principaux de mettre en œuvre la prise en charge de la programmation généralisée dans le compilateur sont connus.
- Inverser le nouveau code pour chaque spécification. Dans ce mode de réalisation, le compilateur considère la description généralisée sous forme de modèle de texte pour créer des options. Lorsqu'un compilateur nécessite une nouvelle concrétisation d'un type généralisé ou d'une procédure, il crée un nouveau type de type ou procédure, en utilisant proprement le type paramètre là. C'est, ayant une caractéristique généralisée de la permutation des éléments, le compilateur, après avoir rencontré son appel à un type entier, créer une fonction de la permutation des entiers et substituer son appel au code, puis, après avoir rencontré un appel à Un type de chaîne - Créez une fonction de permutation de chaîne, qui n'est pas associée au premier. Cette méthode offre une vitesse maximale, car les options de spécification deviennent des fragments différents du programme, chacun d'entre eux peut être optimisé pour son paramètre de type, et personne n'inclut le code. Éléments excédentairesassocié à la transformation de test ou de type à la phase d'exécution du programme. L'inconvénient de c'est que l'utilisation active des types et des fonctions généralisées avec différents types-paramètres, la taille du programme compilé peut se développer beaucoup, parce que même pour les fragments de la description pour différents types Ne diffèrent pas, le compilateur génère toujours un code séparé. Cet inconvénient peut être couvert par la génération partielle du code général (une partie de la description généralisée, qui ne dépend pas des types de paramètres de type, est effectuée de manière particulière et le compilateur génère un code unique pour tous les nodules). Mais ce mécanisme Il donne la possibilité naturelle de créer des types et précise des fonctions généralisées spéciales (généralement fortement optimisé manuellement) pour certains types de paramètres.
- La génération du code, qui lors de l'exécution effectue la transformation des paramètres réels types d'un type avec lequel fonctionne réellement. Dans ce cas, au stade de la compilation, le compilateur ne vérifie que les types de types et inclut le type paramètre de conversion à la commande de conversion type total. Le code qui définit le fonctionnement d'un type ou d'une fonction généralisée est disponible dans le programme compilé en une seule instance, et les contrôles de conversion et de test sont effectués de manière dynamique pendant le programme. Dans ce mode de réalisation, il est généré, en règle générale, de code plus compact, mais le programme s'avère être plus lent que dans la première version, en raison de la nécessité d'effectuer des opérations supplémentaires et moins de capacités d'optimisation. De plus, le code compilé pour les types de paramètres de type n'inclut pas toujours des informations dynamiques sur les types (dans la première version intégrée, s'il est généralement pris en charge, car la spécification pour chaque paramètre de type est différente), qui détermine certaines restrictions sur l'utilisation de types et de fonctions généralisées. Ces restrictions sont, par exemple, en Java.
Programmation généralisée dans les langues
C ++.
En C ++, la programmation généralisée est basée sur le concept de "modèle", désigné par un mot clé modèle.. Il est largement utilisé dans la bibliothèque standard C ++ (voir STL), ainsi que dans les bibliothèques BOOST tiers, Alexander Stepanov.
À titre d'exemple, nous donnons une fonction généralisée qui renvoie la plus grande valeur de deux.
// Description de la fonction de modèle Modèle.
Java.
Java fournit des outils de programmation généralisés basés sur C ++, à commencer par la version J2SE 5.0. Dans cette langue il y a génériques. ou "Type T Conteurs" est un sous-ensemble de programmation généralisée.
.Rapporter
Exemplaire
RÉ.
Dans la langue « D », les moyens de programmation généralisée ont été considérablement évolué par rapport à C ++, tant dans le composant procédural et orienté objet. Une représentation linguistique était beaucoup plus facile.
Un exemple de génération récursive basée sur les modèles D:
// http://digitalmars.com/d/2.0/template.html. Modèle FOO (T, R ...) // Type T-Type, R - Ensemble de types (Void foo (t t t, r r) (Writefln (t); statique si (R.Length) // Si plus d'arguments foo (r); // faire le reste des arguments )) Main () void (foo (1, "a", 6,8);) / ++++++++++++++++++++++++++++++ +++++++++++++++++ +++++ /
Fondation Wikimedia. 2010.
Regardez quelle est la "programmation généralisée" dans d'autres dictionnaires:
programmation généralisée - - - [E.S. Alexseev, A.A. Hukeev. anglais anglais dictionnaire Selon l'ingénieur du système. Moscou 1993] Thèmes informatique En général, en programmation généraliséeGP ... Annuaire Traducteur technique
Conception moderne C ++
Cet article devrait être Vico. Veuillez vous référer en fonction des règles d'articles. Légende ... Wikipedia
Ce terme a également d'autres significations, voir C. Voir aussi: C (Langage de programmation) C ++ Semantiques: MultiParaAdigmal: Orienté objet, Généralisé, procédural, métaprogrammation Type d'exécution: compilé par ... Wikipedia
Ce terme a également d'autres significations, voir D. D Sémantics: MultiPariadigm: Type d'exécution de l'impératif, orienté objet, de programmation généralisée: Le compilateur est apparu dans: 1999 Auteur (s) ... Wikipedia
Voir aussi: C (Langage de programmation) C ++ Semantiques: MultiParaAdigmal: objet orienté objet, généralisé, procédural, métaprogrammation Type d'exécution: Composé par apparu dans: 1985 Auteur (s): Björn Sturastrup ... Wikipedia
Ce terme a d'autres valeurs, voir F (valeurs). Heading approprié Cet article F #. Il est montré de manière incorrecte en raison de limitations techniques. F # Classe Langue: MultiParadigre: fonctionnel, orienté objet, ... ... Wikipedia
Cette combinaison de caractères désigne souvent souvent l'accord ou la tonalité du major numérique F♯ est un langage de programmation fonctionnel usage général. Développé par Don Syme (eng. Don Syme) dans Microsoft Research à Cambridge. Structure F♯ à bien des égards ... ... Wikipedia
F # est une langue de fonctionnement de la programmation générale. Développé par Don Syme (eng. Don Syme) dans Microsoft Research à Cambridge. La structure F # est en grande partie similaire à la structure des bibliothèques et de l'environnement d'exécution.net. Certaines tâches sont résolues ... ... Wikipedia
Ce terme a d'autres valeurs, voir Loki (valeurs). Loki Library pour la langue de programmation C ++ a été écrite par Andrei Alexandrescus dans le cadre du livre "Modern Design on C ++: programmation généralisée et modèles appliqués ... ... Wikipedia
Livres
- Programmation. Principes et pratiques utilisant C ++, Sturastrup Bjarne. Ce livre n'est pas un manuel en C ++, il s'agit d'un manuel de programmation. Malgré le fait que son auteur est l'auteur de C ++, le livre n'est pas dédié à ce langage de programmation; Il joue ...
Programmation généralisée Programmation généralisée - code d'écriture pouvant être utilisé à plusieurs reprises avec des objets de nombreux types différents.
Dans les versions antérieures de Java, cela a été réalisé par héritage, arraylist contenait un éventail de référence à l'objet. Chaque fois que la valeur a été supprimée, il était nécessaire d'effectuer des types.
Programmation généralisée - paradigme de programmation, qui consiste en une telle description des données et des algorithmes pouvant être appliqués à divers types Données sans changer cette description elle-même. Dans l'une ou l'autre, soutenu par différentes langages de programmation.
Les généralisations (génériques) sont le changement de langue le plus important programmation Java À partir de la version 1.0. L'apparition des généralisations en Java 5.0 est devenu le résultat des premières exigences de la spécification Java (JVA 14), qui ont été formulées en 1999. Les généralisations nécessaires parce qu'ils vous permettent d'écrire un code plus sûr qui est plus facile à lire que le code surchargé par la variable d'objets et types de types. Généralisations sont particulièrement utiles pour les classes de collections telles que l'ArrayList omniprésente.
Généralisations sont similaires - au moins en externe - sur des modèles en C ++. En C ++, comme dans Java, des modèles ont d'abord été ajoutés pour supporter des collections strictement typées. Cependant, d'autres demandes ont été ouvertes au fil des ans.
Les possibilités de programmation généralisée sont d'abord apparues dans les années 70 dans les langues CLU et ADA, puis dans de nombreuses langues orientées objet, telles que C ++, Java, D et des langues pour la plate-forme .NET. Le mécanisme général des moyens de programmation généralisé est réalisée sous la forme de certaines syntaxes. La fonction ou le type de données décrit explicitement les paramètres formels-types. Cette description est généralisée et sous sa forme d'origine est directement utilisée ne peut pas être.
Dans ces endroits du programme, où le type ou la fonction généralisée est utilisé, le programmeur doit spécifier explicitement le type de paramètre en spécifiant la description. Le compilateur, rencontrant un appel à un type ou une fonction généralisée, exécute les procédures de contrôle de type statique nécessaires, évalue la possibilité de spécification spécifiée et une évaluation positive génère le code, substituant le type de paramètre réel à la place du paramètre de type formel. dans la description généralisée.
Naturellement, pour l'utilisation réussie de descriptions généralisées, les types de paramètres réels doivent satisfaire certaines conditions. Si la fonction généralisée compare les valeurs de paramètre de valeur, tout type spécifique utilisé doit prendre en charge l'opération de comparaison si les valeurs de paramètre de type variable doivent fournir une affectation spécifique. Les méthodes de mise en œuvre sont connues deux moyens principaux de mettre en œuvre la prise en charge de la programmation résumée dans le compilateur.
Inverser le nouveau code pour chaque spécification. Dans ce mode de réalisation, le compilateur considère la description généralisée sous forme de modèle de texte pour créer des options. Lorsqu'un compilateur nécessite une nouvelle concrétisation d'un type généralisé ou d'une procédure, il crée un nouveau type de type ou procédure, en utilisant proprement le type paramètre là. C'est-à-dire avoir une caractéristique généralisée de la permutation des éléments, le compilateur, ayant rencontré son appel à un type entier, crée une fonction de la permutation des entiers et remplacez son appel au code, puis, après avoir rencontré un appel à un type de chaîne - créer une fonction de permutation de chaîne, qui est non associée à la première. Cette méthode offre une vitesse maximale. Son inconvénient est qu'avec l'utilisation active des types généralisés et des fonctions avec différents types-paramètres, la taille du programme compilé peut augmenter beaucoup, car même pour ces fragments de description qui ne sont pas différents pour différents types, le compilateur génère toujours une code. Cet inconvénient peut être couvert par la génération partielle du code général (une partie de la description généralisée, qui ne dépend pas des types de paramètres de type, est effectuée de manière particulière et le compilateur génère un code unique pour tous les nodules). . La génération du code, qui lors de l'exécution effectue la transformation des paramètres réels types d'un type avec lequel fonctionne réellement. Dans ce cas, au stade de la compilation du programme, le compilateur ne vérifie que les types de types et comprend la commande de paramètre de type conversion du type commun dans le code. Le code qui définit le fonctionnement d'un type ou d'une fonction généralisée est disponible dans le programme compilé en une seule instance, et les contrôles de conversion et de test sont effectués de manière dynamique pendant le programme. Dans ce mode de réalisation, il est généré, en règle générale, de code plus compact, mais le programme s'avère être plus lent que dans la première version, en raison de la nécessité d'effectuer des opérations supplémentaires et moins de capacités d'optimisation. De plus, le code compilé pour les types de paramètres de type n'inclut pas toujours des informations dynamiques sur les types (dans la première version intégrée, s'il est généralement pris en charge, car la spécification pour chaque paramètre de type est différente), qui détermine certaines restrictions sur l'utilisation de types et de fonctions généralisées. Il y a des restrictions similaires dans Java.
La classe généralisée est une classe avec une ou plusieurs variable de type. Paire de classe () La variable de type est utilisée pour spécifier le type de comportement et de types de champs et de variables locales. Ensuite, vous pouvez créer un objet d'un type généralisé, substituant le nom du type au lieu d'une variable de type. Paire ()
Certaines limitations de la généralisation 1. Les paramètres de type ne peuvent accepter les types primitifs. 2. Les tableaux de types paramétrés ne sont pas autorisés. 3. Vous ne pouvez pas créer d'instances de types variables. 4. Le contexte statique n'est pas autorisé. Nomination de la programmation généralisée Programmation généralisée signifie la rédaction de code pouvant être utilisé à plusieurs reprises avec des objets de nombreux types différents. Cela facilite la lecture de votre code. Vous pouvez immédiatement comprendre que cette liste de tableau particulière contient des objets de chaîne. Le compilateur peut également utiliser ces informations avec succès. Aucune création n'est requise lorsque vous appelez get (). Le compilateur sait que le type de retour de cette méthode est la chaîne, pas l'objet: String FileName \u003d Files.get (0); Le compilateur sait également que la méthode Ajouter () dans ArrayList a un paramètre de type de chaîne. Il est beaucoup plus sûr que de traiter avec le type d'objet. Maintenant, le compilateur peut surveiller de manière à ne pas insérer un objet de type incorrect. Par exemple, l'opérateur suivant ne compile pas: Files.Ajouter (nouveau fichier ("...")); // Dans ArrayList, vous pouvez ajouter // L'erreur d'achèvement des chaînes d'objets est bien meilleure que l'exclusion de type apportant lors de l'exécution. Dans cette attraction des paramètres de type: ils facilitent votre programme lisible et plus sécurisé. Les classes généralisées comme ArrayList, utilisent faciles. Et la plupart des programmeurs Java utilisent simplement les types tels que l'arraylist - comme si elles faisaient partie de la langue, comme des tableaux de chaîne. (Bien entendu, les listes de tableaux sont meilleures que de simples tableaux, car ils peuvent se développer automatiquement.) Cependant, la classe généralisée n'est pas aussi simple. Les programmeurs qui utiliseront votre code vont essayer de substituer toutes sortes de classes au lieu de vos paramètres de type. Ils s'attendent à ce que tout le monde travaille sans restrictions ennuyeuses et confondre des messages d'erreur. Votre tâche en tant que programmeur généralisé est de prévoir toutes les applications futures possibles de votre classe. Code généralisé et machine virtuelle La machine virtuelle ne fonctionne pas avec des objets de types généralisés - tous les objets appartiennent aux classes habituelles. Dans la mesure du possible, le type correspondant à celui-ci est automatiquement créé par le type généralisé, le type de "RAW" (RAW) est automatiquement créé. Le nom de ce type coïncide avec le nom du type généralisé avec des paramètres de type à distance. Les variables de type sont supprimées et remplacées par des types de limitation (ou type d'objet, si la variable n'a pas de restrictions). Par exemple, le type «brut» pour la paire ressemble à celui indiqué ci-dessous. Paire de classe publique (objet d'abord, objet de seconde) (this.first \u003d premier; cela.seconde \u003d seconde;) Objet public getfirst () (Retour d'abord;) Objet public getecond () (Objet NouveauValeur ) (premier \u003d NEWVALUE;) VOYAGE PUBLIQUE SETSECOND (OBJECT NEWVALUE) (Deuxième \u003d NewValue) Objet privé Premier; Objet privé Deuxièmement;) Etant donné que T est une variable de type illimitée, elle est simplement remplacée par objet. En conséquence, une classe normale est obtenue comme celles que vous pouvez mettre en œuvre plus tôt avant l'apparition des généralisations dans le langage de programmation Java. Vos programmes contiennent différentes options de paires, telles que la paire ou la paire, mais une telle "Clearing" les transforme dans la paire de type "brute". Le type «brut» remplace les types de variables de la première limite ou de l'objet si aucune restriction n'est fournie. Par exemple, une variable de type dans la classe de paires n'a pas de restrictions explicites, et donc le type brut remplace T à l'objet. Supposons qu'un type légèrement différent soit déclaré: Intervalle de classe public implémente sérialisable (intervalle public (T premier, T seconde (si (deuxième)<= 0) { lower = first; upper = second; } else { lower = second; upper = first; } } ... private T lower; private T upper; } Сырой тип Interval выглядит следующим образом: public class Interval implements Serializable { public Interval(Comparable first, Comparable second) { ... } ... private Comparable lower; private Comparable upper; } Трансляция обобщенных выражений Когда ваша программа вызывает обобщенный метод, компилятор вставляет приведения, когда удаляется возвращаемый тип. Например, рассмотрим следующую последовательность операторов: Pair buddies = ...; Employee buddy = buddies.getFirst(); Подчистка getFirst() приведет к возврату типа Object. Компилятор автоматически вставит приведение к Employee. То есть компилятор транслирует вызов метода в две инструкции виртуальной машины. . Вызов сырого метода Pair.getFirst(). . Приведение возвращенного объекта Object к типу Employee. Приведения также вставляются при обращении к обобщенному полю. Предположим, что поля first и second были бы общедоступными, т.е. public. (Возможно, это нехороший стиль программирования, но вполне допустимый в Java.) Тогда в оператор Employee buddy = buddies.first; в результирующем байт-коде также будут вставлены приведения.
