Dans les années cinquante du XXe siècle, avec l'avènement des ordinateurs à tubes sous vide, le développement rapide des langages de programmation a commencé. Les ordinateurs, qui coûtaient à l’époque beaucoup plus cher que le développement de n’importe quel programme, nécessitaient un code très efficace. Ce code a été développé manuellement en langage Assembly. Au milieu des années 50, sous la direction de John Backus, un algorithme algorithmique a été développé pour IBM. langage de programmation FORTRAN. Malgré le fait qu'il y avait déjà des développements dans les langages qui convertissaient les expressions arithmétiques en code machine, la création du langage FORTRAN (FORMula TRANslator), qui offrait la possibilité d'écrire un algorithme de calcul à l'aide d'instructions conditionnelles et d'opérateurs d'entrée/sortie, est devenue le point de départ de l’ère des langages de programmation algorithmiques.

Le langage FORTRAN était nécessaire pour créer un code très efficace. Par conséquent, de nombreuses constructions de langage ont été initialement développées en tenant compte de l'architecture IBM 407. Le succès du développement de ce langage a conduit les fabricants d'autres systèmes informatiques à créer leurs propres versions de traducteurs. Dans le but d'une éventuelle unification du langage à cette époque, le langage FORTRAN IV, développé en 1966, est devenu le premier standard, appelé FORTRAN 66.

Alternative au langage FORTRAN, initialement destiné à l'architecture IBM, ALGOL (ALGOrithmic Language) a été développé sous la houlette de Peter Naur à la fin des années 50. L'objectif principal poursuivi par les développeurs de ce langage était l'indépendance vis-à-vis de l'architecture spécifique du système informatique. De plus, les créateurs du langage ALGOL ont cherché à développer un langage pratique pour décrire des algorithmes et utiliser un système de notation proche de celui adopté en mathématiques.

FORTRAN et ALGOL ont été les premiers langages axés sur la programmation calculs.

Le langage PL 1, dont les premières versions sont apparues au début des années 60, était initialement destiné à l'IBM 360 et élargissait les capacités du langage FORTRAN avec une partie du langage COBOL développé dans les mêmes années. Malgré la certaine popularité du langage PL/I parmi les programmeurs qui ont travaillé sur des ordinateurs IBM et des machines de la série EC, il présente actuellement un intérêt purement théorique.

À la fin des années 60, sous la direction de Nayard et Dahl, le langage Simula-67 a été développé, utilisant le concept de types de données définis par l'utilisateur. En fait, c’est le premier langage à utiliser le concept de classes.

Au milieu des années 70, Wirth propose le langage Pascal, qui devient immédiatement largement utilisé. Dans le même temps, à l'initiative du ministère américain de la Défense, les travaux ont commencé pour créer un langage de haut niveau appelé Ada - en l'honneur d'Ada Lovelace, programmeuse et fille de Lord Byron. La création du langage a commencé par la définition des exigences et l’élaboration des spécifications. Quatre groupes indépendants ont travaillé sur le projet, mais ils ont tous utilisé Pascal comme base. Au début des années 1980, le premier compilateur industriel pour le langage Ada a été développé.

Universel langage de programmation C a été développé au milieu des années 70 par Denis Ritchie et Ken Thompson. Le langage est devenu un langage de programmation système populaire et a été utilisé à une certaine époque pour écrire le noyau du système d'exploitation UNIX. La norme du langage C a été développée par un groupe de travail ANSI en 1982. La norme internationale pour le langage C a été adoptée en 1990. Le langage C a constitué la base du développement des langages de programmation C++ et Java.

Aux côtés des langages algorithmiques, des langages destinés au traitement des informations commerciales, ainsi que des langages d'intelligence artificielle, se sont développés en parallèle. Le premier inclut le langage COBOL (COmmon Business Oriented Language), et le second inclut les langages LISP (LISt Processing) et Prolog. Le langage LISP, développé dans les années 60 sous la direction de J. McCarthy, fut le premier langage de traitement de listes fonctionnelles largement utilisé dans la théorie des jeux.

Avec l'avènement des ordinateurs personnels, les langages sont devenus des composants d'environnements de développement intégrés. Des langages sont apparus qui sont utilisés dans divers programmes bureautiques, par exemple VBA (Visual Basic for Application).

Dans les années 90, avec la diffusion d’Internet, les possibilités de traitement distribué des données se sont élargies, ce qui se reflète dans le développement des langages de programmation. Il existe des langages orientés vers la création d'applications serveur, tels que Java, Perl et PHP, et des langages de description de documents - HTML et XML. Les langages de programmation traditionnels C++ et Pascal subissent également des changements : un langage de programmation commence à désigner non seulement la fonctionnalité du langage lui-même, mais également les bibliothèques de classes fournies par l'environnement de programmation. L'accent se déplace de la spécification des langages de programmation eux-mêmes vers la standardisation des mécanismes d'interaction des applications distribuées. De nouvelles technologies émergent - COM et CORBA, qui spécifient l'interaction d'objets distribués.

Domaines d'application des langages de programmation

Actuellement, les langages de programmation sont utilisés dans une grande variété de domaines de l'activité humaine, tels que :

• calcul scientifique (langages C++, FORTRAN, Java) ;
• programmation système (langages C++, Java) ;
• traitement de l'information (langages C++, COBOL, Java) ;
• intelligence artificielle (LISP, Prolog) ;
• activités de publication (Postscript, TeX) ;
• traitement de l'information à distance (Perl, PHP, Java, C++) ;
• description des documents (HTML, XML).

Au fil du temps, certains langages se sont développés, ont acquis de nouvelles fonctionnalités et sont restés en demande, tandis que d'autres ont perdu de leur pertinence et ont aujourd'hui, au mieux, un intérêt purement théorique. Cela est dû en grande partie à des facteurs tels que :

• la présence d'un environnement de programmation prenant en charge le développement d'applications dans un langage de programmation spécifique ;
• Facilité d'entretien et tests de programmes ;
• le coût de développement utilisant un langage de programmation spécifique ;
• clarté et orthogonalité des structures linguistiques ;
• application d'une approche orientée objet.

La plupart des programmes informatiques modernes sont écrits à l’aide de langages de haut niveau. Il est à noter que bon nombre d’entre eux ont été développés dans les années 60 et 70, mais sont toujours d’actualité. Quels autres faits sur les langages de haut niveau pouvons-nous noter ? Quels sont les types de solutions pertinentes les plus courantes ?

L'essence des langages de programmation de haut niveau

Un langage de programmation de haut niveau est un outil classé comme indépendant de la machine. Qu'est-ce que cela signifie? Le fait est que les langages de programmation sont divisés en plusieurs catégories.

Il existe un code machine : un ensemble d'algorithmes conçus pour contrôler l'utilisateur directement avec les éléments matériels de l'ordinateur. Leur essence dépendra entièrement de la machine : seuls certains algorithmes seront adaptés à des types spécifiques de PC.

Il existe des langages d'assemblage. En fait, ils constituent un complément à ceux conçus pour le contrôle de bas niveau des composants matériels du PC via le code machine. Mais pour de nombreuses raisons, les langages assembleur sont également généralement classés comme dépendants de la machine. En règle générale, ils sont adaptés à un type spécifique de composant matériel PC. Leur tâche principale est de permettre à l'utilisateur de contrôler plus facilement l'ordinateur grâce à des communications de bas niveau appropriées.

À son tour, un langage de programmation de haut niveau permet à l'utilisateur d'interagir avec le PC, quel que soit le matériel spécifique installé sur l'ordinateur. Il convient donc de le classer comme indépendant de la machine. Lors de l'écriture de systèmes d'exploitation, un langage de programmation de haut niveau est le plus souvent utilisé. Mais il existe des systèmes d’exploitation écrits en langage assembleur. Les langages de programmation de bas et de haut niveau peuvent être utilisés simultanément. Une personne, donnant des commandes de haut niveau à un PC, doit, d'une manière ou d'une autre, les transmettre à des composants matériels spécifiques, et cette fonction peut être implémentée en utilisant simultanément des langages d'assemblage avec des langages de haut niveau impliqués dans la structure du système d’exploitation.

Traducteurs

Les éléments les plus importants inclus dans les langages de programmation de haut niveau sont les traducteurs. Leur fonction peut varier. L'un des principaux domaines d'application des traducteurs est la « traduction » de commandes générées dans un langage de programmation de haut niveau en code machine compréhensible par un composant matériel PC spécifique, par exemple un processeur. Les traducteurs qui remplissent cette fonction sont également appelés compilateurs. Il existe un autre type de composants correspondants : les interprètes. Ils sont destinés, à leur tour, à « traduire » les commandes de haut niveau en commandes compréhensibles par le système d’exploitation ou tout autre programme.

Classification des langues de haut niveau

Les langages de programmation de haut niveau peuvent être classés de différentes manières. Il existe un schéma commun selon lequel ils sont répartis dans les variétés principales suivantes :

Orienté procédural (utilisé comme outil lors du traitement de l'information à n'importe quelle étape des calculs) ;

Orienté vers les problèmes (utilisé comme moyen de résoudre les problèmes industriels et d'application qui surviennent à mesure que les domaines d'application PC se développent) ;

