'>

langage de programmation C++

C + + (prononcé «voir plus plus») est une forme libre, multi-paradigme, compilé, langage de programmation généraliste typé statiquement. Il est considéré comme une langue de niveau intermédiaire, car il comprend à la fois des fonctionnalités de langage de haut niveau et de bas niveau. [3] Développé par Bjarne Stroustrup à partir de 1979 aux Bell Labs, C + + a été initialement nommé C avec des classes, l'ajout de fonctionnalités orientées objet , telles que les classes, et d'autres améliorations apportées au langage de programmation C. La langue a été rebaptisé C + + en 1983 [4], comme un jeu de mots impliquant l'opérateur d'incrémentation.

C + + est l'un des langages de programmation les plus populaires [5] [6] et est mis en œuvre sur une grande variété de plateformes matérielles et systèmes d'exploitation. Comme un compilateur efficace en code natif, ses domaines d'application comprennent les logiciels, logiciels d'application, les pilotes de périphériques, logiciels embarqués, serveur haute performance et les applications clientes, et des logiciels de divertissement comme les jeux vidéo. [7] Plusieurs groupes de fournir à la fois libres et propriétaires C + + compiler le logiciel, y compris le projet GNU, LLVM, Microsoft, Intel et Embarcadero Technologies. C + + a considérablement influencé de nombreux autres langages de programmation, notamment C # [2] et Java.

C + + est également utilisé pour la conception du matériel, dont la conception est d'abord décrite en C + +, puis analysé, architecturalement contraint, et prévu de créer un niveau de langage de description matérielle registres de transfert via la synthèse de haut niveau. [8]

La langue a commencé comme améliorations apportées à C, en ajoutant première classes, puis les fonctions virtuelles, la surcharge des opérateurs, l'héritage multiple, des modèles et la gestion des exceptions, entre autres caractéristiques. Après des années de développement, le standard C + + langage de programmation a été ratifié en 1998 sous la référence ISO / IEC 14882:1998. La norme a été modifiée par le rectificatif technique 2003 ISO / IEC 14882:2003. La norme actuelle extension C + + avec de nouvelles fonctionnalités a été ratifiée et publiée par l'ISO en Septembre 2011 en tant que norme ISO / IEC 14882:2011 (officieusement connu sous le nom C + +11).

Histoire
Bjarne Stroustrup, créateur du C + +

Bjarne Stroustrup, un informaticien qualifié danois et britannique, a commencé son travail sur "C avec des classes» en 1979. [4] L'idée de créer une nouvelle langue est originaire de l'expérience de Stroustrup dans la programmation pour son Ph.D. thèse. Stroustrup constaté que Simula avait des caractéristiques qui ont été très utiles pour le développement de logiciels grand, mais la langue était trop lente pour une utilisation pratique, tandis que BCPL était rapide mais trop bas niveau pour être adapté pour le développement de logiciels grand. Quand Stroustrup a commencé à travailler dans AT & T Bell Labs, il avait le problème de l'analyse du noyau UNIX en ce qui concerne l'informatique distribuée. Se souvenant de sa Ph.D. expérience, Stroustrup a entrepris d'améliorer le langage C avec des fonctionnalités Simula-like. C a été choisi parce qu'il était polyvalent, rapide, portable et largement utilisé. Outre C et Simula, d'autres langues qui ont inspiré lui étaient Algol 68, Ada, CLU et ML. Dans un premier temps, la classe, la classe dérivée, le typage fort, inline, et les caractéristiques de l'argument par défaut ont été ajoutés à C par l'intermédiaire de Stroustrup "C avec des classes» pour compilateur C, Cpre [10].

En 1983, le nom de la langue a été modifiée à partir de C avec des classes de C + + (+ + étant l'opérateur d'incrémentation en C). Les nouvelles fonctionnalités ont été ajoutées, notamment des fonctions virtuelles, le nom de la fonction et la surcharge des opérateurs, des références, des constantes, le contrôle de la mémoire contrôlée par l'utilisateur libre-boutique, l'amélioration de la vérification de type et le style BCPL commentaires sur une ligne avec deux barres obliques (/ /), ainsi que le développement d'un compilateur approprié pour C + +, Cfront. En 1985, la première édition de The C + + Programming Language a été libéré, fournissant une référence importante à la langue, car il n'y avait pas encore une norme officielle. [11] La première application commerciale de C + + a été publié en Octobre de la même année. [ 12] La version 2.0 de C + + est venu en 1989 et la deuxième édition mise à jour du C + + Programming Language a été libéré en 1991. [13] Les nouvelles fonctionnalités incluses héritage multiple, classes abstraites, les fonctions membres statiques, les fonctions membres const, et les membres protégées. En 1990, The Annotated C + + Manuel de référence a été publié. Ce travail a servi de base pour la future norme. Ajouts de fonctionnalités incluses fin templates, les exceptions, les espaces de noms, de nouveaux moulages, et un type Boolean.