Orienté objet (peut être des cas particuliers de langages des deux premiers types, cependant, ils sont adaptés pour être utilisés par un large éventail de développeurs avec différents niveaux de formation, par exemple sous la forme d'une solution avec une interface visuelle ).

Considérons maintenant quelques langages de programmation historiques et modernes de haut niveau qui correspondent à cette classification.

Langages orientés procédure

Ceux-ci incluent Fortran. Il est considéré comme le premier langage de programmation de haut niveau créé pour une utilisation généralisée. Caractérisé par une structure simple. BASIC est également un langage orienté procédural. Il est considéré comme l’un des plus couramment utilisés dans l’enseignement de la programmation. Un exemple d'un autre langage orienté procédural est SI. Il a été créé à l'origine pour le système d'exploitation UNIX. Sur cette base, le langage C++ a ensuite été créé, complété par des outils de programmation orientés objet. Une autre langue appartenant à cette catégorie est le Pascal. Souvent également utilisé lors de l’enseignement de la programmation. Les capacités de ce langage lui permettent d'être utilisé comme un outil très puissant pour développer des logiciels de type professionnel.

Langages orientés problèmes

Ceux-ci incluent Lisp et Prolog. Le premier langage a été développé en 1962, quelques années après la création de Fortran. Considéré donc comme le deuxième de l’histoire. Activement utilisé comme outil permettant aux programmeurs de travailler avec des chaînes de caractères. En pratique, Lisp était utilisé dans des systèmes classés comme systèmes experts, ainsi que dans ceux destinés au calcul analytique. Prolog a été largement utilisé dans le domaine de la programmation logique. En pratique, il intervient le plus souvent dans la gestion des algorithmes d’intelligence artificielle dans les systèmes concernés.

Langages orientés objet

Étudions maintenant des exemples de langages de programmation de haut niveau entrant dans la catégorie orientée objet. Parmi ceux-ci figurent Visual Basic, Delphi, Visual Fortran, le C++ mentionné ci-dessus, ainsi que Prolog ++. En fait, ils contiennent tous à la base des langages orientés procédure. Cependant, il est prévu qu'ils soient considérablement complétés par des contrôles visuels en vue d'une maîtrise ultérieure des algorithmes nécessaires par des développeurs habitués à d'autres outils. Ainsi, le premier langage de programmation de haut niveau, Fortran, peut être rapidement appris par les informaticiens grâce aux capacités de Visual Fortran. En utilisant une méthode similaire, vous pouvez rapidement maîtriser BASIC ou Prolog.

À son tour, lors de l'utilisation de Delphi, la programmation est effectuée dans le langage de haut niveau Object Pascal. Il existe un grand nombre d'autres environnements de développement logiciel classés comme langages orientés objet. Ce domaine de la technologie de développement logiciel se développe activement.

Fortran et Lisp sont les premier et deuxième langages de haut niveau

Étudions plus en détail comment est apparu le premier langage de programmation de haut niveau, Fortran, ainsi que Lisp, qui est considéré comme le second. En 1954, les développeurs d'IBM, dirigés par John Backus, ont créé un langage grâce auquel les programmeurs pouvaient grandement faciliter l'interaction avec un PC, qui jusqu'alors s'effectuait via des commandes machine ou un assembleur. Il s'appelait Fortran et devint bientôt connu en URSS sous son nom russifié. Fortran est devenu un outil populaire pour le calcul scientifique.

Le principal élément révolutionnaire proposé par les spécialistes d'IBM à la communauté était en fait ce même compilateur, conçu pour être une alternative à l'assembleur. Au cours des premières années d'écriture de programmes utilisant Fortran, de nombreux développeurs considéraient le compilateur comme une solution pas entièrement réussie, principalement du point de vue des coûts de main-d'œuvre. En effet, de nombreux codes machine ont été compilés plus simplement qu’en utilisant un traducteur. Cependant, à mesure que les performances des ordinateurs augmentaient rapidement, les programmeurs ont commencé à se rendre compte que sans utiliser de compilateur, il était extrêmement difficile de créer un logiciel efficace capable d'utiliser pleinement la puissance de calcul d'un PC. Ainsi, les initiatives des développeurs d'IBM ont été développées. Les structures syntaxiques de base du langage de programmation de haut niveau Fortran ont dans de nombreux cas commencé à être utilisées comme bases lors de la création de nouvelles solutions.

Un exemple d'obtention de résultats pratiques dans le développement de concepts intégrés dans Fortran est la création de Lisp. Ce langage a été développé en 1958, mais il est devenu largement connu un peu plus tard, en 1960. Lisp a été développé par John McCarthy et publié dans l'un des magazines populaires destinés aux informaticiens. L'objectif principal du langage en question est le traitement de listes. Lisp est devenu populaire parmi les développeurs de systèmes d’intelligence artificielle. Sur cette base, des langages tels que Planner, Scheme et Common Lisp ont été créés. Lisp a également eu une influence significative sur de nombreux outils de développement de logiciels modernes. La structure des langages de programmation de haut niveau populaires aujourd'hui repose en grande partie sur les algorithmes Fortran et Lisp.

Il sera cependant intéressant d’envisager d’autres approches de classification des outils de développement logiciel considérés.

Langages universels de haut niveau

Ainsi, les experts modernes identifient des langages universels de haut niveau. Il s'agit notamment de ceux qui ont été développés dans les années 60. Leurs principales caractéristiques :

Se concentrer sur un large éventail de tâches (principalement celles liées à l'informatique) ;

Un grand nombre de constructions de langage et d'algorithmes ;

Importance non seulement pour l'époque, mais aussi pour le stade moderne de développement de la technologie informatique ;

Support dans les langues pertinentes pour la méthodologie impérative.

Les langages universels sont fondamentaux dans le domaine concerné du développement informatique. On peut noter que jusqu'à présent, ils n'ont pas d'analogues directs en termes de structure interne. En fait, cela explique en grande partie la pertinence d'utiliser les langages correspondants dans les interfaces modernes orientées objet. Le type de données est également courant dans les langues mentionnées. Ce facteur détermine en grande partie leur polyvalence. Parmi les propriétés les plus remarquables des langues appartenant à la catégorie des langues universelles se trouve la continuité. Ainsi, historiquement, les langues ultérieures étaient généralement basées sur les concepts de leurs prédécesseurs.

Langues uniques

Certains experts informatiques classent les « langues uniques » dans une catégorie distincte. Ceux-ci incluent : APL, Cobol, Forth, SETL et CLU. Quelles sont leurs spécificités ?

L'aspect le plus important de l'APL est l'utilisation de tableaux (vecteurs et matrices) comme type structurel clé. La spécificité du langage Cobol est sa focalisation sur la sphère commerciale. Ainsi, il est conseillé de l'utiliser lors de la résolution de problèmes liés à un format standardisé de présentation des résultats. Le langage Forth se caractérise par l'utilisation de la notation postfixe des programmes, ainsi que par l'utilisation de la notation pile. SETL utilise des collections de valeurs comme l'un de ses types de données clés. CLU est également un langage de programmation de haut niveau. Sa principale caractéristique est l'utilisation du concept de travail avec des types de données abstraits. De nombreux informaticiens voient l'émergence logique de nouvelles solutions basées sur des langages uniques - comme, par exemple, le Cobol orienté objet.

Outils de programmation parallèle

Cette catégorie peut inclure un grand nombre de solutions. À leur tour, les langages de programmation parallèles peuvent avoir un grand nombre de bases de classification. Par exemple, une méthode d'organisation des processus. Cette base implique la classification des outils de programmation parallèle en fonction de la présence dans ceux-ci de :

Coroutine ;

Branches;

Les associations;

Supports parallèles ;

Algorithmes pour travailler avec des processus.

Une autre base pour classer les langages du type considéré concerne les méthodes de synchronisation des processus. Les solutions appropriées pourraient donc inclure :

Sémaphores ;

Moniteurs ;

- "rendez-vous";

Zones critiques;

Appel de procédure à distance ;

Transactions classées comme atomiques.

Les langages du type considéré incluent Modula-2, BLISS, Concurrent Pascal, DP, Argus.

Famille de langages C

Ci-dessus, nous avons examiné une solution telle que C comme exemple de langage de programmation de haut niveau. En fait, il forme toute une famille. Les langages qui lui appartiennent sont des constructions propriétaires du C. Ainsi, son ajout de divers composants orientés objet a conduit au développement du C++. Après un filtrage important d'un certain nombre de constructions C, le langage Java a émergé. On peut noter que Java a été créé en grande partie sous l'influence des concepts du projet Oberon, dirigé par Niklaus Wirth, le créateur du langage Pascal. Est-ce du JavaScript de haut niveau ? Bien sûr, oui, malgré son application étroite – en tant qu'outil de développement de pages Web. Mais les langages de programmation de haut niveau n’incluent pas notamment HTML, XML et SGML. Ils sont classés comme outils de balisage hypertexte.

Famille de langues pascales

Les langages de programmation Pascal de haut niveau forment également une famille à part. Basé sur Pascal, Oberon a en fait été créé, classé comme langage orienté objet. Une caractéristique clé d'Oberon est sa capacité à assurer la sécurité du type. Outre Oberon, les langages de la famille Pascal incluent Modula-2, ainsi que Component Pascal.

Famille de langues Ada

Fondamental dans la catégorie de langues correspondante - Ada, commandé pour les besoins du département américain de la Défense. Il a été créé à la fin des années 70 et au début des années 80. Il se caractérise par un grand nombre de fonctions, de capacités et de polyvalence. La famille de langages Ada comprend des solutions telles que Cedar, Modula 3.

Famille de langues Simula

Le langage Simula est courant dans les industries de programmation liées à la modélisation par simulation. La spécificité des solutions correspondantes réside dans l'utilisation d'un noyau spécifique. Son utilisation permet d'utiliser diverses extensions adaptées à certains domaines d'application. Basé sur Simula, le langage orienté objet Smalltalk a été créé, ainsi que BETA, qui se caractérise par la capacité de combiner des algorithmes qui reflètent le travail avec les données, les procédures et la gestion au sein d'une seule abstraction. Les objets BETA peuvent être visualisés dans différents contextes, tels que des variables, des fonctions ou des systèmes concurrents.

Travaux de cours

sur le thème : « Langages de programmation »

Introduction

1. Langages de programmation

1.1 Historique du développement des langages de programmation

2. Examen des langages de programmation modernes

2.1 C ses variétés

2.2 Pascal

2.3Fortran

2.4 DE BASE

Conclusions et offres

Liste de la littérature utilisée

Introduction

Au stade actuel de développement de la technologie informatique, il est impossible d'imaginer un spécialiste hautement qualifié qui ne connaît pas les technologies de l'information. Étant donné que l'activité de tout sujet dépend en grande partie du degré de connaissance de l'information, ainsi que de la capacité de l'utiliser efficacement. Pour s'orienter librement dans les flux d'informations, un spécialiste moderne de tout profil doit être capable de recevoir, traiter et utiliser des informations, principalement à l'aide d'ordinateurs, ainsi que de télécommunications et d'autres nouveaux moyens de communication, y compris la capacité de gérer les langages de programmation.

La pertinence de ce sujet est due au fait que les progrès de la technologie informatique ont déterminé le processus d'émergence de systèmes de signes nouveaux et diversifiés pour l'enregistrement des algorithmes - les langages de programmation.

L'objet de l'étude était les langages de programmation et l'histoire du développement des langages de programmation.

Le but du cours est d'étudier la classification des langages de programmation et leur développement.

Objectifs de recherche:

1. Afficher les informations générales et les niveaux des langages de programmation.

2. Consultez l'historique du développement des langages de programmation.

3. Passez en revue les langages de programmation modernes.

Objectifs de recherche:

1. Introduction aux langages de programmation.

2. Considération de l'histoire du développement des langages de programmation.

3. Examen des langages de programmation modernes.

Le premier chapitre traite des informations générales sur les langages de programmation et l'historique de leur développement.

Le deuxième chapitre donne un aperçu des langages de programmation modernes.

Ce travail de cours a utilisé des méthodes de recherche.

Moyens techniques utilisés : PC : Core 2 DuoE6600 2,4 GHz 2 x 4 Mo L2 ; 2 x 1 024 Mo DDR3-1 333 MHz ; NVIDIAGeForce 8600 GT 512 Mo ; Disque dur HitachiDeskstar 7K1000 1 To ; Imprimante : Canon LBP3010.

Logiciel Windows XPProfessionalSP3. Ce travail de cours a été réalisé sous Microsoft Word 2003 et d'autres programmes ont également été utilisés : Microsoft PowerPoint, Nero StartSmart.

1. Langages de programmation

Un langage de programmation est un système de notation utilisé pour décrire avec précision des programmes informatiques ou des algorithmes. Les langages de programmation sont des langages artificiels. Ils diffèrent des langues naturelles par le nombre limité de « mots » et des règles très strictes d'écriture des commandes (opérateurs). Par conséquent, lorsqu’ils sont utilisés aux fins prévues, ils ne permettent pas la libre interprétation des expressions caractéristiques du langage naturel.

Il est possible de formuler un certain nombre d'exigences pour les langages de programmation et de classer les langages en fonction de leurs fonctionnalités.

Exigences de base pour les langages de programmation :

clarté - l'utilisation dans le langage, si possible, de symboles déjà existants, bien connus et compréhensibles tant pour les programmeurs que pour les utilisateurs d'ordinateurs ;

unité - l'utilisation des mêmes symboles pour désigner des concepts identiques ou liés dans différentes parties de l'algorithme. Le nombre de ces caractères doit être aussi minimal que possible ;

flexibilité - la possibilité d'une description relativement pratique et simple des méthodes courantes de calculs mathématiques en utilisant l'ensemble limité de moyens visuels disponibles dans la langue ;

modularité - la capacité de décrire des algorithmes complexes sous la forme d'un ensemble de modules simples qui peuvent être compilés séparément et utilisés dans divers algorithmes complexes ;

sans ambiguïté - enregistrement sans ambiguïté de n'importe quel algorithme. Son absence pourrait conduire à des réponses incorrectes lors de la résolution de problèmes.

Actuellement, il existe plusieurs centaines de langages de programmation réellement utilisés dans le monde. Chacun a son propre domaine d'application.

Tout algorithme est une séquence d'instructions à la suite de laquelle vous pouvez passer des données initiales au résultat en un nombre fini d'étapes. En fonction du degré de détail des instructions, le niveau du langage de programmation est généralement déterminé - moins il y a de détails, plus le niveau du langage est élevé.

Sur la base de ce critère, on peut distinguer les niveaux de langages de programmation suivants :

· machine;

· orienté machine (assembleurs);

· indépendant de la machine (langages de haut niveau).

Les langages machine et les langages orientés machine sont des langages de bas niveau qui nécessitent de spécifier des détails fins sur le processus de traitement des données. Les langues de haut niveau, en revanche, imitent les langues naturelles en utilisant certains mots du langage parlé et des symboles mathématiques courants. Ces langages sont plus conviviaux.

Différents types de processeurs ont différents jeux d'instructions. Si un langage de programmation se concentre sur un type spécifique de processeur et prend en compte ses fonctionnalités, on parle alors de langage de programmation de bas niveau. Dans ce cas, « niveau faible » ne signifie pas « mauvais ». Cela signifie que les opérateurs du langage sont proches du code machine et se concentrent sur des commandes spécifiques du processeur.

Lors de la programmation en langage machine, le programmeur peut contrôler chaque instruction et chaque cellule mémoire et utiliser toutes les capacités des opérations machine disponibles. Mais le processus d’écriture d’un programme en langage machine est très long et fastidieux. Le programme s'avère encombrant, difficile à visualiser et difficile à déboguer, modifier et développer.

Par conséquent, dans le cas où il est nécessaire de disposer d'un programme efficace qui prend en compte au maximum les spécificités d'un ordinateur particulier, à la place des langages machine, des langages orientés machine (assembleurs) qui leur sont proches sont utilisés. .

Le langage assembleur est un langage de bas niveau spécifique à une machine dans lequel des noms mnémoniques courts correspondent à des instructions machine individuelles. Utilisé pour représenter des programmes écrits en code machine sous une forme lisible par l'homme.

Le langage assembleur permet au programmeur d'utiliser des codes mnémoniques textuels (c'est-à-dire facilement mémorisables par une personne), d'attribuer des noms symboliques aux registres de l'ordinateur et de la mémoire à sa discrétion, et également de définir des méthodes d'adressage qui lui conviennent. De plus, il vous permet d'utiliser différents systèmes numériques (par exemple décimal ou hexadécimal) pour représenter des constantes numériques, d'utiliser des commentaires dans le programme, etc.

Les langages de bas niveau créent des programmes très efficaces et compacts car le développeur a accès à toutes les capacités du processeur. En revanche, cela nécessite une très bonne compréhension de l’ordinateur, rend difficile le débogage de grandes applications et le programme final ne peut pas être transféré sur un ordinateur doté d’un autre type de processeur. De tels langages sont généralement utilisés pour écrire de petites applications système, des pilotes de périphériques et des modules d'interface avec des équipements non standard, lorsque la compacité, les performances et la possibilité d'accéder directement aux ressources matérielles deviennent les exigences les plus importantes. Dans certains domaines, tels que l'infographie, les bibliothèques sont écrites en langage assembleur pour implémenter efficacement des algorithmes de traitement d'image à forte intensité de calcul.

Ainsi, les programmes écrits en langage assembleur nécessitent beaucoup moins de mémoire et de temps d’exécution. La connaissance du langage assembleur et du code machine d'un programmeur lui permet de comprendre l'architecture de la machine. Bien que la plupart des professionnels du logiciel développent des programmes dans des langages de haut niveau, les logiciels les plus puissants et les plus efficaces sont écrits entièrement ou partiellement en langage assembleur.

Des langages de haut niveau ont été développés afin de libérer le programmeur de la prise en compte des caractéristiques techniques des ordinateurs spécifiques et de leur architecture. Le niveau de langage est caractérisé par son degré de proximité avec le langage naturel et humain. Le langage machine n’est pas semblable au langage humain ; il est extrêmement pauvre en moyens visuels. Les moyens d'écrire des programmes dans des langages de haut niveau sont plus expressifs et familiers aux humains. Par exemple, un algorithme de calcul utilisant une formule complexe n'est pas divisé en opérations distinctes, mais est écrit de manière compacte sous la forme d'une expression unique utilisant des symboles mathématiques familiers. Il est beaucoup plus facile de créer le vôtre ou de comprendre le programme de quelqu’un d’autre dans cette langue.

Un avantage important des langages de haut niveau est leur universalité et leur indépendance par rapport aux ordinateurs. Un programme écrit dans un tel langage peut être exécuté sur différentes machines. Le compilateur de programme n'a pas besoin de connaître le système de commande de l'ordinateur sur lequel il compte effectuer des calculs. Lors du passage à un autre ordinateur, le programme ne nécessite aucune modification. De tels langages ne sont pas seulement un moyen de communication entre une personne et une machine, mais aussi entre les personnes. Un programme écrit dans un langage de haut niveau peut être facilement compris par tout spécialiste connaissant le langage et la nature de la tâche.

Ainsi, on peut formuler les principaux avantages des langages de haut niveau par rapport aux langages machine :

L'alphabet du langage de haut niveau est beaucoup plus large que l'alphabet du langage machine, ce qui augmente considérablement la clarté du texte du programme ;

l'ensemble des opérations autorisées ne dépend pas de l'ensemble des opérations de la machine, mais est choisi pour des raisons de commodité lors de la formulation d'algorithmes pour résoudre des problèmes d'une certaine classe ;

le format de phrase est assez flexible et pratique à utiliser, ce qui vous permet de spécifier une étape assez significative du traitement des données à l'aide d'une seule phrase ;

les opérations requises sont spécifiées à l'aide de notations mathématiques généralement acceptées ;

Avant de vouloir apprendre un langage de programmation, vous devez connaître un peu son histoire et où il est utilisé.

Je vous présente un bref aperçu de 25 langages de programmation célèbres. Du plus célèbre au moins populaire. L'article est destiné aux débutants dans le domaine de la programmation. Vous pouvez lire sur chaque langue et choisir celle que vous préférez étudier.

Avant de commencer à apprendre les langages de programmation, je vous recommande de suivre un cours sur .

1. Javascript

Langage de programmation de script orienté prototype. JavaScript a été créé à l’origine pour rendre les pages Web « vivantes ». Dans le navigateur, ils se connectent directement au HTML et, dès le chargement de la page, ils sont immédiatement exécutés.

Lorsque JavaScript a été créé, il portait à l'origine un nom différent : « LiveScript ». Mais ensuite, le langage Java était très populaire et les spécialistes du marketing ont décidé qu'un nom similaire rendrait le nouveau langage plus populaire.

Il était prévu que JavaScript soit une sorte de « petit frère » de Java. Cependant, l'histoire a son propre chemin, JavaScript s'est beaucoup développé et c'est désormais un langage complètement indépendant, avec sa propre spécification et n'a rien à voir avec Java.

2. Java

Un langage de programmation orienté objet fortement typé. Les applications Java sont généralement traduites en bytecode personnalisé afin de pouvoir s'exécuter sur n'importe quelle architecture informatique utilisant la machine virtuelle Java.

L'avantage de cette méthode d'exécution de programmes est l'indépendance totale du bytecode par rapport au système d'exploitation et au matériel, ce qui vous permet d'exécuter des applications Java sur n'importe quel appareil pour lequel il existe une machine virtuelle correspondante. Une autre caractéristique importante de la technologie Java est son système de sécurité flexible, dans lequel l'exécution du programme est entièrement contrôlée par la machine virtuelle.

Le langage s'appelait à l'origine Oak et a été développé par James Gosling pour la programmation d'appareils électroniques grand public. Il a ensuite été renommé Java et utilisé pour écrire des applications client et des logiciels serveur.

3.PHP

Il s'agit d'un langage interprété commun, open source et à usage général (langage de script). PHP a été créé spécifiquement pour le développement Web et son code peut être intégré directement dans le code HTML. La syntaxe du langage provient de C, Java et Perl et est facile à apprendre.

L'objectif principal de PHP est de fournir aux développeurs Web la possibilité de créer rapidement des pages Web générées dynamiquement, mais la portée de PHP ne se limite pas à cela.

4.Python

Un langage de programmation généraliste de haut niveau visant à améliorer la productivité des développeurs, la lisibilité du code et le développement d'applications Web. La syntaxe de base de Python est minimaliste. Le code en Python est organisé en fonctions et classes, qui peuvent être combinées en modules.

5.C#

Langage de programmation orienté objet. Développé en 1998-2001 par un groupe d'ingénieurs dirigé par Anders Hejlsberg chez Microsoft en tant que langage de développement d'applications pour Microsoft .NET Framework. C# appartient à une famille de langages à syntaxe de type C, dont sa syntaxe est la plus proche de C++ et Java.

Le langage a un typage statique, prend en charge le polymorphisme, la surcharge d'opérateurs, les délégués, les attributs, les événements, les propriétés, les types et méthodes génériques, les itérateurs, les fonctions anonymes avec prise en charge des fermetures, LINQ, les exceptions, les commentaires au format XML.

6.C++

Un langage de programmation à usage général compilé et typé statiquement. C'est l'une des langues les plus parlées au monde. Google Chrome, Mozilla Firefox, Winamp et la gamme de produits Adobe ont été développés en C++. De plus, certains jeux et systèmes d'exploitation modernes ont été développés en C++ en raison de son traitement et de sa compilation rapides.

7. Rubis

Un langage de programmation simple et lisible destiné au développement d'applications Web. Conçu par Yukihiro Matsumto en 1995. Le langage a une implémentation indépendante du système d'exploitation du multithreading, du typage dynamique strict et d'un garbage collector.

L'objectif principal de Ruby est de créer des programmes simples et en même temps compréhensibles, où ce n'est pas la vitesse du programme qui est importante, mais le temps de développement court, la clarté et la simplicité de la syntaxe. Le langage suit le principe de la « moindre surprise » : le programme doit se comporter comme le programmeur l'attend.

8.CSS

Les feuilles de style en cascade sont un langage formel permettant de décrire l'apparence d'un document rédigé à l'aide d'un langage de balisage.
Il est principalement utilisé pour décrire et concevoir l'apparence de pages Web écrites à l'aide des langages de balisage HTML et XHTML, mais peut également être appliqué à n'importe quel document XML.

9.C

Un langage de programmation compilé, typé statiquement et à usage général. Le langage C a été développé par Dennis Ritchie en 1972 aux Bell Labs. C'est le prédécesseur des langages de programmation tels que C++, Java, C#, JavaScript et Perl. Pour cette raison, l’apprentissage de cette langue conduit à la compréhension d’autres langues. Le langage C est utilisé pour développer des applications de bas niveau, car il est considéré comme le plus proche du matériel.

10. Objectif-C

Un langage de programmation orienté objet compilé utilisé par Apple Corporation, construit sur le langage C et les paradigmes Smalltalk. Le langage Objective-C est un sur-ensemble du langage C, le code C est donc entièrement compréhensible par le compilateur Objective-C. Le langage est principalement utilisé pour Mac OS X (Cocoa) et GNUstep - implémentations de l'interface OpenStep orientée objet. Le langage est également utilisé pour iOS (Cocoa Touch).

11.Coquille

Ce n'est pas tant un langage qu'un interpréteur de commandes (langage de commande). Ses scripts sont utilisés pour automatiser les mises à jour logicielles. Contient des constructions standard pour les boucles, les branchements et les déclarations de fonctions. La famille de systèmes d'exploitation UNIX utilise SHELL comme langage standard de contrôle des tâches.

12. R.

Un langage de programmation pour le traitement des données statistiques et graphiques, ainsi qu'un environnement informatique gratuit et open source dans le cadre du projet GNU. R est largement utilisé comme logiciel statistique pour l’analyse des données et est devenu la norme de facto pour les programmes statistiques. R utilise une interface de ligne de commande.

13. Perl

Un langage de programmation dynamique à usage général interprété de haut niveau. Le nom du langage est un acronyme qui signifie Practical Extraction and Report Language - « un langage pratique pour extraire des données et rédiger des rapports ». La principale caractéristique du langage réside dans ses riches capacités de travail avec du texte, notamment avec des expressions régulières intégrées à la syntaxe. Actuellement, il est utilisé pour un large éventail de tâches, notamment l'administration système, le développement Web, la programmation réseau, les jeux, la bioinformatique et le développement d'interfaces utilisateur graphiques.

14. Échelle

Un langage de programmation multi-paradigmes conçu pour être concis et sécurisé pour une création facile et rapide de logiciels basés sur des composants, combinant les capacités de la programmation fonctionnelle et orientée objet. Les programmes Scala sont similaires aux programmes Java à bien des égards et peuvent interagir librement avec le code Java.

15. Allez

Un langage de programmation multithread compilé développé par Google. Le langage Go a été développé en tant que langage de programmation système permettant de créer des programmes très efficaces fonctionnant sur des systèmes distribués modernes et des processeurs multicœurs. Cela peut être considéré comme une tentative de créer un substitut au langage C. Lors du développement, une attention particulière a été accordée à garantir une compilation très efficace. Les programmes Go sont compilés en code objet et ne nécessitent pas d'exécution de machine virtuelle.

16.SQL

Langage de requêtes structurées. un langage de programmation formel et non procédural utilisé pour créer, modifier et manipuler des données dans une base de données relationnelle arbitraire gérée par un système de gestion de base de données approprié. SQL est avant tout un langage logique d'information conçu pour décrire, modifier et récupérer des données stockées dans des bases de données relationnelles. Chaque instruction SQL est soit une demande de données provenant d'une base de données, soit un appel à la base de données qui entraîne la modification des données de la base de données.

17. Haskel

Un langage de programmation standardisé, pur, fonctionnel et à usage général. C'est l'un des langages de programmation les plus courants prenant en charge l'informatique paresseuse. Une caractéristique distinctive de la langue est son attitude sérieuse à l'égard de la dactylographie. Haskell est un excellent langage pour apprendre et expérimenter des types de données fonctionnelles complexes.

18. Rapide

Un langage de programmation ouvert, multi-paradigmes, compilé et à usage général. Créé par Apple principalement pour les développeurs iOS et OS X, Swift fonctionne avec les frameworks Cocoa et Cocoa Touch et est compatible avec la base de code Objective-C principale d'Apple. Swift était destiné à être un langage plus facile à lire et plus résistant aux erreurs que son prédécesseur, Objective-C. Swift emprunte beaucoup à Objective-C, mais il n'est pas défini par des pointeurs, mais par les types de variables traitées par le compilateur. De nombreux langages de script fonctionnent sur un principe similaire.

19. Matlab

Un langage de programmation interprété de haut niveau qui comprend des structures de données matricielles, un large éventail de fonctionnalités, un environnement de développement intégré, des capacités orientées objet et des interfaces avec des programmes écrits dans d'autres langages de programmation. Les programmes écrits dans MATLAB sont de deux types : les fonctions et les scripts. Les fonctions ont des arguments d'entrée et de sortie, ainsi que leur propre espace de travail pour stocker les résultats et les variables de calcul intermédiaires. Les scripts utilisent un espace de travail commun. Les scripts et les fonctions sont enregistrés sous forme de fichiers texte et compilés dynamiquement en code machine.

20. Visual Basic

Un langage de programmation et un environnement de développement logiciel intégré développés par Microsoft Corporation. Le langage Visual Basic a hérité de l'esprit, du style et de la syntaxe de son ancêtre, le langage BASIC, qui possède de nombreux dialectes. Dans le même temps, Visual Basic combine les procédures et les éléments des langages de programmation orientés objet et orientés composants.

Visual Basic est également un bon outil pour développer rapidement des applications de bases de données RAD pour les systèmes d'exploitation Microsoft Windows. De nombreux composants prêts à l'emploi fournis avec l'environnement sont conçus pour aider le programmeur à commencer immédiatement à développer la logique métier de l'application, sans détourner son attention sur l'écriture du code de lancement du programme.

21. Delphes

Un langage de programmation impératif, structuré et orienté objet avec un typage de variables statiques fort. Le principal domaine d'utilisation est l'écriture de logiciels d'application.

Aujourd'hui, outre la prise en charge du développement de programmes 32 et 64 bits pour Windows, il est possible de créer des applications pour Apple Mac OS X, ainsi que pour Google Android (directement exécutées sur un processeur ARM).

22. Groovy

Un langage de programmation orienté objet conçu pour la plate-forme Java en complément du langage Java avec des fonctionnalités de Python, Ruby et Smalltalk. Groovy utilise une syntaxe de type Java avec compilation dynamique du bytecode JVM et fonctionne directement avec d'autres codes et bibliothèques Java. Le langage peut être utilisé dans n'importe quel projet Java ou comme langage de script.

23. Visual Basic .NET

Un langage de programmation orienté objet, qui peut être considéré comme la prochaine évolution de Visual Basic, implémenté sur la plateforme Microsoft .NET. VB.NET n'est pas rétrocompatible avec une version antérieure (Visual Basic 6.0). Le développement de projets d'anciennes versions (*.vbp) n'est possible qu'après leur conversion préalable au format VB.NET par un assistant spécial (Migration Wizard) ; cependant, après la conversion, d'importantes modifications manuelles des textes sont nécessaires.

24.D

Un langage de programmation compilé multi-paradigmes créé par Walter Bright de Digital Mars. D a été conçu à l’origine comme une réingénierie du langage C++, cependant, malgré l’influence significative du C++, il n’en est pas une variante. Le langage a également été influencé par les concepts des langages de programmation Python, Ruby, C#, Java et Eiffel.

25. Assembleur

Un langage orienté machine de bas niveau avec des commandes qui ne correspondent pas toujours aux commandes machine, qui peut apporter des fonctionnalités supplémentaires telles que des macros ; autocode étendu par des constructions de langage de programmation de haut niveau, telles que des expressions, des macros et des moyens garantissant la modularité du programme.

Le langage assembleur est un système de notation utilisé pour représenter des programmes écrits en code machine sous une forme lisible par l'homme. Le langage assembleur permet au programmeur d'utiliser des codes d'opération mnémoniques alphabétiques, d'attribuer des noms symboliques aux registres et à la mémoire de l'ordinateur à sa discrétion, et également de définir des schémas d'adressage qui lui conviennent. De plus, il permet d'utiliser différents systèmes numériques pour représenter des constantes numériques et permet d'étiqueter les lignes de programme avec des noms symboliques afin qu'elles puissent être référencées.

Je n'ai pas pris toutes les langues parce que... ils ne sont pas tellement demandés par les programmeurs professionnels. Ma tâche est terminée, il ne vous reste plus qu'à choisir la langue appropriée et à la conquérir. Bonne chance à vous dans vos démarches.

1.1 Microsoft Visual Studio C++

Microsoft Visual Studio est une gamme de produits Microsoft qui comprend un environnement de développement logiciel intégré et un certain nombre d'autres outils.

Visual Studio inclut un ou plusieurs des éléments suivants :

Visual Basic .NET, et avant son apparition - Visual Basic ;

Visuel C++ ;

Visuel C#.

De nombreuses options de livraison incluent également :

Microsoft SQL Server ou MSDE ;

Visual Source Safe - système de contrôle de version du serveur de fichiers ;

Dans le passé, Visual Studio incluait également les produits suivants :

Visual InterDev ;

Visuel J++ ;

Visuel J# ;

Visuel FoxPro.

Les versions les plus importantes du package :

Visual Studio 97 a été la première version de Visual Studio publiée et la première à regrouper divers outils de développement logiciel. Il a été publié en deux versions : Professionnelle et Entreprise. Il comprenait Visual Basic 5.0, Visual C++ 5.0, Visual J++ 1.1, Visual FoxPro 5.0 et l'environnement de développement ASP - Visual InterDev - est apparu pour la première fois. Visual Studio 97 était la première tentative de Microsoft de créer un environnement de développement unique pour différents langages de programmation : Visual C++, Visual J++, Visual InterDev et MSDN partageaient tous un environnement appelé Developer Studio. Visual Basic et Visual FoxPro utilisaient des environnements de développement distincts.

Visual Studio 6.0 - publié en juin 1998 - la dernière version de Visual Studio fonctionnant sur la plateforme Win9x. Toujours populaire parmi les programmeurs utilisant Visual Basic. Cette version était le principal environnement de développement d'applications pour Windows de Microsoft, avant l'avènement de la plateforme .NET.

Visual Studio .NET (nom de code Rainier ; version interne 7.0) - publié en février 2002 (inclut .NET Framework 1.0). Le Service Pack 1 pour Visual Studio .NET (2002) a été publié en mars 2005.

Visual Studio .NET 2003 (nom de code Everett ; version interne 7.1) - publié en avril 2003 (inclut .NET Framework 1.1). Le Service Pack 1 pour Visual Studio .NET 2003 a été publié le 13 septembre 2006.

Visual Studio 2005 (nom de code Whidbey ; version interne 8.0) - publié fin octobre 2005 (inclut .NET Framework 2.0). Début novembre 2005, une série de produits de l'édition Express ont également été publiés : Visual C++ 2005 Express, Visual Basic 2005 Express, Visual C# 2005 Express, etc. Le 19 avril 2006, l'édition Express est devenue gratuite. Le Service Pack 1 pour VS2005 et toutes les éditions Express a été publié le 14 décembre 2006. Un correctif supplémentaire pour SP1 qui résout le problème de compatibilité avec Windows Vista a été publié le 3 juin 2007.

Visual Studio 2008 (nom de code Orcas) - publié le 19 novembre 2007 avec .NET Framework 3.5. Destiné à créer des applications pour Windows Vista (mais prend également en charge XP), Office 2007 et des applications Web. Inclut LINQ, les nouvelles versions de C# et Visual Basic. Visual J# n'était pas inclus dans le studio. Depuis le 28 octobre 2008, la version russe est disponible pour la première fois.

Le produit successeur de Visual Studio 2008 porte le nom de code Hawaii. Le 29 septembre 2008, une annonce a été publiée présentant certaines des innovations qui apparaîtront dans Visual Studio 2010 et .NET Framework 4.0.

Un développeur d'applications qui décide d'utiliser les services de Visual Studio.Net 7.0 dispose de nombreuses nouvelles technologies et outils qui lui permettent de créer rapidement et efficacement des applications Windows ordinaires, désormais communément appelées applications de bureau, ainsi que applications Web et services Web. Microsoft a ajouté à l'arsenal du programmeur un nouveau langage, C# (prononcé "C Sharp"), qui, comme le promettent les experts, peut accélérer plusieurs fois le cycle de développement de projets complexes.

La principale nouveauté qui devrait retenir votre attention est que Visual C++, Visual Basic et C# utilisent le même IDE (Integrated Development Environment), ce qui permet de créer des projets complexes en utilisant différents langages (solutions multi-langages). L'environnement de développement multilingue .Net (.Net Framework) est la somme de trois composants :

une bibliothèque d'exécution commune pour l'ensemble de langages considéré (Common Language Runtime) ;

bibliothèque unifiée de classes de développeurs (Unified Programming Classes) ;

modèle de développement d'applications Web (Active Server Pages.Net).

Le premier composant est la bibliothèque d'exécution (Common Language Runtime, en abrégé CLR), qui fonctionne à la fois au moment de l'exécution et au stade du développement. Lors de l'exécution du code, il surveille la dynamique des applications multithread, assure l'interconnexion des processus, maintient leur sécurité et automatise les procédures d'allocation et de libération de mémoire. Au stade du développement, le CLR automatise les tâches typiques résolues par le programmeur, simplifiant ainsi grandement l'utilisation des nouvelles technologies. On note particulièrement les avantages obtenus lors de la création de composants du standard COM (Component Object Model, en abrégé COM - Multi-Component Object Model).

Le deuxième composant (Classes de programmation unifiées) fournit au développeur une bibliothèque de classes unifiée, orientée objet et extensible, qui, avec d'autres ressources, fait partie de l'interface de programmation d'application (API). Il combine des éléments de MFC (Microsoft Foundation Classes), WFC (Windows Foundation Classes) et une partie de l'API utilisée par Visual Basic.

Le troisième composant (ASP.Net) est un module complémentaire aux classes, qui permet d'utiliser la technologie orientée objet lors du développement d'éléments d'interface HTML standard. En réalité exécutés côté serveur, ces éléments exposent les fonctions de l’interface utilisateur sous forme de code HTML. Cependant, lors du développement d'un serveur, il est possible d'utiliser le puissant appareil fourni par le modèle de programmation objet. Le résultat est une simplification spectaculaire du processus de création d’applications Web. En plus de cela, ASP.Net prend en charge un concept ou un modèle de développement de programme relativement nouveau. Vous en avez probablement entendu parler sous le nom de technologie de client léger. L'essence principale de ce modèle est la fourniture de code à l'utilisateur non pas sous la forme d'un produit installé, mais sous la forme d'un service temporaire.

Le code créé sur la base de l'environnement de développement .Net Framework est appelé code managé. (code géré) contrairement au code standard non géré (code non géré). En mode .Net, les compilateurs des langages considérés produisent des métadonnées (métadonnées), qui accompagnent le code lui-même. Cela signifie qu'ils génèrent des informations supplémentaires décrivant les types de données, les objets et les références. La bibliothèque d'exécution (Common Language Runtime) utilise des métadonnées pour rechercher et charger des objets, exécuter des fonctions, transmettre des paramètres et placer des objets en mémoire.

Une fonction importante remplie par la bibliothèque d'exécution est de libérer automatiquement la mémoire occupée par les objets qui ne sont plus utilisés. Cette innovation est conçue pour augmenter la fiabilité à la fois des composants individuels et de l'ensemble de l'application en cours de développement. Les données dont la durée de vie est ainsi gérée sont appelées données gérées. (données gérées). Si votre code est géré (code managé), alors vous pouvez ou non utiliser des données gérées. De plus, vous ne savez peut-être pas si vos données sont gérées.

La Common Runtime Library (CLR) simplifie la création d'applications et de leurs composants développés dans différents langages et destinés à utiliser le CLR. Ces modules peuvent être intégrés dans un même projet et interagir entre eux comme s'ils étaient créés dans le même langage. Par exemple, vous pouvez déclarer une classe, puis créer une classe dérivée de celle-ci dans un autre langage. Vous pouvez simplement utiliser des méthodes de classe dans un module écrit dans un autre langage. Cette intégration est possible car les compilateurs et outils dans différents langages partagent un système de types commun défini dans le CLR, ainsi que de nouvelles règles du jeu adoptées lors de son développement.

1.2 Générateur C++

Borland C++ Builder est un outil de développement d'applications rapide récemment publié par Borland qui vous permet de créer des applications en C++ à l'aide de l'environnement de développement Delphi et de la bibliothèque de composants. Cet article traite de l'environnement de développement C++ Builder et des techniques de base utilisées dans la conception de l'interface utilisateur.

C++ Builder est une application SDI dont la fenêtre principale contient une barre d'outils personnalisable (à gauche) et une palette de composants (à droite). De plus, par défaut, lorsque vous lancez C++ Builder, la fenêtre Inspecteur d'objets (à gauche) et le formulaire Nouvelle application (à droite) apparaissent. Sous la fenêtre du formulaire de candidature se trouve la fenêtre de l’éditeur de code.

Fig. 1. Environnement de développement C++Builder

Les formulaires sont au cœur des applications C++ Builder. La création de l'interface utilisateur d'une application implique l'ajout d'éléments d'objet C++ Builder, appelés composants, à la fenêtre du formulaire. Les composants C++ Builder se trouvent sur la palette de composants, conçue comme un bloc-notes multipage. Une fonctionnalité importante de C++ Builder est qu'il vous permet de créer vos propres composants et de personnaliser la palette de composants, ainsi que de créer différentes versions de la palette de composants pour différents projets.

Les composants sont divisés en visibles (visuels) et invisibles (non visuels). Les composants visuels apparaissent au moment de l’exécution comme au moment de la conception. Les exemples sont les boutons et les champs modifiables. Les composants non visuels apparaissent lors de la conception sous forme d'icônes sur un formulaire. Ils ne sont jamais visibles au moment de l'exécution, mais possèdent certaines fonctionnalités (par exemple, ils donnent accès aux données, appellent les boîtes de dialogue standard de Windows 95, etc.)

Riz. 2. Exemple d'utilisation de composants visibles et invisibles

Pour ajouter un composant à un formulaire, vous pouvez sélectionner le composant souhaité dans la palette avec la souris et cliquer sur le bouton gauche de la souris à l'emplacement souhaité du formulaire conçu. Le composant apparaîtra sur le formulaire, et vous pourrez ensuite le déplacer, modifier sa taille et d'autres caractéristiques.

Chaque composant C++ Builder possède trois types de caractéristiques : propriétés, événements et méthodes.

Si vous sélectionnez un composant dans la palette et l'ajoutez à un formulaire, l'inspecteur d'objets affichera automatiquement les propriétés et les événements pouvant être utilisés avec ce composant. En haut de l'inspecteur d'objets se trouve une liste déroulante qui permet de sélectionner l'objet souhaité parmi ceux disponibles sur le formulaire.

Les propriétés sont des attributs d'un composant qui déterminent son apparence et son comportement. De nombreuses propriétés de composants dans la colonne des propriétés ont une valeur par défaut (par exemple, la hauteur du bouton). Les propriétés du composant sont affichées sur la page Propriétés. L'inspecteur d'objets affiche les propriétés publiées des composants. En plus des propriétés publiées, les composants peuvent avoir, et le plus souvent, des propriétés publiques publiées qui ne sont disponibles que pendant l'exécution de l'application. L'inspecteur d'objets est utilisé pour définir les propriétés au moment de la conception. La liste des propriétés se trouve sur la page des propriétés de l'inspecteur d'objets. Vous pouvez définir des propriétés au moment de la conception ou écrire du code pour modifier les propriétés d'un composant au moment de l'exécution.

Lors de la définition des propriétés d'un composant au moment de la conception, vous sélectionnez le composant sur le formulaire, ouvrez la page de propriétés dans l'inspecteur d'objets, sélectionnez la propriété à définir et modifiez-la à l'aide de l'éditeur de propriétés (il peut s'agir d'un simple texte ou d'un simple texte). (champ numérique, liste déroulante, liste déroulante, boîte de dialogue), panneau, etc.).