Comme le langage C + + a évolué, la bibliothèque standard évolué avec elle. Le premier ajout à la bibliothèque C + + standard était la bibliothèque E / S qui a fourni des installations pour remplacer les fonctions C classiques telles que printf et scanf flux. Plus tard, parmi les ajouts les plus significatifs de la bibliothèque standard, était une grande quantité de la Standard Template Library.

Il est possible d'écrire du code objet orienté ou de procédure dans le même programme en C + +. Cela a causé une certaine inquiétude que certains programmeurs C + + sont encore en train d'écrire le code de procédure, mais sont sous l'impression qu'il est orienté objet, tout simplement parce qu'ils utilisent C + +. Souvent, il s'agit d'un amalgame des deux. Cela provoque généralement la plupart des problèmes lorsque le code est revisité ou la tâche est prise en charge par un autre codeur. [14]

C + + continue d'être utilisé et est l'un des langages de programmation préférés pour développer des applications professionnelles. [15]
Étymologie

Selon Stroustrup: "le nom signifie la nature évolutive des changements de C» [16] Au cours de C + + 's période de développement, la langue avait été désigné comme "nouveau C", puis "C avec des classes".. Le nom définitif est crédité de Rick Mascitti (mi-1983) et a d'abord été utilisé en Décembre 1983. Quand Mascitti a été interrogé de manière informelle en 1992 à propos de la nomination, il a indiqué qu'il a été donné dans un esprit pince-sans-rire. Il découle de "+ +" l'opérateur de C (qui incrémente la valeur d'une variable) et une convention de nommage commun d'utiliser "+" pour indiquer un programme informatique amélioré. Une blague raconte que le nom lui-même a un bug: en raison de l'utilisation de post-incrémentation, qui incrémente la valeur de la variable, mais évalue à la valeur non incrémentée, C + + n'est pas mieux que C, et la pré-incrémentation + + C forme aurait dû être utilisé à la place. [17] Il n'ya pas de langage appelé "C plus". ABCL / c + était le nom de, un langage de programmation indépendants plus tôt. Quelques autres langues ont été nommés de manière similaire à C + +, notamment C - et C #.
Normalisation
Année C + + nom informel standard
1998 ISO / IEC 14882:1998 [18] C + +98
2003 ISO / IEC 14882:2003 [19] C + +03
2007 ISO / CEI TR 19768:2007 [20] C + + TR1
2011 ISO / IEC 14882:2011 [21] C + +11

En 1998, le C + + Comité des normes (le groupe de travail ISO / IEC JTC1/SC22/WG21) normalisé C + + et publié la norme internationale ISO / IEC 14882:1998 (officieusement connu sous le nom C + +98). Depuis quelques années après la sortie officielle de la norme, le comité transformé les rapports de défectuosité, et en 2003 a publié une version corrigée du C + + standard, ISO / IEC 14882:2003. En 2005, un rapport technique, appelée le «rapport technique de la bibliothèque 1" (souvent connu sous le nom TR1 pour faire court), a été libéré. Bien que n'étant pas officiellement partie de la norme, elle a précisé un certain nombre d'extensions à la bibliothèque standard, qui devaient être inclus dans la prochaine version de C + +.

La dernière révision majeure de la norme C + +, C + +11, (anciennement connue sous le nom C + +0 x) a été approuvé par ISO / CEI le 12 Août 2011. [22] Il a été publié sous 14882:2011. [23] sont des plans pour un mineur (C + +14) et une révision majeure (C + +17) à l'avenir. [24]

C + +14 est le nom utilisé pour la prochaine révision. C + +14 est prévu pour être une petite extension sur C + +11, avec principalement des corrections de bugs et de petites améliorations, de manière similaire à la façon dont C + +03 est une petite extension pour C + +98. Alors que le nom de «C + +14' implique une libération en 2014, cette date n'est pas fixée.
Philosophie