1.3 Delphes

Delphi est un environnement de développement qui utilise le langage de programmation Delphi (à partir de la version 7, le langage de l'environnement s'appelle Delphi, auparavant Object Pascal), développé par Borland et initialement implémenté dans son package Borland Delphi, d'où il tire son nom actuel. en 2003. Object Pascal est essentiellement un successeur du langage Pascal avec des extensions orientées objet.

Delphi est un environnement de développement rapide qui utilise Delphi comme langage de programmation. Le langage Delphi est un langage orienté objet fortement typé, qui s'appuie sur le Pascal Objet, bien connu des programmeurs.

Delphi est une combinaison de plusieurs technologies importantes :

compilateur hautes performances en code machine ;


– modèle de composants orienté objet ;


– construction visuelle (et donc rapide) d'applications à partir de prototypes logiciels ;


– des outils évolutifs pour créer des bases de données.


Borland Delphi 8 Studio vous permet de créer une grande variété de programmes : des applications à fenêtre unique les plus simples aux programmes de gestion de bases de données distribuées. Le package comprend une variété d'utilitaires qui vous permettent de travailler avec des bases de données, des documents XML, de créer un système d'aide et de résoudre d'autres problèmes. Une caractéristique distinctive de la septième version est la prise en charge de la technologie .NET.


L'objectif principal du modèle Delphi est de maximiser la productivité du code, ce qui permet de développer des applications très rapidement, puisque des objets pré-préparés existent déjà. Vous pouvez également créer vos propres objets, sans aucune restriction. Le langage Delphi est un langage orienté objet fortement typé, qui s'appuie sur le Pascal Objet, bien connu des programmeurs.


Delphi est livré en standard avec des objets de base issus de 270 classes de base. Ce langage est très pratique pour écrire à la fois des applications de bases de données et même des programmes de jeux. Si nous prenons en compte l'interface pratique pour créer des shells graphiques, nous pouvons affirmer avec confiance que le langage Delphi est un langage de programmation très facile à comprendre, mais en même temps très puissant.


La première version d'un environnement de développement Delphi à part entière pour .NET était Delphi 8. Elle vous permettait d'écrire des applications uniquement pour .NET. Actuellement, dans Delphi 2006, vous pouvez écrire des applications .NET à l'aide de la bibliothèque de classes .NET standard, VCL pour .NET. Le framework vous permet également de créer des applications .NET en C# et des applications Win32 en C++. Delphi 2006 contient des fonctionnalités permettant d'écrire des applications courantes à l'aide des bibliothèques VCL et CLX. Delphi 2006 prend en charge la technologie MDA à l'aide de la version ECO (Enterprise Core Objects) 3.0.