Dans la conception et l'évolution de C + + (1994), Bjarne Stroustrup décrit quelques règles qu'il a utilisé pour la conception du C + +: [la page nécessaire]

    C + + est conçu pour être un typage statique, la langue d'usage général qui est aussi efficace et portable C
    C + + est conçu pour soutenir directement et complètement plusieurs styles de programmation (programmation procédurale, l'abstraction des données, la programmation orientée objet et la programmation générique)
    C + + est conçu pour donner le choix du programmateur, même si cela permet au programmeur de choisir incorrectement
    C + + est conçu pour être compatible avec C, autant que possible, offrant ainsi une transition en douceur à partir de C
    C + + permet d'éviter des fonctionnalités qui sont but précis ou pas grand plate-forme
    C + + ne comporte pas de frais généraux pour les fonctions qui ne sont pas utilisées (le «principe zéro frais généraux»)
    C + + est conçu pour fonctionner sans un environnement de programmation sophistiquée

A l'intérieur du C + + Object Model (Lippman, 1996) décrit comment les compilateurs peuvent convertir C + + déclarations de programme dans une mise en mémoire. auteurs du compilateur sont toutefois libres d'appliquer la norme à leur manière.
Bibliothèque standard

De 1998 ANSI / ISO C + + standard se compose de deux parties: le noyau du langage et de la bibliothèque C + + standard, celui-ci comprend la plupart du Standard Template Library (STL) et une version légèrement modifiée de la bibliothèque standard C. Beaucoup C + + bibliothèques existent qui ne font pas partie de la norme, et, en utilisant la spécification de liaison, les bibliothèques peuvent même être écrits dans des langages tels que BASIC, C, Fortran, Pascal ou. Lequel de ceux-ci sont pris en charge est compilateur-dépendante.

La bibliothèque C + + standard comprend la bibliothèque standard C avec quelques petites modifications pour le rendre plus optimisée avec le langage C + +. Une autre grande partie de la bibliothèque C + + est basé sur la STL. Cette offre ces outils utiles comme des récipients (par exemple des vecteurs et des listes), itérateurs pour fournir ces conteneurs avec semblable au tableau d'accès et algorithmes pour effectuer des opérations telles que la recherche et le tri. En outre (multi) cartes (tableaux associatifs) et des (multi) sont prévus, qui exporter des interfaces compatibles. Par conséquent, il est possible, en utilisant des modèles, à écrire des algorithmes génériques qui fonctionnent avec n'importe quel récipient ou sur une séquence définie par les itérateurs. Comme en C, les fonctions de la bibliothèque sont accessibles à l'aide de la directive # include pour inclure un en-tête standard. C + + fournit 105 têtes standard, dont 27 sont obsolètes.

La STL a été initialement conçu par Alexander Stepanov, qui a expérimenté avec des algorithmes et des conteneurs génériques depuis de nombreuses années. Quand il a commencé avec C + +, il a finalement trouvé un langage où il était possible de créer des algorithmes génériques (par exemple, STL genre) qui effectuent encore mieux que, par exemple, le C bibliothèque standard qsort, grâce au C + + des fonctionnalités telles que l'aide inline et compilation temps de liaison à la place des pointeurs de fonction. La norme ne fait pas référence à lui comme "STL", car il s'agit simplement d'une partie de la bibliothèque standard, mais le terme est encore largement utilisé pour le distinguer du reste de la bibliothèque standard (flux d'entrée / sortie, l'internationalisation, les diagnostics, le sous-ensemble de la bibliothèque C, etc.)

La plupart des compilateurs C + + fournir une implémentation de l'+ + bibliothèque standard C, y compris la STL. Compiler implémentations indépendantes de la STL, comme STLPort [25], existent également. D'autres projets produisent aussi diverses implémentations personnalisées de la bibliothèque C + + standard et la STL avec différents objectifs de conception.
caractéristiques linguistiques

C + + hérite de la plupart de la syntaxe de C. Ce qui suit est la version de Bjarne Stroustrup du programme Bonjour tout le monde qui utilise le + + facilité de flux de la bibliothèque standard C pour écrire un message sur la sortie standard: [26] [27]

# Include <iostream>

int main ()
{
   std :: cout << "Bonjour, world \ n";
}

Dans les fonctions qui définissent un type de retour non nulle, le défaut de retourner une valeur avant que la commande arrive à la fin des résultats de fonction à un comportement indéfini (compilateurs fournissent généralement les moyens d'émettre un diagnostic dans un tel cas). [28] La seule exception à cette règle est la fonction principale, qui renvoie implicitement une valeur de zéro. [29]
Les opérateurs et la surcharge d'opérateur
Les opérateurs qui ne peuvent pas être surchargé symbole d'opérateur
opérateur de résolution de portée ::
Opérateur conditionnel?:
opérateur point.
opérateur de sélection des membres. *
"Sizeof" opérateur sizeof
"Typeid" opérateur typeid

C + + fournit plus de 35 opérateurs, couvrant l'arithmétique de base, la manipulation de bits, indirect, des comparaisons, des opérations logiques et d'autres. Presque tous les opérateurs peuvent être surchargés pour les types définis par l'utilisateur, avec quelques exceptions notables telles que l'accès des membres (. Et. *) Ainsi que l'opérateur conditionnel. La riche ensemble d'opérateurs surchargés est au centre de l'utilisation de types créés par l'utilisateur en C + + aussi bien et aussi facilement que les types intégrés (de sorte que l'utilisateur à l'aide ne peut pas faire la différence). Les opérateurs surchargés sont également un élément essentiel de nombreux C + + les techniques de programmation avancées, telles que des pointeurs intelligents. Surcharger un opérateur ne modifie pas la priorité des calculs impliquant l'opérateur, ni ne change le nombre d'opérandes que l'opérateur utilise (l'un des opérandes peut cependant être ignoré par l'opérateur, mais il sera évalué avant l'exécution). Surchargées "&&" et "| |" opérateurs perdent leur propriété d'évaluation de court-circuit.
la gestion de la mémoire

C + + prend en charge quatre types de gestion de la mémoire:

    Allocation de mémoire statique. Une variable statique est attribuée une valeur au moment de la compilation, et attribué le stockage dans un lieu fixe avec le code exécutable. Ceux-ci sont déclarées avec le mot-clé "statique" (dans le sens de stockage statique, pas dans le sens de déclarer une variable de classe).
    Allocation automatique de la mémoire. Une variable automatique est simplement déclarée avec son nom de classe, et le stockage est allouée sur la pile lorsque la valeur est affectée. Le constructeur est appelé quand la déclaration est exécutée, le destructeur est appelé lorsque la variable est hors de portée, et après le destructeur de la mémoire allouée est automatiquement libéré.
    L'allocation dynamique de la mémoire. Le stockage peut être allouée de façon dynamique sur le tas en utilisant la gestion manuelle de la mémoire - les appels normalement à new et delete (bien que l'ancienne C appelle comme malloc () et free () sont toujours pris en charge).
    Avec l'utilisation d'une bibliothèque, la collecte des ordures est possible. Le garbage collector Boehm est couramment utilisé à cette fin.