En mars 2006, Borland a décidé de cesser d'améliorer les environnements de développement intégrés JBuilder, Delphi et C++ Builder en raison de la non-rentabilité de ce domaine. En août 2006, Borland a publié une version allégée de RAD Studio sous le nom de Turbo : Turbo Delphi, Turbo Delphi pour .NET, Turbo C#, Turbo C++. En mars 2008, il a été annoncé que le développement de cette gamme de produits serait interrompu.


En mars 2007, CodeGear a ravi les utilisateurs avec la gamme mise à jour de Delphi 2007 pour les produits Win32 et la sortie d'un tout nouveau produit, Delphi 2007 pour PHP. En juin 2007, CodeGear a présenté ses projets pour l'avenir, c'est-à-dire qu'il a publié ce qu'on appelle la feuille de route, qui peut être consultée ici


Le 25 août 2008, Embarcadero, le nouveau propriétaire de CodeGear, a publié un communiqué de presse sur Delphi pour Win32 2009. La version a apporté de nombreuses innovations au langage, telles que :


– prise en charge complète d'Unicode par défaut dans toutes les parties du langage, VCL et RTL ;


– les types généralisés, également appelés génériques.


– méthodes anonymes.


Parmi les nombreux produits logiciels courants fabriqués avec Delphi, vous pouvez trouver :


1. Produits Borland : Borland Delphi, Borland C++ Builder, Borland JBuilder versions 1 et 2.


2.Administration/développement de bases de données : Outils MySQL (Administrateur, Navigateur de requêtes), IBExpert, TOAD


3.Logiciel d'ingénierie : Altium Designer/Protel (conception électronique).


4.Visionneuses graphiques : FastStone Image Viewer, FuturixImager, Photofiltre.


5.Lecteurs vidéo et audio : KMPlayer (lecteur vidéo et audio), X-Player (lecteur audio).


6.Diffusion d'informations sur Internet : Skype (VoIP et IM), QIP, QIP Infium et R&Q, (IMs), The Bat! et si.Mail (clients de messagerie), PopTray (vérificateur de courrier), FeedDemon (visualiseur de groupes de discussion RSS/Atom), XanaNews (lecteur de groupes de discussion), Xnews (lecteur de groupes de discussion).


7.Création musicale : FL Studio (anciennement FruityLoops).


8. Développement de logiciels : Dev-C++, Dev-PHP, Maguma Open Studio et Open Perl IDE (IDE), DUnit (tests unitaires), Jedi Code Format (formatage du code), Game Maker (création de jeux) Aide et manuel (aide à la création système), Inno Setup (moteur d'installation).


9.Développement Web : Macromedia HomeSite (éditeur HTML), TopStyle Pro (éditeur CSS), Macromedia Captivate (capture d'écran), Quick Page 2008 (environnement de développement de sites Web).


10.Navigateurs Web (shells pour MSIE) : Avant Browser, Netcaptor.


11.Utilitaires : Spybot - Search & Destroy, Ad-Aware (anti-spyware), jv16 PowerTools, FDK (utilitaire d'optimisation du système multifonctionnel), Total Commander et Frigate (gestionnaires de fichiers), DarkCrypt TC/GUI (logiciel de cryptage), ImageSpyer et StegoTC (progiciel stéganographique), Copernic Desktop Search, PowerArchiver et PeaZip (archiveurs), MCubix (exploration de données), Download Master [gestionnaire de téléchargement], ACProtect (programme d'empaquetage et de protection des fichiers EXE).


12.Éditeurs de texte : SynEdit, Bred2, KeyNote, cEdit Professional, Programmer's Notepad, UniRed, gleditor.


13.Éditeurs de fichiers binaires (éditeurs HEX) : Hexapad


14. Comptabilité et fiscalité : le logiciel de fiscalité professionnel Lacerte d'Intuit, y compris tous les sous-systèmes tels que l'utilitaire de balance de vérification QuickBooks/EasyACCT, le système de gestion de documents et l'utilitaire de réparation de base de données client.


15.Programmes de lecture et de catalogage de textes électroniques : DarkLib (catalogueur et liseuse multiformat), IxReader (lecteur électronique).


2 Analyse comparative des capacités (avantages) inconvénients des langages modernes orientés objet et des outils de développement basés sur ceux-ci


2.1 Objet Pascal


Object Pascal est un dialecte entièrement orienté objet du langage Pascal, développé par Apple Computer en collaboration avec Niklaus Wirth. En 1986, Borland a ajouté une extension Pascal similaire au produit Turbo Pascal pour Macintosh ; avec la sortie de Turbo Pascal 5.5, l'extension est devenue disponible pour DOS. À partir de Delphi 7, Borland a commencé à appeler officiellement son langage Delphi. Cependant, Object Pascal est maintenu et développé par d'autres développeurs. Les implémentations les plus sérieuses d'Object Pascal (outre Delphi) sont TMT Pascal, Virtual Pascal et Free Pascal.


Tout programme Delphi se compose d'un fichier projet (fichier avec l'extension dpr) et d'un ou plusieurs modules (fichiers avec l'extension pas). Chacun de ces fichiers décrit une unité de programme Object Pascal.


Dans la fenêtre de code, les mots dits réservés sont surlignés en gras et les commentaires en italique (les mots réservés et les commentaires dans le livre sont également surlignés). Comme vous pouvez le constater, le texte du programme commence par le mot réservé programme et se termine par le mot fin suivi d'un point. Notez que la combinaison de end avec le point qui le suit est appelée terminateur d'unité de programme : dès qu'un tel terminateur est rencontré dans le texte du programme, le compilateur arrête d'analyser le programme et ignore le reste du texte.


Les mots réservés jouent un rôle important dans Object Pascal, donnant à l'ensemble du programme l'apparence d'un texte écrit dans un anglais presque naturel. Chaque mot réservé (et il y en a plusieurs dizaines en Pascal Objet) véhicule un message conditionnel pour le compilateur, qui analyse le texte du programme de la même manière que nous le lisons : de gauche à droite et de haut en bas.


Les commentaires, au contraire, ne signifient rien pour le compilateur et celui-ci les ignore. Les commentaires sont importants pour le programmeur, qui les utilise pour expliquer certaines parties du programme. La présence de commentaires dans le texte du programme le rend plus clair et permet de se souvenir facilement des caractéristiques d'implémentation d'un programme écrit il y a plusieurs années. En Pascal Objet, un commentaire est une séquence de caractères entourée d'accolades. Dans le texte ci-dessus, il y a deux commentaires de ce type, mais la ligne


($R *.RES)


n'est pas vraiment un commentaire. Ce morceau de code spécialement écrit est appelé directive du compilateur (dans notre cas, il s'agit d'une instruction adressée au compilateur pour connecter ce qu'on appelle un fichier de ressources au programme). Les directives commencent par un symbole $, qui est immédiatement suivi d'une accolade ouvrante.


Puisque nous parlons de commentaires, je note que dans Object Pascal, les paires de caractères (*, *) et // peuvent également être utilisées comme délimiteurs de commentaires. Les crochets (*...*) sont utilisés comme des accolades, c'est-à-dire qu'un fragment de texte qu'ils contiennent est considéré comme un commentaire, et les symboles // indiquent au compilateur que le commentaire se trouve derrière eux et continue jusqu'à la fin du ligne actuelle :


(Ceci est un commentaire)


(*Ceci est aussi un commentaire*)


//Tous les caractères jusqu'à la fin de cette ligne constituent un commentaire


Le mot Programme suivi du nom du programme et d'un point-virgule forme le titre du programme. Après l'en-tête se trouve une section de description dans laquelle le programmeur (ou Delphi) décrit les identifiants utilisés dans le programme. Les identifiants désignent les éléments du programme, tels que les types, les variables, les procédures, les fonctions (nous parlerons des éléments du programme un peu plus tard). Ici, à l'aide d'une phrase commençant par le mot réservé usages, le programmeur informe le compilateur des fragments de programme (modules) qui doivent être considérés comme faisant partie intégrante du programme et qui se trouvent dans d'autres fichiers. Cordes


les usages


Formulaires, Unit1 dans 'Unitl.pas' (fmExample) ;