Le contrôle précis de la gestion de la mémoire est semblable à C, mais contrairement aux langues qui ont l'intention de cacher des détails de la programmation, comme Java, Perl, PHP et Ruby.
Modèles
Voir aussi: métaprogrammation de modèle et de programmation générique

Templates C + + permet la programmation générique. C + + prend en charge les modèles de fonction et de classe. Les modèles peuvent être paramétrés par des types, des constantes de compilation, et d'autres modèles. C + + modèles sont mis en œuvre par l'instanciation au moment de la compilation. Pour instancier un gabarit, les compilateurs substituer arguments spécifiques pour les paramètres d'un modèle pour générer une fonction en béton ou en instance de classe. Certaines substitutions ne sont pas possibles, ceux-ci sont éliminés par une politique de résolution de surcharge décrite par l'expression «échec de substitution n'est pas une erreur" (SFINAE). Les modèles sont un outil puissant qui peut être utilisé pour la programmation générique, métaprogrammation de modèle, et l'optimisation de code, mais ce pouvoir implique un coût. utilisation de modèles peut augmenter la taille du code, parce que chaque instanciation de modèle produit une copie du code du modèle: un pour chaque ensemble d'arguments de modèle, cependant, c'est la même quantité de code qui serait généré, ou moins, que si le code a été écrit à la main [30]. Ceci est en contraste aux médicaments génériques Run-time vu dans d'autres langues (par exemple, Java) où au moment de la compilation du type est effacé et un corps de modèle unique est préservé.