indiquer qu'en plus du fichier projet, le programme doit utiliser les modules Forms ET Unit1. le module Forms est standard (c'est-à-dire déjà connu de Delphi), et le module Unit1 est nouveau, jusqu'alors inconnu, et Delphi dans ce cas précise également le nom du fichier avec le texte du module (dans 'uniti.pas') et le nom du fichier de description associé au module form(fmExample).


Le corps réel du programme commence par le mot start et est limité par le terminateur end avec un point. Le corps se compose de plusieurs instructions du langage Object Pascal. Chaque instruction implémente une action - changer la valeur d'une variable, analyser le résultat d'un calcul, appeler un sous-programme, etc. Le corps de notre programme contient trois instructions exécutables :


Application.Initialiser ;


Application.CreateForm(TfmExample, fmExample);


Application.Exécuter ;


Chacun d'eux implémente un appel à l'une des méthodes de l'objet Application


Un objet est un fragment spécialement conçu d'un programme qui contient des données et des sous-programmes pour les traiter. Les données sont appelées les champs d'un objet et les routines ses méthodes. L'objet dans son ensemble est destiné à résoudre un problème spécifique et est perçu dans le programme comme un tout indivisible (en d'autres termes, il est impossible de « retirer » un domaine ou une méthode distinct de l'objet). Les objets jouent un rôle extrêmement important dans les langages de programmation modernes. Ils ont été inventés afin d'augmenter la productivité du programmeur et en même temps d'améliorer la qualité des programmes qu'il développe. Deux propriétés principales d'un objet - la fonctionnalité et l'indivisibilité - en font une partie indépendante voire autosuffisante du programme et facilitent le transfert de l'objet d'un programme à un autre. Les développeurs Delphi ont créé pour vous et moi des centaines d'objets qui peuvent être considérés comme des briques à partir desquelles un programmeur construit un programme à plusieurs étages. Ce principe de construction de programmes est appelé programmation orientée objet (POO). L'objet Application contient les données et routines nécessaires au fonctionnement normal du programme Windows dans son ensemble. Delphi crée automatiquement un objet programme Application pour chaque nouveau projet. Doubler


Application.Initialiser ;


signifie appeler la méthode Initialize de l’objet Application. Après avoir lu cette ligne, le compilateur créera du code qui forcera le processeur à commencer à exécuter un fragment du programme que les développeurs Delphi ont écrit pour nous. Après avoir exécuté ce fragment (les programmeurs disent : après avoir quitté le sous-programme), le contrôle du processeur passera à la ligne suivante du programme, qui appelle la méthode CreateForm, etc.


Les modules sont des unités de programme conçues pour héberger des fragments de programme. À l'aide du code du programme qu'ils contiennent, tout l'aspect comportemental du programme est implémenté. Tout module a la structure suivante : en-tête interface déclaration section implémentation section terminateur L'en-tête s'ouvre avec le mot réservé Unit suivi du nom du module et d'un point-virgule. La section de déclaration d'interface s'ouvre avec le mot réservé Interface, et la section d'implémentation avec le mot implémentation. Le terminateur d'un module, comme le terminateur d'un programme, se termine par un point. Le fragment de programme suivant est une version syntaxiquement correcte du module :


unité Unité1 ;


interface


// Section des déclarations d'interface


mise en œuvre


// Section Implémentation


fin.


La section des déclarations d'interface décrit les éléments du programme (types, classes, procédures et fonctions) qui seront « visibles » par les autres modules du programme, et la section d'implémentation révèle le fonctionnement de ces éléments. La division du module en deux sections fournit un mécanisme pratique pour échanger des algorithmes entre des parties distinctes du même programme. Il met également en œuvre un moyen de partage des développements logiciels entre programmeurs individuels. Ayant reçu un module « étranger » compilé, le programmeur n'a accès qu'à sa partie interface, qui, comme déjà mentionné, contient des déclarations d'éléments. Les détails de l'implémentation des procédures, fonctions et classes déclarées sont masqués dans la section d'implémentation et ne sont pas disponibles pour les autres modules.


Les classes constituent l'outil principal pour implémenter les puissantes fonctionnalités de Delphi. Une classe est un modèle à partir duquel des objets sont créés et, inversement, un objet est une instance d'implémentation d'une classe. Les modèles de création d'éléments de programme dans Object Pascal sont appelés types, la classe TfmExample est donc un type. Sa déclaration est précédée du mot réservé type, qui informe le compilateur qu'une section de déclaration de type a commencé.


La classe TForm standard implémente tout le nécessaire pour créer et exploiter une fenêtre Windows vide. La classe TfmExamplel est dérivée de cette classe, comme en témoigne la ligne


TfmExample = classe (TForm)


dans lequel le nom de la classe parent est indiqué entre parenthèses après le mot réservé classe. Le terme « dérivé » signifie que la classe TfmExample a hérité de toutes les capacités de la classe TForm parent et leur a ajouté les siennes sous la forme de composants supplémentaires insérés dans le formulaire fmExample. La liste des composants que nous avons insérés constitue une partie importante de la description de la classe.


La propriété d'hériter par les classes descendantes de toutes les propriétés de la classe parent et de les enrichir de nouvelles capacités est l'un des principes fondamentaux de la programmation orientée objet. Un nouvel héritier peut être généré à partir de l'héritier, qui contribuera sous la forme de composants logiciels supplémentaires, etc. En conséquence, une hiérarchie de classes branchées est créée, au sommet de laquelle se trouve la classe la plus simple TObject (toutes les autres classes de Delphi est dérivé de cet unique ancêtre) et au niveau le plus bas de la hiérarchie se trouvent de puissantes classes descendantes capables de résoudre n'importe quel problème.


L'objet fmExampie fait formellement référence à des éléments de programme appelés variables. C'est pourquoi la déclaration de l'objet est précédée du mot réservé var (issu des variables anglaises).


Les éléments du programme sont ses parties minimales indivisibles qui revêtent néanmoins une certaine importance pour le compilateur. Les éléments comprennent :


mots réservés;


identifiants;


les types;


constantes ;


variables ;


Mots clés;


sous-programmes ;


commentaires.


Les mots réservés sont des mots anglais qui indiquent au compilateur d'effectuer certaines actions. Les mots réservés ne peuvent être utilisés dans un programme à des fins autres que celles pour lesquelles ils sont destinés. Par exemple, le mot réservé début indique au compilateur le début d’une instruction composée. Un programmeur ne peut pas créer dans un programme une variable nommée début, une constante début, une étiquette de début ou tout autre élément de programme nommé début.


Les identifiants sont des mots qu'un programmeur utilise pour désigner tout élément d'un programme autre qu'un mot réservé, un identifiant ou un commentaire. Les identifiants dans Object Pascal peuvent être constitués de lettres latines, de chiffres arabes et de traits de soulignement. Aucun autre caractère ou caractère spécial ne peut apparaître dans l'identifiant. De cette règle simple, il résulte que les identifiants ne peuvent pas être constitués de plusieurs mots (vous ne pouvez pas utiliser d'espace) ni inclure des caractères cyrilliques (alphabet russe).


Les types sont des constructions de langage spéciales qui sont traitées par le compilateur comme des modèles pour créer d'autres éléments de programme, tels que des variables, des constantes et des fonctions. Tout type définit deux choses importantes pour le compilateur : la quantité de mémoire allouée pour accueillir un élément (constante, variable ou résultat renvoyé par une fonction) et l'ensemble des actions valides qu'un programmeur peut effectuer sur des éléments de ce type. Je note que tout identifiant défini par le programmeur doit être décrit dans la section descriptions (avant le début des instructions exécutables). Cela signifie que le compilateur doit connaître le type (modèle) à partir duquel l'élément spécifié par l'identifiant est créé.


Les constantes définissent des zones de mémoire qui ne peuvent pas modifier leurs valeurs lors de l'exécution du programme. Comme tout autre élément du programme, les constantes peuvent avoir leur propre nom. La déclaration des noms de constantes doit être précédée du mot réservé const (de l'anglais constants - constants). Par exemple, nous pouvons définir des constantes const


Ko octet = 1 024 ;


Mo = Ko*Koctet ;


Go = 1024*Mo ;


de sorte qu'au lieu de longs chiffres


1048576 (1024*1024) et 1073741824


(1024*1024*1024) écrivent respectivement Mo et Go. Le type d'une constante est déterminé par la manière dont elle est écrite et est facilement reconnu par le compilateur dans le texte du programme. Le programmeur ne peut donc pas utiliser de constantes nommées (c'est-à-dire ne pas les déclarer explicitement dans le programme).


Les variables sont associées à des zones de mémoire mutables, c'est-à-dire à des zones de mémoire dont le contenu changera pendant le fonctionnement du programme. Contrairement aux constantes, les variables sont toujours déclarées dans le programme. Pour cela, après l'identifiant de la variable, placez deux points et le nom du type à l'image duquel la variable doit être construite. La section de déclaration des variables doit être précédée du mot var. Par exemple:


var


inValue : entier ;


byValue : octet ;