Les modèles sont différents des macros: alors que ces deux caractéristiques linguistiques compilation de permettre la compilation conditionnelle, les modèles ne sont pas limités à la substitution lexicale. Les modèles sont conscients de la sémantique et le système de type de la langue de leur compagnon, ainsi que toutes les définitions de type compilation, et peuvent effectuer des opérations de haut niveau, y compris le contrôle de flux programmatique fondée sur une évaluation des paramètres strictement typé. Les macros sont capables de contrôle conditionnel sur la compilation en fonction de critères prédéterminés, mais ne peut pas instancier de nouveaux types, reproduit, ou effectuer une évaluation de type et en effet sont limités à pré-compilation texte de substitution et text-inclusion/exclusion. En d'autres termes, les macros peuvent contrôler le flux de compilation basé sur des symboles prédéfinis, mais ne peuvent pas, à la différence des modèles, indépendamment instancier de nouveaux symboles. Les modèles sont un outil pour le polymorphisme statique (voir ci-dessous) et la programmation générique.

En outre, les modèles sont un mécanisme de compilation en C + + qui est Turing-complet, ce qui signifie que tout calcul exprimable par un programme d'ordinateur peut être calculé, sous quelque forme, par un modèle métaprogramme avant l'exécution.

En résumé, un modèle est une fonction paramétrée lors de la compilation ou de la classe écrit sans la connaissance des arguments spécifiques utilisés pour instancier. Après l'instanciation, le code résultant est équivalent au code écrit spécifiquement pour les arguments passés. De cette manière, les modèles offrent un moyen de dissocier les aspects génériques, largement applicables de fonctions et de classes (codées dans les modèles) à certains aspects spécifiques (codées dans les paramètres du template) sans sacrifier les performances grâce à l'abstraction.
Objets
Article détaillé: classes C + +

C + + introduit programmation fonctionnalités orientées objet (OOP) pour C. Il propose des cours, qui fournissent les quatre fonctions les plus couramment présents dans la POO (et certains non-POO) langues: abstraction, encapsulation, héritage et le polymorphisme. Une caractéristique distinctive de classes C + + par rapport à des classes dans d'autres langages de programmation est le soutien aux destructeurs déterministes, qui à son tour fournir un soutien pour l'acquisition des ressources est Initialisation Concept (RAII).
Encapsulation

L'encapsulation est la dissimulation de l'information pour s'assurer que les structures de données et les opérateurs sont utilisés comme prévu et à rendre le modèle d'utilisation plus évident pour le développeur. C + + offre la possibilité de définir des classes et des fonctions que ses mécanismes d'encapsulation primaires. Dans une classe, les membres peuvent être déclarés comme étant encapsulation publique, protégée ou privée à appliquer de manière explicite. Un membre du public de la classe est accessible à n'importe quelle fonction. Un membre privé est accessible uniquement aux fonctions qui sont les membres de cette classe et à des fonctions et des classes explicitement une autorisation d'accès par la classe ("amis"). Un membre protégé est accessible aux membres de classes qui héritent de la classe en plus de la classe elle-même et d'amis.

Le principe OO, c'est que toutes les fonctions (et seulement les fonctions) qui accèdent à la représentation interne d'un type doit être encapsulé dans la définition du type. C + + prend en charge cette (via les fonctions membres et des fonctions d'amis), mais ne l'applique pas: le programmeur peut déclarer tout ou partie de la représentation d'un type à être public, et est autorisé à faire des entités publiques qui ne font pas partie de la représentation de le type. Par conséquent, C + + supporte pas la programmation OO juste, mais d'autres paradigmes de décomposition plus faibles, comme la programmation modulaire.

Il est généralement considéré comme une bonne pratique de faire toutes les données privé ou protégé, et de rendre publiques que les fonctions qui font partie d'une interface minimale pour les utilisateurs de la classe. Cela peut cacher les détails de la mise en œuvre des données, permettant au concepteur de suite changer fondamentalement la mise en œuvre sans modifier l'interface en aucune façon. [31] [32]
Héritage

L'héritage permet à un type de données pour acquérir des propriétés d'autres types de données. Héritage d'une classe de base peut être déclarée publique, protégée ou privée. Ce spécificateur d'accès détermine si les classes indépendantes et dérivée peut accéder aux membres publics et protégés hérités de la classe de base. Seulement patrimoine public correspond à ce que l'on entend habituellement par «héritage». Les deux autres formes sont beaucoup moins fréquemment utilisés. Si le spécificateur d'accès est omis, une «classe» hérite privé, tandis qu'un "struct" hérite publiquement. Les classes de base peuvent être déclarés en tant que virtuel, c'est ce qu'on appelle l'héritage virtuel. L'héritage virtuel garantit qu'une seule instance d'une classe de base existe dans le graphe d'héritage, d'éviter certains des problèmes d'ambiguïté de l'héritage multiple.

L'héritage multiple est un C + + ne retrouve dans la plupart des autres langues, ce qui permet une classe à tirer de plus d'une des classes de base, ce qui permet de relations d'héritage plus élaborés. Par exemple, une classe "Flying Cat" peut hériter de deux "Chat" et "Flying mammifères". D'autres langues, telles que C # ou Java, d'accomplir quelque chose de similaire (bien plus limitée) en permettant l'héritage de plusieurs interfaces tout en limitant le nombre de classes de base à une (interfaces, à la différence des classes, ne fournissent que des déclarations de fonctions membres, sans la mise en œuvre ou d'un membre données). Une interface en C # et Java peut être définie en C + + comme une classe ne contenant que des fonctions virtuelles pures, souvent connus sous le nom d'une classe de base abstraite ou "ABC". Les fonctions de membres de cette classe de base abstraite sont normalement définies explicitement dans la classe dérivée, pas hérité implicitement. C + + héritage virtuel présente une fonction de résolution d'ambiguïté appelé dominance.
Polymorphisme
Voir aussi: Polymorphisme de la programmation orientée objet

Polymorphisme permet une interface commune pour de nombreuses implémentations, et pour les objets d'agir différemment dans des circonstances différentes.

C + + prend en charge plusieurs types de statiques (compilation) et dynamique polymorphismes (run-time). Compilation polymorphisme ne permet pas certaines décisions d'exécution, tout en run-time polymorphisme encourt habituellement une pénalité de performance.
Polymorphisme statique

La surcharge de fonction permet aux programmes de déclarer plusieurs fonctions ayant le même nom (mais avec des arguments différents). Les fonctions se distinguent par le nombre ou le type de leurs paramètres formels. Ainsi, le même nom de fonction peut faire référence à des fonctions différentes selon le contexte dans lequel il est utilisé. Le type retourné par la fonction n'est pas utilisée pour distinguer les fonctions surchargées et se traduirait par un message d'erreur lors de la compilation.

Lors de la déclaration d'une fonction, un programmeur peut spécifier un ou plusieurs paramètres d'une valeur par défaut. Cela permet aux paramètres par défaut avec éventuellement être supprimées lorsque la fonction est appelée, dans ce cas, les arguments par défaut seront utilisés. Quand une fonction est appelée avec moins d'arguments que là sont déclarés paramètres, arguments explicites sont adaptés aux paramètres dans l'ordre de gauche à droite, avec tous les paramètres inégalés à la fin de la liste des paramètres étant cédé leurs arguments par défaut. Dans de nombreux cas, en précisant les arguments par défaut dans une seule déclaration de fonction est préférable de fournir des définitions de fonctions surchargées avec des nombres différents de paramètres.

Modèles en C + + fournira un mécanisme sophistiqué pour l'écriture générique, le code polymorphe. En particulier, à travers le motif récurrent de modèle Curieusement, il est possible de mettre en œuvre une forme de polymorphisme statique qui imite de près la syntaxe pour des raisons impérieuses de fonctions virtuelles. Parce templates C + + sont de type courant et Turing-complet, ils peuvent également être utilisés pour laisser le compilateur résout conditionnelles récursives et de générer d'importants programmes à travers métaprogrammation de modèle. Contrairement à certains avis, le code de modèle ne sera pas générer un code en vrac après compilation avec les paramètres du compilateur appropriées. [30]
Polymorphisme dynamique
Héritage

Pointeurs de variables (et références) à un type de classe de base en C + + peut se référer à des objets de toutes les classes dérivées de ce type en plus d'objets correspondant exactement le type de variable. Cela permet de tableaux et d'autres types de contenants pour des pointeurs vers des objets de types différents. Parce que l'affectation de valeurs aux variables survient généralement au moment de l'exécution, ce qui est nécessairement un phénomène run-time.

C + + fournit également un opérateur dynamic_cast, ce qui permet au programme de tenter en toute sécurité conversion d'un objet en un objet d'un type d'objet plus spécifique (par opposition à la conversion d'un type plus général, qui est toujours autorisé). Cette fonctionnalité s'appuie sur des informations de type à l'exécution (RTTI). Objets connus pour être d'un certain type spécifique peuvent également être émis à ce type avec static_cast, une construction purement compilation qui n'a pas de frais généraux d'exécution et ne nécessite pas de RTTI.
Fonctions de membre virtuel