Ici, l'identifiant inValue est déclaré comme une variable entière et l'identifiant byValue est déclaré comme une variable Byte. Le type standard (c'est-à-dire prédéfini en Pascal Objet) entier définit une région de mémoire de quatre octets dont le contenu est traité comme un entier compris entre -2 147 483 648 et +2 147 483 647, et le type standard Byte définit une région de mémoire d'une longueur de 1 octet. , qui contient un entier non signé compris entre 0 et 255 4 . Toutes les informations fournies concernant la plage de valeurs possibles et la capacité mémoire des types standards s'appliquent à Delphi 32. Pour la version 16 bits, ces valeurs ont des significations différentes, par exemple, le type Integer dans la version 1 prend 2 s'incline et a une plage de valeurs allant de -32 768 à +32 767.


Les étiquettes sont les noms des instructions de programme. Les étiquettes sont utilisées très rarement et uniquement pour que le programmeur puisse indiquer au compilateur quelle instruction de programme doit être exécutée ensuite. Les étiquettes, comme les variables, sont toujours déclarées dans un programme. La section de déclaration du label est précédée du mot réservé label.


Les sous-programmes sont des fragments spécialement conçus d'un programme. Une caractéristique remarquable des sous-programmes est leur grande indépendance par rapport au reste du texte du programme. Les propriétés d’un sous-programme sont dites localisées dans son corps. Cela signifie que si le programmeur modifie quelque chose dans le sous-programme, il n'a généralement pas besoin de modifier quoi que ce soit en dehors du sous-programme à cause de cela. Ainsi, les sous-programmes sont un moyen de structurer des programmes, c'est-à-dire de diviser les programmes en un certain nombre de fragments largement indépendants. La structuration est inévitable pour les grands projets logiciels, c'est pourquoi les sous-programmes sont très souvent utilisés dans les programmes Delphi.


Il existe deux types de routines en Pascal Objet : les procédures et les fonctions. Une fonction diffère d'une procédure uniquement en ce que son identifiant peut être utilisé dans des expressions avec des constantes et des variables, puisque la fonction a un résultat de sortie d'un certain type. Si, par exemple, une fonction est définie


Fonction MaFonction : Entier ;


et variable var


X : entier ;


alors l'opérateur d'affectation suivant est possible :


X:= 2*MaFonction-l;


Le nom d'une procédure ne peut pas être utilisé dans une expression car la procédure n'est associée à aucun résultat :


Procédure MaProcédure ;


:


X:= 2*MaProcédure-l; // Erreur!


2.2C++


C++, une extension du langage C, a été développé par Bjarne Stroustrop, employé du centre de recherche AT&T Bell Laboratories (New Jersey, USA), en 1979. C++ contient tout ce qui existe en C. Mais, en plus, il prend en charge la programmation orientée objet (Object Oriented Programming, POO). Le C++ a été créé à l’origine pour faciliter le développement de grands programmes. La programmation orientée objet est une nouvelle approche de la création de programmes.


À l’exception de détails mineurs, C++ est un sur-ensemble du langage de programmation C. En plus des fonctionnalités fournies par C, C++ offre un moyen flexible et efficace de définir de nouveaux types. En utilisant de nouvelles définitions de types qui correspondent étroitement aux concepts de l'application, le programmeur peut diviser le programme en cours de développement en parties faciles à gérer. Cette méthode de création de programmes est souvent appelée abstraction de données. Les informations de type sont contenues dans certains objets de type définis par l'utilisateur. De tels objets sont simples et fiables à utiliser dans des situations où leur type ne peut pas être déterminé au moment de la compilation. La programmation utilisant de tels objets est souvent appelée orientée objet. Lorsqu'elle est utilisée correctement, cette méthode produit des programmes plus courts, plus faciles à comprendre et à contrôler.


Le concept clé en C++ est la classe. Une classe est un type défini par l'utilisateur. Les classes assurent le masquage des données, l'initialisation garantie des données, la conversion de type implicite pour les types définis par l'utilisateur, la définition de type dynamique, la gestion de la mémoire contrôlée par l'utilisateur et les mécanismes de surcharge des opérateurs. C++ fournit de bien meilleurs moyens d’exprimer la modularité du programme et la vérification de type que le C. Le langage présente également des améliorations non directement liées aux classes, notamment des constantes symboliques, la substitution de fonctions en ligne, les paramètres de fonction par défaut, les noms de fonctions surchargés, les opérations de gestion de mémoire libre et le type de référence. C++ conserve les capacités du langage C pour travailler avec des objets matériels de base (bits, octets, mots, adresses, etc.). Cela vous permet d'implémenter très efficacement des types définis par l'utilisateur.


C++ et ses bibliothèques standards sont conçus pour être portables. L'implémentation actuelle du langage fonctionnera sur la plupart des systèmes prenant en charge le C. Les programmes C++ peuvent utiliser les bibliothèques C, et la plupart des outils prenant en charge la programmation C peuvent être utilisés avec C++.


Un programme C++ se compose généralement d'un grand nombre de fichiers sources, chacun contenant des déclarations de types, de fonctions, de variables et de constantes. Pour qu'un nom utilisé dans différents fichiers sources fasse référence au même objet, il doit être déclaré comme externe. Par exemple:


externe double sqrt(double);


cinétique externe;


Le moyen le plus courant d'assurer la cohérence entre les fichiers sources consiste à placer ces déclarations dans des fichiers séparés appelés fichiers d'en-tête (ou fichiers d'en-tête), puis à inclure, c'est-à-dire à copier, ces fichiers d'en-tête dans tous les fichiers où ces déclarations sont nécessaires. Par exemple, si la description de sqrt est stockée dans le fichier d'en-tête des fonctions mathématiques standard math.h et que vous souhaitez extraire la racine carrée de 4, vous pouvez écrire :


#inclure


//…


x = carré(4);


Étant donné que les fichiers d'en-tête normaux sont inclus dans de nombreux fichiers sources, ils ne contiennent pas de descriptions qui ne doivent pas être répétées. Par exemple, les corps de fonction sont donnés uniquement pour les fonctions inline-inline (voir ce paragraphe) et les initialiseurs ne sont donnés que pour les constantes (voir ce paragraphe). Sauf dans ces cas, le fichier d'en-tête est le référentiel des informations de type. Il fournit une interface entre les parties compilées séparément d’un programme.


Dans une commande include, le nom de fichier entre crochets, par exemple, fait référence à un fichier de ce nom dans le répertoire standard (souvent /usr/include/CC) ; les fichiers situés à d'autres emplacements sont référencés à l'aide de noms entourés de guillemets doubles.


Par exemple:


#include "math1.h"


#include "/usr/bs/math2.h"


inclura math1.h du répertoire utilisateur actuel et math2.h du répertoire /usr/bs.


Voici un très petit exemple complet de programme dans lequel une chaîne est définie dans un fichier et imprimée dans un autre. Le fichier header.h définit les types requis :


// en-tête.h


extern char* nom_prog ;


externe vide f();


Le fichier main.c contient le programme principal :


// principal c


#include "en-tête.h"


char* prog_name = "bon, mais complet";


principal()


{


F();


}


et le fichier f.c imprime la ligne :


//f.c


#inclure


#include "en-tête.h"


vide f()


{


cout<< prog_name << «\n»;


}


Par exemple, vous pouvez compiler et exécuter le programme comme ceci :


$ CC main.c f.c -o idiot


$idiot


bien mais complet


$


Un langage qui prend en charge les technologies de localisation de données, d'abstraction de données et de programmation orientée objet, pour être un langage à usage général, doit également :


Être implémenté sur des ordinateurs traditionnels ;


Exécuter dans l’environnement des systèmes d’exploitation traditionnels ;


Être compétitif avec les langages de programmation traditionnels en termes d'efficacité lors de l'exécution des programmes ;


Convient à la plupart des applications possibles.


Cela signifie que des fonctionnalités permettant des applications numériques efficaces doivent être incluses (arithmétique flottante sans surcharge, sinon Fortran sera plus attractif). Les capacités d'accès à la mémoire doivent être activées (ce qui est nécessaire pour l'écriture des pilotes). Il doit y avoir des possibilités d'accès à des fonctions (appels d'appel) compatibles avec les interfaces de systèmes d'exploitation spécifiques. Et, en plus, il devrait être possible d'accéder à des fonctions écrites dans d'autres langages et vice versa, à des fonctions écrites dans des langages orientés objet depuis d'autres langages.


Le tableau 1 montre les avantages et les inconvénients des langages orientés objet.


Tableau 1 - Avantages et inconvénients des langages orientés objet


avantages	Inconvénients
Les classes vous permettent de construire des composants utiles avec des outils simples, ce qui permet de faire abstraction des détails d'implémentation.	Doit comprendre les concepts de base tels que les classes, l'héritage et la liaison dynamique
Les données et les opérations forment ensemble une entité spécifique et elles ne sont pas « étalées » tout au long du programme, comme c'est souvent le cas avec la programmation procédurale.	La réutilisabilité nécessite que le programmeur se familiarise avec les grandes bibliothèques de classes
La localisation du code et des données améliore la visibilité et la maintenabilité des logiciels	Concevoir des classes est une tâche bien plus difficile que de les utiliser
L'encapsulation des informations protège les données les plus critiques contre tout accès non autorisé.	Il est très difficile d’étudier des cours sans pouvoir les « toucher ».
Vous permet de créer des systèmes extensibles	Inefficacité en termes d'allocation de mémoire

La technologie orientée objet offre aux utilisateurs des performances améliorées tout au long du cycle de vie du logiciel, ce qui se traduit par un réel retour sur investissement. Des performances accrues sont obtenues lorsqu'il existe quatre propriétés principales des systèmes orientés objet et les avantages qui en résultent :


l'utilisation d'objets comme modèles de base permet à l'utilisateur de simuler des systèmes complexes du monde réel ;


la flexibilité des textes orientés objet permet de répondre rapidement aux changements des besoins des utilisateurs ;


la réutilisation de composants standards réduit à la fois le temps de développement de nouvelles tâches applicatives et le volume de code généré ;


la simplicité du logiciel le rend plus flexible et réduit les coûts d'exploitation.


Parallèlement à ces avantages évidents, l'utilisation de langages et d'environnements de programmation orientés objet facilite le développement logiciel incrémental. Le prototypage rapide des interfaces vous permet de tester les réponses des utilisateurs quel que soit le corps principal de la tâche applicative. La valeur de cette approche est particulièrement évidente dans les projets dont les tâches d'application sont floues ou difficiles à comprendre.


Actuellement, il existe peu de mesures objectives de la croissance de la productivité en raison du fait que la plupart des projets liés aux systèmes orientés objet en sont à leurs débuts. L'une des sociétés, STC Technology (Royaume-Uni), qui a effectué des estimations comparatives, a calculé que la phase de développement d'un projet orienté objet prend deux fois moins de temps qu'une tâche similaire dans un système traditionnel et nécessite un quart d'heures de travail.


Le premier avantage majeur des systèmes orientés objet vient de la nature de leur connexion au monde réel. Un développeur peut concevoir un système physique dans un système logiciel en définissant initialement tous les objets physiques importants et leurs objets logiciels correspondants. Les groupes d'objets physiques associés sont cartographiés en classes, qui peuvent être organisées selon une hiérarchie, en commençant par les classes générales et en leur ajoutant des sous-classes spécialisées. Les procédures communes à plusieurs classes se trouvent dans leur superclasse commune et sont héritées par celles-ci.


Par exemple, dans un système de mesure développé chez Combuston Engineering (Columbus, Ohio), un groupe de capteurs est représenté par une classe Sensor qui définit les propriétés communes de tous les capteurs. Des sous-classes sont définies pour chaque type de capteur du système, tel qu'optique ou infrarouge. Ils héritent des procédures générales qui s'appliquent à tous les capteurs et contiennent des procédures supplémentaires qui s'appliquent uniquement aux capteurs optiques ou infrarouges.


L'approche orientée objet réduit le fossé conceptuel entre le monde réel et le modèle informatique. Il permet aux analystes et aux concepteurs de comprendre clairement la structure du système. Comme le note un utilisateur : « Je peux représenter mes pensées avec le texte du programme sous la forme que je pense. » Par conséquent, les systèmes orientés objet sont aujourd’hui utilisés pour modéliser des systèmes physiques complexes dans les applications manufacturières, de télécommunications et militaires et de défense.


Le deuxième avantage des systèmes orientés objet vient de la manière dont les objets sont interconnectés via des messages. Dans l'exemple ci-dessus, des messages généraux tels que « démarrer la mesure » ​​pourraient être envoyés à tous les capteurs du système ; chacun d'eux répond d'une manière spécifique. Si l'un des capteurs physiques est obsolète, il est remplacé. Parallèlement, la classe correspondante du système change : pour un nouveau type de capteur, une nouvelle classe est introduite, contenant des procédures spécifiques au nouveau capteur. La nouvelle classe hérite des procédures restantes dont elle a besoin de la superclasse. Lorsque le nouveau capteur reçoit un message général, il répond en conséquence. Le corps de l'ensemble du système et les messages généraux restent inchangés.


La flexibilité des systèmes orientés objet constitue un avantage certain pour les utilisateurs dans des environnements en évolution rapide tels que la technologie de programmation. Par exemple, Computer Science Corporation a utilisé le langage orienté objet Smalltalk pour développer son produit Design Generator. L'entreprise note que grâce à l'utilisation de la technologie orientée objet, les développeurs de programmes sont en mesure de réagir rapidement aux nouvelles tendances du marché dans un environnement de plus en plus concurrentiel.


Le troisième avantage des systèmes orientés objet est que les classes peuvent hériter des procédures d'autres classes. Une entreprise peut compiler des bibliothèques des classes les plus couramment utilisées, contenant des procédures conçues pour des besoins spécifiques et utilisées dans les tâches applicatives ultérieures. Par exemple, une société de développement de logiciels peut créer une bibliothèque de classes pour les primitives graphiques telles qu'un cylindre, un cône ou une sphère. Ceux-ci constituent la base de sous-classes telles que la section conique ou la section. La réutilisation du code source réduit le temps de développement et permet aux concepteurs de résoudre en toute confiance des problèmes dans divers domaines.


Dans le passé, les développeurs de logiciels utilisaient des bibliothèques de routine pour résoudre des problèmes standards tels que des calculs mathématiques. Les systèmes orientés objet permettent une plus large gamme de réutilisation des textes de programme. L'un des premiers utilisateurs, Cadre Technologies, a calculé que le volume de code pour une nouvelle tâche d'application est réduit d'un rapport de 5 : 1 lors de l'utilisation de programmes orientés objet.


Les bibliothèques d'objets peuvent également être achetées auprès de fournisseurs indépendants. Actuellement, ces bibliothèques de classes sont achetées le plus activement pour créer des interfaces utilisateur avec des icônes. Concevoir et écrire de telles interfaces à partir de zéro n’est pas une tâche facile. Des sociétés comme Apple et Whitewater Group fournissent des outils permettant de créer rapidement de telles interfaces basées sur quelques classes de base telles que Window, Menu, ScrollBar et Icon. Les utilisateurs peuvent utiliser à la fois ces classes et leurs sous-classes qui ajoutent, par exemple, des icônes spéciales à l'interface.


Le quatrième avantage réside dans la manière dont les modules logiciels orientés objet sont packagés. Les logiciels traditionnels sont constitués de données et de procédures qui accèdent et modifient les données. Les données et les procédures sont regroupées séparément, de sorte que la modification de la structure des données affecte différents modules écrits par différents utilisateurs. Dans un système orienté objet, les données et les procédures sont considérées ensemble comme faisant partie d'un seul package : un objet. Lorsque les données changent, toutes les procédures impliquées sont facilement identifiées et modifiées simultanément. Étant donné que le changement n’affecte qu’un seul domaine du système, son effet d’entraînement sur l’ensemble du système est réduit.


On sait que les coûts de maintenance représentent jusqu'à 80 % du coût du cycle de vie d'un système de programmation. Les développeurs de grands systèmes complexes, souvent confrontés à la nécessité de les modifier, sont enclins à utiliser OOS comme l'un des moyens de réduire les coûts de maintenance et d'augmenter la fiabilité de leurs produits. Par exemple, Wild Leitz (Toronto, Canada) a utilisé le langage orienté objet Objective-C pour développer un système d'information géographique. L'entreprise a trouvé que le code source dans ce langage était plus facile à maintenir, car il est plus court, autonome et réduit l'impact de la modification d'un module sur le reste du système.


Les programmes correctement conçus doivent non seulement satisfaire leurs exigences fonctionnelles, mais également posséder des propriétés telles que :


réutilisabilité;


extensibilité;


résistance aux données incorrectes ;


systématique.


Un style de programmation orienté objet approprié garantit la présence de ces propriétés. Expliquons cela en utilisant l'exemple de la propriété de systématique.