Normalement, quand une fonction dans une classe dérivée remplace une fonction dans une classe de base, la fonction à appeler est déterminé par le type de l'objet. Une fonction donnée est remplacée quand il n'existe pas de différence dans le nombre ou le type de paramètres entre deux ou plusieurs définitions de cette fonction. Ainsi, au moment de la compilation, il peut être impossible de déterminer le type de l'objet et donc le fonctionnement correct d'appeler, étant donné que d'un pointeur de classe de base, la décision est donc reportée jusqu'à l'exécution. C'est ce qu'on appelle la liaison dynamique. Fonctions membres virtuelles ou des méthodes [33] permettent la mise en oeuvre plus particulière de la fonction qui est appelée, selon le type réel d'exécution de l'objet. En C + + implémentations, cela se fait couramment en utilisant des tables de fonctions virtuelles. Si le type d'objet est connu, cela peut être contourné en faisant précéder un nom de classe entièrement qualifié avant l'appel de fonction, mais dans des appels généraux aux fonctions virtuelles sont résolues au moment de l'exécution.

En plus des fonctions de membre standard, les surcharges d'opérateur et destructeurs peuvent être virtuel. Une règle générale est que si toutes les fonctions de la classe sont virtuels, le destructeur doit être aussi bien. Comme le type d'un objet lors de sa création est connue au moment de la compilation, les constructeurs, et par un constructeur de copie d'extension, ne peut pas être virtuel. Néanmoins, une situation peut survenir si une copie d'un objet doit être créé quand un pointeur vers un objet dérivé est passé comme un pointeur vers un objet de base. Dans un tel cas, une solution commune est de créer un clone () (ou similaire) fonction virtuelle qui crée et renvoie une copie de la classe dérivée lorsqu'il est appelé.

Une fonction membre peut également être faite "virtuelle pure" en l'ajoutant avec = 0 après la parenthèse fermante et avant le point-virgule. Une classe contenant une fonction virtuelle pure est appelé un type de données abstrait. Les objets ne peuvent être créés à partir des types de données abstraits, ils ne peuvent être obtenues à partir. Toute classe dérivée hérite de la fonction virtuelle pure et doit donner une définition non-pure de celui-ci (et toutes les autres fonctions virtuelles pures) avant les objets de la classe dérivée peuvent être créés. Un programme qui tente de créer un objet d'une classe avec une fonction membre virtuelle pure ou hérité fonction membre virtuelle pure est mal formé.
L'analyse et la transformation C + + de code source

Il est relativement difficile d'écrire un bon analyseur C + + avec des algorithmes d'analyse classiques tels que LALR (1). [34] Ceci est en partie le résultat de la grammaire C + + ne pas être LALR. Pour cette raison, il ya très peu d'outils pour l'analyse ou effectuer des transformations non négligeables (par exemple, le refactoring) de code existant. Une façon de gérer cette difficulté est de choisir une syntaxe différente. Analyseurs plus puissants, tels que des analyseurs de la RGL, peuvent être beaucoup plus simple (mais plus lent).

Parsing (dans le sens littéral de produire un arbre de syntaxe) n'est pas le problème le plus difficile à construire un outil C + + de traitement. Ces outils doivent également avoir la même compréhension de la signification des identifiants dans le programme comme un compilateur pourrait avoir. Systèmes pratiques pour le traitement C + + doit alors non seulement analyser le texte source, mais être capable de résoudre pour chaque identifiant précisément la définition qui s'applique (par exemple, ils doivent gérer correctement C règles de portée + de + complexes) et quel est son type est, ainsi que les types de expressions plus grandes.

Enfin, une pratique C + + outil de traitement doit être capable de gérer la variété de C + + dialectes utilisés dans la pratique (comme celle prise en charge par la collection de compilateur GNU et celle de de Microsoft Visual C + +) et mettre en œuvre des analyseurs appropriés, source de transformateurs de code, et de régénérer texte source . Combinant des algorithmes d'analyse avancées, telles que GLR avec la construction de la table des symboles et des machines de transformation du programme peut permettre la construction d'arbitraires C + + outils.

Parseurs existent dans tous les grands compilateurs. Malgré que seul un compilateur fournit l'analyseur dans un format adapté à l'intégration de l'outil, Clang [35], l'analyseur peut être utilisé comme C + + (ou C) bibliothèque qui est prêt pour l'intégration dans, soit un IDE.
Compatibilité