Un programme a la propriété d'être systématique s'il est applicable comme opérateur généralisé en « programmation en gros blocs ». La programmation en gros blocs est l'utilisation systématique de grandes unités logicielles précédemment développées (telles que des classes, des sous-systèmes ou des modules) dans le développement de nouveaux systèmes logiciels.


Les limites des systèmes orientés objet (OOS) modernes sont principalement liées à leurs imperfections. Surmonter ces limitations constitue un défi pour les éditeurs de logiciels et une opportunité pour de nouveaux fournisseurs d'entrer sur le marché. Ce chapitre aborde les défis du développement de systèmes orientés objet et fournit un calendrier pour surmonter leurs faiblesses.


Le principal obstacle aux systèmes orientés objet aujourd'hui est la résistance du personnel technique et de direction. Cette résistance est naturelle étant donné la nature imparfaite de nombreux produits orientés objet sur le marché aujourd’hui. L'imperfection se manifeste par un certain nombre de problèmes inhérents à la plupart des nouvelles technologies :


accès limité sur un certain nombre de plateformes standards ;


la nécessité d'une intégration avec les systèmes et bases de données existants ;


manque de logiciels pour programmer des systèmes à grande échelle.


Le succès de la technologie orientée objet est dû à sa pénétration dans le courant dominant de l’industrie informatique. Pour que cela se produise, il faut résoudre les problèmes mentionnés ci-dessus. Mais c’est une activité assez coûteuse et qui prend beaucoup de temps. Certains des premiers fournisseurs de systèmes orientés objet ont ajouté à leurs problèmes en choisissant des langages propriétaires non standard comme base de leurs produits. Ayant reçu d'importants investissements en capital, ces entreprises seront confrontées à de graves problèmes dans la lutte pour occuper leur niche sur le marché.


Un langage orienté objet ne peut pas s'appuyer entièrement sur des mécanismes qui ne sont pas efficacement implémentés sur les architectures traditionnelles, et un tel langage est toujours destiné à être utilisé comme langage généraliste. La même chose peut être dite pour le garbage collection, qui peut constituer un goulot d’étranglement en termes de performances et de portabilité. La plupart des langages orientés objet utilisent le garbage collection pour simplifier les problèmes du programmeur et réduire la complexité du langage lui-même et du compilateur. Cependant, il devrait être possible d'utiliser le garbage collection dans des situations non critiques, tout en conservant le contrôle de la mémoire si nécessaire. Une alternative est un langage qui ne fait pas l'objet d'un garbage collection mais vous permet de concevoir des types qui gèrent la mémoire qu'ils utilisent. Un exemple serait C++.


La gestion des exceptions et l’utilisation de ressources spécifiques posent également des problèmes. Toute fonctionnalité linguistique implémentée à l’aide d’un éditeur de liens présentera probablement également un problème de portabilité.


Une alternative à l’inclusion de fonctionnalités de bas niveau dans un langage consiste à utiliser des langages spécialisés de bas niveau dans les cas critiques.


La programmation orientée objet est une programmation qui utilise le mécanisme d'héritage. L'abstraction de données consiste à programmer à l'aide de types définis par l'utilisateur. À quelques exceptions près, la programmation orientée objet peut et doit être une généralisation de l'abstraction de données.


Ce mécanicien a besoin d’un support linguistique approprié pour être efficace. Pour l’abstraction des données, seule la prise en charge du langage est suffisante ; La programmation orientée objet nécessite des outils issus d'un environnement logiciel à l'échelle du système. Pour avoir les propriétés d’un langage généraliste, le langage doit permettre une utilisation efficace du matériel traditionnel.





Riz. 3. Schéma simplifié de l'organisation d'un système multi-modules pour travailler avec des objets géométriques


La structure multimodulaire du système présente les avantages suivants.


Extensibilité. L'ajout de nouvelles classes et de leurs interactions ne se fait pas en réécrivant le code existant, mais en développant de nouveaux modules.


Possibilité de réutilisation du code. Le module Objets géométriques peut être inclus dans n'importe quelle application, si elle dispose également de fenêtres de démonstration, vous pouvez également inclure la visualisation.


Possibilité de mise en œuvre étape par étape des programmes. Ainsi, la première version peut inclure des objets géométriques, des fenêtres de démonstration et une visualisation, la seconde ajoutera des calculs, etc.


Possibilité d'utiliser la méthode de production par convoyeur, en « parallélisant » le processus de développement du logiciel.


Il existe plusieurs raisons pour lesquelles C++ ne peut pas être considéré comme un langage de programmation dynamique.


Interface statique et implémentation de classe. L'interface d'une classe s'entend comme l'ensemble de ses attributs et méthodes (définis par la description de la classe, généralement placée dans le fichier d'en-tête), tandis que l'implémentation est le code spécifique exécuté lorsque ces méthodes sont appelées. Le premier et le second doivent être définis avant le début de la compilation ; vous ne pouvez pas au moment de l’exécution ajouter une variable ou une méthode à une classe ou remplacer une variable existante.


Mais lors du développement de nouveaux modules, il est constamment nécessaire de modifier les classes existantes ! Ainsi, lors du développement de calculs, vous aurez peut-être besoin de fonctions qui calculent la longueur d'une ligne, sa courbure en un certain point ou l'aire d'une figure. Lors du développement d'une visualisation, des variables telles que la couleur, l'épaisseur des lignes peuvent être nécessaires ; pour les figures plates, une triangulation (partition en triangles) doit souvent être construite. De plus, les fonctions ci-dessus dépendent fortement du type d'objet : elles doivent être écrites séparément pour les rectangles, les cercles et les objets géométriques arbitraires.


Vérification de type statique.


Lors de l'analyse de l'expression p->f(), le compilateur "doit être sûr" que l'objet pointé par le pointeur p contient réellement une méthode f(). Même les modèles ne permettent pas toujours de créer du code qui traite différents types d'objets : au stade de la compilation et de l'assemblage, vous devez savoir lesquels d'entre eux doivent être installés, lequel est utilisé dans chaque cas spécifique. Essayez la tâche du listing 1 sans changer de classe ni utiliser les constructions if-then-else + Dynamic_cast.


/*


Listing 1. La vérification de type statique limite l'utilisation du polymorphisme


*/


classe classe de base ();


classe A : classe de base publique


{


publique:


UN();


// la classe A contient la méthode void f()


vide virtuel f();


};


classe B : classe de base publique


{


publique:


B();


// la classe B ne contient pas de méthode void f()


};


classe C:classe de base publique (...);


/*


Obligatoire d'écrire


(sans changer les classes ci-dessus et sans utiliser if-then-else + Dynamic_cast) :


*/


bool CallF (classe de base *p)


{


/*


si p->f() est défini, appelez cette fonction et retournez true,


sinon renvoie faux


*/


}


C++ propose trois façons d'implémenter la fonction CallF. La première (la plus utilisée) consiste à ajouter la méthode bool f() à la classe de base, dans les sous-classes où cela a du sens - effectuer les actions nécessaires et renvoyer true, dans le reste - renvoyer false. La seconde consiste à créer une classe baseclass_f:public baseclass, à en hériter de toutes les classes contenant f() et à utiliser Dynamic_cast.< baseclass_f *>. Le troisième est le fameux if-then-else + Dynamic_cast dans CallF. La première option conduit à un colmatage de la classe de base, et la classe de base peut ne pas être accessible (par exemple, contenue dans un module « fermé »). La seconde nécessite de repenser l’ensemble du système d’objets. Et si vous deviez ensuite écrire CallG, CallH ? Bien sûr, C++ prend en charge l’héritage multiple, mais la hiérarchie des classes avec cette approche deviendra beaucoup plus compliquée et il ne sert à rien de la modifier « d’avant en arrière ». Les inconvénients de la troisième méthode ont été discutés à plusieurs reprises : la fonction CallF devra être réécrite chaque fois qu'une nouvelle classe sera introduite prenant en charge f().


Impossibilité de modifier des objets de classe individuels au moment de l'exécution. Il semblerait que si les objets appartiennent à la même classe, ils devraient alors se comporter de la même manière. Si vous n'êtes pas satisfait d'une manière ou d'une autre d'une classe existante, « héritez-en » et modifiez ce que vous voulez. Cependant, la possibilité de modifier dynamiquement les objets individuels d’une classe est souvent très utile. Bien entendu, l’héritage est un moyen flexible et pratique de modifier les fonctionnalités des classes. Mais une fois qu'un objet est créé, il n'est plus possible de modifier ses méthodes ou d'ajouter de nouvelles méthodes et variables. Pour ce faire, vous devez supprimer l'objet existant puis en créer un nouveau. Dans ce cas, vous devez prendre soin de mettre à jour tous les pointeurs vers cet objet et de sauvegarder ses propriétés. De plus, si de nouvelles classes sont créées à chaque fois, leur nombre peut dépasser toutes les limites raisonnables.


Conclusion


Le langage de programmation orienté objet le plus courant est de loin le C++. Des systèmes de programmation C++ commerciaux disponibles gratuitement existent sur pratiquement toutes les plateformes. Le système de programmation G++ distribué gratuitement est largement connu, ce qui donne à chacun la possibilité d'analyser le code source assez bien et minutieusement commenté de l'un des compilateurs exemplaires du langage C++. Les idées principales de l'approche orientée objet reposent sur les dispositions suivantes : un programme est un modèle d'un processus réel, faisant partie du monde réel ; un modèle du monde réel ou une partie de celui-ci peut être décrit comme un ensemble d'objets interagissant les uns avec les autres ; un objet est décrit par un ensemble de paramètres dont les valeurs déterminent l'état de l'objet, et un ensemble d'opérations (actions) que l'objet peut effectuer ; l'interaction entre les objets s'effectue en envoyant des messages spéciaux d'un objet à un autre. Un message reçu par un objet peut nécessiter certaines actions, telles que changer l'état de l'objet ; Les objets décrits par le même ensemble de paramètres et capables d'effectuer le même ensemble d'actions constituent une classe d'objets du même type.


Du point de vue du langage de programmation, une classe d’objets peut être considérée comme un type de donnée, et un objet individuel peut être considéré comme une donnée de ce type. La définition par le programmeur de ses propres classes d'objets pour un ensemble spécifique de tâches doit lui permettre de décrire des tâches individuelles en termes de classe de tâches elle-même (avec un choix approprié de noms de types et de noms d'objets, de leurs paramètres et des actions effectuées).


Ainsi, l'approche orientée objet suppose que lors du développement d'un programme, les classes d'objets utilisées dans le programme doivent être déterminées et leurs descriptions doivent être construites, puis des instances des objets nécessaires doivent être créées et l'interaction entre eux doit être définie.


Il est souvent pratique de structurer les classes d'objets de manière à ce qu'elles forment une structure hiérarchique.


De toute évidence, afin d'utiliser de manière productive l'approche objet pour le développement de programmes, des langages de programmation sont nécessaires pour prendre en charge cette approche, c'est-à-dire vous permettant de créer une description des classes d'objets, de générer des données sur les types d'objets et d'effectuer des opérations sur les objets. L'un des premiers langages de ce type était le langage SmallTalk, dans lequel toutes les données sont des objets de certaines classes, et le système de classes global est construit comme une structure hiérarchique basée sur des classes de base prédéfinies.


L'expérience en programmation montre que toute approche méthodologique en technologie de programmation ne doit pas être appliquée aveuglément, en ignorant les autres approches. Cela s’applique également à l’approche orientée objet. Il existe un certain nombre de problèmes typiques pour lesquels son utilité est la plus évidente ; ces problèmes incluent, en particulier, les tâches de modélisation par simulation et les dialogues de programmation avec l'utilisateur. Il existe également des problèmes dans lesquels l'utilisation de l'approche objet n'entraînera que des coûts de main-d'œuvre inutiles. À cet égard, les langages de programmation orientés objet, qui permettent de combiner l'approche objet avec d'autres méthodologies, sont devenus les plus répandus. Dans certains langages et systèmes de programmation, l'utilisation de l'approche objet est limitée aux outils d'interface utilisateur (par exemple, les premières versions de Visual FoxPro).


Liste de la littérature utilisée

1. Arkhangelsky A. Programmation en Delphi pour Windows. Versions 2006, 2007, Turbo Delphi + CD. –M. : Binom. Laboratoire de connaissances, 2006.
   

   Arkhangelsky A. Langage C++ dans C++Builder. Manuel de référence et méthodologique. – M. : Binom. Laboratoire de connaissances, 2008.
   

   Bucknell J. Algorithmes fondamentaux et structures de données dans Delphi. Bibliothèque des programmeurs – Saint-Pétersbourg : Peter, DiaSof, 2006.
   

   Galiseev G.V. Composants dans Delphi 7. Travail professionnel. – M. : Williams, 2006.
   

2. Gamma E. Techniques de conception orientée objet. Modèles de conception. Saint-Pétersbourg : Peter, 2006.
   Résoudre le problème sur la base du texte des lois d'Hammourabi améliorant la comptabilité des immobilisations d'une entreprise agricole Quel est le délai pour réaliser un inventaire des immobilisations ?

   2014-05-28