Produire un raisonnablement conformes aux normes compilateur C + + s'est avéré être une tâche difficile pour les éditeurs de compilateur en général. Depuis de nombreuses années, différents compilateurs C + + en œuvre le langage C + + à différents niveaux de conformité à la norme, et leur mise en œuvre variait grandement dans certains domaines tels que la spécialisation de modèle partiel. Dernières parutions de la plus populaire compilateurs C + + supporte la quasi-totalité de la norme C + + 1998. [36]

Pour donner aux vendeurs de compilateur plus de liberté, le C + + comité de normalisation a décidé de ne pas imposer la mise en œuvre de la décoration de nom, la gestion des exceptions, et d'autres caractéristiques spécifiques à l'implémentation. L'inconvénient de cette décision est que le code de l'objet produit par différents compilateurs devrait être incompatibles. Il y avait, cependant, les tentatives pour normaliser les compilateurs pour certaines machines ou des systèmes d'exploitation (par exemple C + + ABI) [37], mais ils semblent être largement abandonnée aujourd'hui.
Modèles exportés

Un point de discorde particulier est le mot-clé à l'exportation, destinée à permettre définitions de modèle à être séparés de leurs déclarations. Le premier compilateur largement disponibles pour mettre en œuvre l'exportation était Comeau C / C + +, au début de 2003 (cinq ans après la publication de la norme), en 2004, le compilateur bêta de Borland C + + Builder X a également été publié à l'exportation. Ces deux compilateurs sont basées sur le C + + extrémité avant EDG. D'autres compilateurs comme GCC ne supportent pas du tout. Prend ANSI C + + par Ivor Horton fournit un exemple de code avec le mot-clé qui ne compilera pas dans la plupart des compilateurs, sans référence à ce problème. Herb Sutter, ancien animateur du + comité C + normes, a recommandé que l'exportation soit retiré de futures versions de la norme C + +. [38] Lors de l'ISO réunion C + + sur les normes Mars 2010, le + comité C + normes ont voté pour retirer les modèles exportés entièrement à partir de C + + 11, mais se réservent le mot-clé pour une utilisation future. [39]
Avec C

C + + est souvent considéré comme un sur-ensemble du C, mais ce n'est pas tout à fait vrai. [40] La plupart du code C peut facilement être faite pour compiler correctement en C + +, mais il ya quelques différences qui causent peu de code C valide à invalide ou se comporter différemment en C + +.

Une différence communément rencontrée est que C permet la conversion implicite de void * à d'autres types de pointeurs, mais C + + ne fonctionne pas (pour des raisons de sécurité de type). Un autre problème de portabilité commune est que C + + définit de nombreux nouveaux mots-clés, tels que de nouvelles et de la classe, qui peuvent être utilisés comme identifiants (par exemple, les noms de variables) dans un programme C.

Certaines incompatibilités ont été enlevés par la révision de la norme C (C99), qui prend désormais en C + + des fonctionnalités telles que des lignes de commentaires (/ /), et les mélanges de déclarations avec le code 1999. D'autre part, C99 introduit un certain nombre de nouvelles fonctionnalités que C + + n'a pas de soutien, étaient incompatibles ou redondants en C + + (par exemple, complexe, utilisez la classe complexe dans la bibliothèque standard à la place), tels que tableaux de longueur variable, natif nombres complexes types, initialisateurs désignés, les mots composés, le booléen typedef (en C + +, il est un type fondamental) et le mot-clé restreindre. [41] Certaines des caractéristiques C99-introduits ont été inclus dans la version ultérieure de la norme C + +, C + +11 : [42] [43] [44]

    C99 préprocesseur (y compris les macros variadiques, large / étroit concaténation littérale, plus l'arithmétique entière)
    _Pragma ()
    long long
    __func__
    Têtes:
        cstdbool (stdbool.h)
        cstdint (stdint.h)
        cinttypes (inttypes.h).

Pour mélanger C et C + + code, toute déclaration de fonction ou la définition qui doit être appelé à partir de / utilisé à la fois en C et C + + doit être déclarée avec C lien en le plaçant dans un extern "C" {/ * ... * /} bloc . Une telle fonction peut pas compter sur les caractéristiques en fonction de la décoration de nom (par exemple, la surcharge de fonction).
Critique
C + + est parfois comparé défavorablement avec plus strictement orienté objet langues sur la base du fait qu'il permet aux programmeurs de "mix and match" styles de programmation déclarative, fonctionnel, générique, modulaire et procédural avec la programmation orientée objet, plutôt que d'appliquer strictement un style unique , bien que C + + est un langage volontairement multi-paradigme.
Published By Drupal french Study