RAD Studio - Modifications récentes [fr]

Audit de code intelligent

Yukikoi — Wed, 09 Sep 2026 05:01:37 GMT

Compagnon RAD AI

← Version précédente		Version du 9 septembre 2026 à 05:01
Ligne 60 :		Ligne 60 :


			<!--
	==Compagnon RAD AI==		==Compagnon RAD AI==

	RAD Studio introduit « RAD AI Companion », un chat et générateur de code web spécifiquement entraîné sur du contenu en lien avec RAD Studio. Le compagnon RAD AI s'active depuis l'EDI en sélectionnant {{Menu\| Menu Aide > [http://www.embarcadero.com/radaicompanion RAD AI Companion]}}.		RAD Studio introduit « RAD AI Companion », un chat et générateur de code web spécifiquement entraîné sur du contenu en lien avec RAD Studio. Le compagnon RAD AI s'active depuis l'EDI en sélectionnant {{Menu\| Menu Aide > [http://www.embarcadero.com/radaicompanion RAD AI Companion]}}.
			-->

	==Fenêtre de chat IA==		==Fenêtre de chat IA==
Ligne 100 :		Ligne 101 :
	* [[Configuring Ollama for Smart CodeInsight\|Configuration d'Ollama]]		* [[Configuring Ollama for Smart CodeInsight\|Configuration d'Ollama]]
	* [[Create and implement your AI plugin\|Créer et implémenter votre plugin IA]]		* [[Create and implement your AI plugin\|Créer et implémenter votre plugin IA]]

Fichier:Ai smartchat.png

Yukikoi — Wed, 09 Sep 2026 05:01:00 GMT

Yukikoi a téléversé Fichier:Ai smartchat.png

Nouvelle page

Fichier:Smart CodeInsight-Display.png

Yukikoi — Wed, 09 Sep 2026 05:00:49 GMT

Yukikoi a téléversé Fichier:Smart CodeInsight-Display.png

Nouvelle page

Fichier:Ai chat window.png

Yukikoi — Wed, 09 Sep 2026 05:00:36 GMT

Yukikoi a téléversé Fichier:Ai chat window.png

Nouvelle page

Audit de code intelligent

Yukikoi — Wed, 09 Sep 2026 05:00:28 GMT

Yukikoi a importé Audit de code intelligent par téléversement de fichier (1 version) LOC-23469

Nouvelle page

[[Audit de code intelligent|Audit de code intelligent]] est une architecture ouverte qui vous permet d'utiliser vos moteurs d'IA préférés. En plus des fonctionnalités déjà présentes, {{Product}} vous propose également une intégration de l'interface utilisateur personnalisable :

* Moteur d'IA de base et ToolsAPI.
* Intégration de l'EDI :
** [[#Options de configuration|Options de configuration pour les moteurs]].
** [[#Commandes du menu Editeur|Commandes de menu de l'éditeur permettant d'invoquer des opérations IA]].
** [[#Fenêtre de chat IA|Fenêtre de chat IA]].
* Prise en charge des fournisseurs LLM en ligne et hors ligne tels que :
** OpenAI, Gemini et Claude (en ligne).
** Ollama (hors ligne).

:
::{{Tip|Ollama est distribué en tant que produit open source sous licence MIT. Les modèles individuels que vous êtes susceptible d'utiliser avec Ollama ont leurs propres licences. La politique d'utilisation "Codellama Acceptable Use Policy" est disponible sur cette page.}}
::{{Note|Pour les adeptes de ToolsAPI, {{Product}} vous permet de créer votre propre plugin API. Pour plus d'informations, consultez la page [[Create and implement your AI plugin|Créer et implémenter votre plugin IA]].}}

{{Warning|{{Product}} ne fournit pas d'accès à ces moteurs. L'utilisation de ces services d'IA nécessite que l'utilisateur accepte les conditions d'utilisation de chaque éditeur, reçoive une clé API permettant de modifier la configuration de {{Product}}, et paie les frais de redevance de la société d'IA concernée.
La seule exception concerne Ollama qui peut être utilisé hors ligne gratuitement et être installé en local ou sur un serveur de votre choix.}}

==Options de configuration==

{{Product}} vous permet de configurer et de contrôler pleinement vos informations personnelles de différentes façons. Vous pouvez ainsi :

* Désactiver la fonctionnalité IA complète à partir d'un paramètre unique.
* Activer ou désactiver chacun des quatre moteurs.
* Sélectionner le moteur par défaut de chacun des éléments d'interface utilisateur (fenêtre de chat et menu éditeur).

Toutes ces fonctionnalités peuvent être configurées dans la fenêtre Options de l'EDI. Consultez la page [[Options relatives à l'audit de code intelligent|Configuration de l'audit de code intelligent]] pour plus d'informations sur chaque rubrique.

* Les actions suivantes ont aussi été implémentées pour sécuriser le système.
* Les clés API sont stockées dans un format chiffré.
* Vous avez la possibilité d'utiliser un moteur local, hors ligne.

==Commandes du menu Editeur==

Le menu Editeur propose des opérations préconfigurées pour le code sélectionné dans l'éditeur. Le but est d'analyser et d'optimiser une partie du code source de votre application.

Le moteur LLM réagit en renvoyant le résultat dans une fenêtre de l'éditeur sous forme de commentaire après le code analysé.

===Commandes disponibles :===

Voici les commandes disponibles pour l'audit de code intelligent :

[[Image:Smart CodeInsight-Display.png|450x450px|link=]]

* '''Chat IA''' : ouvre la vue [[#Fenêtre de chat IA|Fenêtre de chat IA]].
* '''Trouver des bogues''' : recherche des bogues potentiels dans le code sélectionné.
* '''Expliquer le code''' : explique le code sélectionné.
* '''Ajouter un commentaire''' : ajoute des commentaires au code sélectionné.
* '''Achever le code''' : termine le code sélectionné.
* '''Optimiser le code''' : optimise le code sélectionné.
* '''Ajouter un test unitaire''' : ajoute un test unitaire au code sélectionné.
* '''Convertir en assembleur''' : convertit le code sélectionné en code assembleur.
* '''Convertir en Delphi''' : convertit le code sélectionné en code Delphi (à partir du code C++ ou assembleur).
* '''Convertir en C++Builder''' : convertit le code sélectionné en code C++Builder.
* '''Trouver l'en-tête (IA)''' (dans C++) ou '''Rechercher une unité''' (dans Delphi) : ajoute l'unité manquante aux instructions uses d'une classe sélectionnée ou d'un type de données.
* '''Afficher les résultats dans l'éditeur :''' envoie la sortie dans l'éditeur.
* '''Afficher les résultats dans la fenêtre de''' '''chat''' : envoie la sortie dans la fenêtre de chat IA au format Markdown.

==Compagnon RAD AI==

RAD Studio introduit « RAD AI Companion », un chat et générateur de code web spécifiquement entraîné sur du contenu en lien avec RAD Studio. Le compagnon RAD AI s'active depuis l'EDI en sélectionnant {{Menu| Menu Aide > [http://www.embarcadero.com/radaicompanion RAD AI Companion]}}.

==Fenêtre de chat IA==

La fenêtre de chat IA est une fiche ancrable de l'EDI, qui fonctionne comme n'importe quelle fenêtre de chat LLM. Vous pouvez taper une requête, choisir un moteur (ou utiliser le moteur par défaut) et attendre la réponse. Voici un rapide exemple :

[[Image:ai chat window.png|350px|link=]]

La fenêtre de chat comporte une zone de saisie qui fonctionne comme une ligne de commande. Voici les commandes disponibles :

* <code>chatgpt> + Entrée</code> : active ChatGpt comme moteur d'IA actif (si celui-ci a été activé).
* <code>gemini> + Entrée</code> : active Gemini comme moteur d'IA actif (si celui-ci a été activé).
* <code>claude> + Entrée</code> : active Claude comme moteur d'IA actif (si celui-ci a été activé).
* <code>ollama> + Entrée</code> : active Ollama comme moteur d'IA actif (si celui-ci a été activé).
* <code>clear> + Entrée</code> : efface la zone de réponse.
* <code>stop> + Entrée</code> : arrête la génération de la réponse (équivalent à un clic sur le bouton Stop).
* <code>Ctrl + Entrée</code> : commence à générer la réponse (équivalent à un clic sur le bouton Start).

En plus des requêtes standard, vous pouvez sélectionner un extrait de code spécifique dans la fenêtre de code et poser une '''nouvelle question''' ou '''demander une explication''' en utilisant l'une des commandes suivantes :

[[Image:ai smartchat.png|450px|link=]]

* $COL : est remplacé par le '''numéro de colonne''' sur lequel le curseur est placé dans la fenêtre éditeur de code active.
* $ROW : est remplacé par le '''numéro de ligne''' sur lequel le curseur est placé dans la fenêtre éditeur de code active.
* $CURTOKEN : est remplacé par le '''mot''' sur lequel le curseur est placé dans la fenêtre éditeur de code active. Cette commande peut être utile pour faire référence à une variable, une méthode ou un identificateur situé à l'emplacement du curseur.
* $EDNAME : est remplacé par le '''nom de fichier complet''' de la fenêtre éditeur de code active. Cette commande peut être très utile si vous avez besoin du nom du fichier en cours avec son chemin d'accès.
* $SELECTION : explique le code sélectionné dans l'éditeur actif.
* $UNIT : explique le code de l'unité complète.

Consultez la page [[Macros de transfert|Macros de transfert]] pour plus d'informations et d'exemples.

===Voir aussi===

* [[Options relatives à l'audit de code intelligent|Options relatives à l'audit de code intelligent]]
* [[Configuring Ollama for Smart CodeInsight|Configuration d'Ollama]]
* [[Create and implement your AI plugin|Créer et implémenter votre plugin IA]]

Audit de code intelligent

Yukikoi — Wed, 09 Sep 2026 04:47:29 GMT

Yukikoi a importé Audit de code intelligent par téléversement de fichier (1 version) LOC-23469

Nouvelle page

Eléments syntaxiques fondamentaux (Delphi)

Yukikoi — Tue, 08 Sep 2026 13:59:54 GMT

Yukikoi a importé Eléments syntaxiques fondamentaux (Delphi) par téléversement de fichier (1 version) LOC-23469

Nouvelle page

__TOC__

{{Parent|Eléments syntaxiques fondamentaux - Index}}

Les éléments syntaxiques fondamentaux, appelés ''tokens'', se combinent pour former des expressions, des déclarations et des instructions.
Une ''instruction'' décrit une action algorithmique qui peut être exécutée dans un programme. Une ''expression'' est une unité syntaxique située dans une instruction et qui désigne une valeur. Une ''déclaration'' définit un identificateur (par exemple le nom d’une fonction ou d’une variable) qui peut être employé dans des expressions ou des instructions et, si c’est nécessaire, alloue de la mémoire à l’identificateur.

Cette rubrique présente le jeu de caractères du langage {{Delphi}} et décrit la syntaxe de déclaration :

*Identificateurs
*Nombres
*Chaînes de caractères
*Libellés
*Commentaires du code source

==Le jeu de caractères {{Delphi}}==

Le langage {{Delphi}} utilise l’encodage de caractères Unicode pour son jeu de caractères, qui comprend les caractères Unicode alphabétiques et alphanumériques ainsi que le caractère de soulignement. {{Delphi}} ne tient pas compte de la casse. Le caractère espace et les caractères de contrôle ({{code|U+0000}} à {{code|U+001F}}, y compris {{code|U+000D}}, le caractère de retour ou de fin de ligne) sont des blancs.

Le compilateur {{Product}} accepte un fichier codé en {{code|UCS-2}} ou {{code|UCS-4}} si le fichier contient une marque d’ordre des octets. L’utilisation de formats autres que UTF-8 peut ralentir la compilation ; toutefois, l’utilisation d’UTF-8 est recommandée. Tous les caractères d’un fichier source codé en {{code|UCS-4}} doivent pouvoir être représentés en {{code|UCS-2}} sans paires de substitution. Les codages {{code|UCS-2}} avec paires de substitution (y compris GB18030) ne sont acceptés que si l’option de compilation codepage est spécifiée.

==Tokens==

Au niveau le plus élémentaire, un programme est une suite de tokens délimités par des séparateurs. Un token est la plus petite unité de texte significative d’un programme. Un séparateur est soit un blanc, soit un commentaire. Strictement parlant, il n’est pas toujours nécessaire de placer un séparateur entre deux tokens ; par exemple le fragment de code suivant :

<source lang="delphi">
Size:=20;Price:=10;
</source>

Est parfaitement correct. Néanmoins, pour respecter la pratique courante et les exigences de lisibilité, il est préférable de l’écrire sur deux lignes, de la manière suivante :

<source lang="delphi">
Size := 20;
Price := 10;
</source>

Les tokens sont divisés en symboles spéciaux, identificateurs, mots réservés, directives, nombres, libellés et chaînes de caractères. La chaîne de caractères est le seul token qui peut contenir des séparateurs. Il doit obligatoirement y avoir un séparateur entre des identificateurs, mots réservés, nombres et libellés adjacents.

===Symboles spéciaux===

Les symboles spéciaux sont des caractères, ou des paires de caractères, non alphanumériques ayant un sens déterminé. Les caractères individuels suivants sont des symboles spéciaux :

<code style="color:#004a80;"># $ & ' ( ) * + , - . / : ; < = > @ [ ] ^ { }</code>

Les paires de caractères suivantes sont également des symboles spéciaux :

<code style="color:#004a80;">(* (. *) .) .. // := <= >= <></code>

Le tableau suivant présente les paires de symboles utilisées dans {{Delphi}} et ayant des significations similaires (les paires de symboles {{code|{}}} et {{code|(* *)}} sont des caractères de commentaire décrits plus en détail dans [[Eléments syntaxiques fondamentaux (Delphi)#Commentaires et directives de compilation|Commentaires et directives de compilation]]) :

{| frame="hsides" border="1" rules="rows" style="font-weight: bold;"
|-
! Symboles spéciaux
! Symboles spéciaux similaires
|-
|[ ]
|(. .)
|-
|{ }
|(* *)
|}

Le crochet ouvrant '''{{code|[}}''' est similaire à la paire de caractères composée d’une parenthèse ouvrante et d’un point '''{{code|(.}}'''.

Le crochet fermant '''{{code|]}}''' est similaire à la paire de caractères composée d’un point et d’une parenthèse fermante '''{{code|.)}}'''.

L’accolade ouvrante '''{{code|{}}''' est similaire à la paire de caractères composée d’une parenthèse ouvrante et d’un astérisque '''{{code|(*}}'''.

L’accolade fermante '''{{code|}}}''' est similaire à la paire de caractères composée d’un astérisque et d’une parenthèse fermante '''{{code|*)}}'''.

{{Note|<nowiki>%, ?, \, !, " (guillemets doubles), _ (trait de soulignement), | (barre verticale) et ~ (tilde) ne sont pas des caractères spéciaux.</nowiki>}}

===Identificateurs===

Les identificateurs désignent les constantes, variables, champs, types, propriétés, procédures, fonctions, programmes, unités, bibliothèques et packages. La longueur d’un identificateur peut être quelconque, mais seuls les 255 premiers caractères sont significatifs. Un identificateur doit commencer par un caractère alphabétique, un caractère Unicode ou un caractère de soulignement ('''_''') et ne peut contenir ni espace ni caractère Unicode considéré comme un espace. Les caractères alphanumériques, les caractères Unicode, les chiffres (y compris les caractères Unicode représentant des chiffres) et les caractères de soulignement sont autorisés après le premier caractère. Les mots réservés ne peuvent pas être utilisés comme identificateurs.
Comme le langage {{Delphi}} ne tient pas compte de la casse, un identificateur tel que CalculateValue peut s’écrire de l’une des façons suivantes :

CalculateValue
calculateValue
calculatevalue
CALCULATEVALUE

Comme les noms des unités correspondent aux noms des fichiers, des incohérences de casse peuvent parfois affecter la compilation. Pour plus d’informations, voir la section [[Programmes et unités (Delphi)#Références d’unité et la clause uses|Références d’unité et la clause uses]] dans [[Programmes et unités (Delphi)|Programmes et unités (Delphi)]].

====Identificateurs qualifiés====

Quand vous utilisez un identificateur qui a été déclaré à plusieurs endroits, il est parfois nécessaire de qualifier l’identificateur. La syntaxe d’un identificateur qualifié est :

''identificateur1.identificateur2''

Où ''identificateur1'' qualifie ''identificateur2''. Si, par exemple, deux unités déclarent une variable appelée CurrentValue, vous pouvez spécifier que vous voulez accéder à CurrentValue dans Unit2 en écrivant :

<source lang="delphi">
Unit2.CurrentValue
</source>

Il est possible de chaîner les qualificateurs. Par exemple :

<source lang="delphi">
Form1.Button1.Click
</source>

appelle la méthode Click de Button1 dans Form1.

Si vous ne qualifiez pas un identificateur, son interprétation est déterminée par les règles de portée décrites dans [[Déclarations et instructions (Delphi)#Blocs et portée|Blocs et portée]] dans [[Déclarations et instructions (Delphi)|Déclarations et instructions (Delphi)]].

====Identificateurs étendus====

Il se peut que vous rencontriez des identificateurs (par exemple, des types ou des méthodes d’une classe) portant le même nom qu’un mot réservé du langage {{Delphi}}. Par exemple, une classe peut avoir une méthode appelée begin. Les mots réservés de {{Delphi}}, tels que '''begin''', ne peuvent pas être utilisés comme noms d’identificateurs.

Si vous qualifiez complètement l’identificateur, il n’y a alors plus de problème. Par exemple, si vous voulez utiliser le mot réservé '''type''' de {{Delphi}} comme nom d’identificateur, vous devez utiliser son nom qualifié complet :

<source lang="delphi">
var TMyType.type
// Using a fully qualified name avoids ambiguity with Delphi language keyword.
</source>

Une solution plus concise consiste à utiliser l’opérateur esperluette ('''&''') pour résoudre les ambiguïtés entre les identificateurs et les mots réservés du langage {{Delphi}}. Le symbole '''&''' empêche qu’un mot clé soit analysé comme tel (c’est-à-dire comme un mot réservé). Si vous rencontrez une méthode ou un type portant le même nom qu’un mot clé {{Delphi}}, vous pouvez omettre la spécification de l’espace de noms si vous faites précéder le nom de l’identificateur d’une esperluette. Mais lorsque vous '''déclarez''' un identificateur portant le même nom qu’un mot clé, vous devez utiliser le symbole & :

<source lang="delphi">
type
&Type = Integer;
// Prefix with '&' is ok.
</source>

===Mots réservés===

Les mots réservés suivants ne peuvent être redéfinis ou utilisés comme des identificateurs.

'''Mots réservés {{Delphi}} :'''

{| frame="hsides" border="1" rules="rows" style="font-weight: bold;"
|-
|[[Expressions (Delphi)#Opérateurs logiques (bit-à-bit)|and]]
|[[Déclarations et instructions (Delphi)#Instructions composées|end]]
|[[Programmes et unités (Delphi)#La section interface|interface]]
|[[Types structurés (Delphi)#Enregistrements (traditionnels)|record]]
|[[Paramètres (Delphi)#Sémantique des paramètres|var]]
|-
|[[Types structurés (Delphi)#Tableaux|array]]
|[[Exceptions (Delphi)#Déclenchement et gestion des exceptions|except]]
|[[Références de classes#Opérateur is|is]]
|[[Déclarations et instructions (Delphi)#Instructions repeat|repeat]]
|[[Déclarations et instructions (Delphi)#Instructions while|while]]
|-
|[[Références de classes#Opérateur as|as]]
|[[Ecriture de bibliothèques à chargement dynamique|exports]]
|[[Déclarations et instructions (Delphi)#Instructions goto|label]]
|[[Constantes déclarées#Chaînes de ressources|resourcestring]]
|[[Déclarations et instructions (Delphi)#Instructions with|with]]
|-
|[[Syntaxe assembleur|asm]]
|[[Types structurés (Delphi)#Types fichiers (Win32)|file]]
|[[Ecriture de bibliothèques à chargement dynamique|library]]3
|[[Types structurés (Delphi)#Ensembles|set]]
|[[Expressions (Delphi)#Opérateurs logiques (bit-à-bit)|xor]]
|-
|[[Déclarations et instructions (Delphi)#Instructions composées|begin]]
|[[Programmes et unités (Delphi)#La section finalization|finalization]]
|[[Expressions (Delphi)#Opérateurs arithmétiques|mod]]
|[[Expressions (Delphi)#Opérateurs logiques (bit-à-bit)|shl]]
|
|-
|[[Déclarations et instructions (Delphi)#Instructions case|case]]
|[[Exceptions (Delphi)#Instructions try...finally|finally]]
|[[Pointeurs et types pointeur (Delphi)|nil]]
|[[Expressions (Delphi)#Opérateurs logiques (bit-à-bit)|shr]]
|
|-
|[[Classes et objets (Delphi)|class]]
|[[Déclarations et instructions (Delphi)#Instructions for|for]]
|[[Expressions (Delphi)#Opérateurs logiques (bit-à-bit)|not]]
|[[Chaîne|string]]
|
|-
|[[Constantes déclarées|const]]
|[[Procédures et fonctions (Delphi)|function]]
|[[Classes et objets (Delphi)#Types objet|object]]
|[[Déclarations et instructions (Delphi)#Instructions if|then]]
|
|-
|[[Classes et objets (Delphi)|constructor]]
|[[Déclarations et instructions (Delphi)#Instructions goto|goto]]
|of
|[[Variables (Delphi)#Variables locales de thread|threadvar]]
|
|-
|[[Classes et objets (Delphi)|destructor]]
|[[Déclarations et instructions (Delphi)#Instructions if|if]]
|[[Expressions (Delphi)#Opérateurs logiques (bit-à-bit)|or]]
|[[Déclarations et instructions (Delphi)#Instructions for|to]]
|
|-
|[[Objets automation (Win32 seulement)|dispinterface]]
|[[Programmes et unités (Delphi)#La section implementation|implementation]]
|[[Types structurés (Delphi)|packed]]
|[[Exceptions (Delphi)|try]]
|
|-
|[[Expressions (Delphi)#Opérateurs arithmétiques|div]]
|[[In|in]]
|[[Procédures et fonctions (Delphi)|procedure]]
|[[Types simples (Delphi)#Types énumérés|type]]
|
|-
|[[Déclarations et instructions (Delphi)#Instructions for|do]]
|[[Méthodes (Delphi)#Inherited|inherited]]
|[[Programmes et unités (Delphi)|program]]
|[[Programmes et unités (Delphi)|unit]]
|
|-
|[[Déclarations et instructions (Delphi)#Instructions for|downto]]
|[[Programmes et unités (Delphi)#La section initialization|initialization]]
|[[Propriétés (Delphi)|property]]
|[[Déclarations et instructions (Delphi)#Instructions repeat|until]]
|
|-
|[[Déclarations et instructions (Delphi)#Instructions if|else]]
|[[Utilisation du code assembleur inline|inline]]
|[[Exceptions (Delphi)#Déclenchement et gestion des exceptions|raise]]
|[[Programmes et unités (Delphi)#Références d’unité et la clause uses|uses]]
|
|}

{{Note|Outre les mots spécifiés dans le tableau ci-dessus, '''private''', '''protected''', '''public''', '''published''' et '''automated''' se comportent comme des mots réservés [[Classes et objets (Delphi)#Visibilité des membres de classe|à l’intérieur de la déclaration du type de classe]] et sont traités ailleurs comme des directives. Les mots '''at''' et '''on''' ont aussi des significations spéciales, et doivent être traités comme des mots réservés. Les mots clés '''of object''' sont utilisés pour définir les [[Types procéduraux (Delphi)#Pointeurs de méthode|pointeurs de méthode]].}}

===Directives===

{{Delphi}} comporte plusieurs types de directives. Une des significations de "directive" est un mot qui est sensible à certains endroits du code source. Ce type de directive a une signification particulière en langage {{Delphi}}, mais à la différence d’un mot réservé, il apparaît seulement dans des contextes où il ne peut y avoir d’identificateurs définis par l’utilisateur. De ce fait, vous pouvez (même si cela est déconseillé) définir un identificateur identique à une directive.

'''Directives :'''

{| frame="hsides" border="1" rules="rows" style="font-weight: bold;"
|-
| [[Variables (Delphi)#Adresses absolues|absolute]]
| export12
| [[Ecriture de bibliothèques à chargement dynamique|name]]
| [[Classes et objets (Delphi)#Visibilité des membres de classe|protected]]
| [[Méthodes (Delphi)#Méthodes statiques de classe|static]]
|-
| [[Méthodes (Delphi)#Méthodes abstraites|abstract]]
| [[Procédures et fonctions (Delphi)#Déclarations externes|external]]
| near1
| [[Classes et objets (Delphi)#Visibilité des membres de classe|public]]
| [[Procédures et fonctions (Delphi)#Conventions d’appel|stdcall]]
|-
| assembler12
| far1
| [[Propriétés (Delphi)|nodefault]]
| [[Classes et objets (Delphi)#Visibilité des membres de classe|published]]
| [[Classes et objets (Delphi)#Spécificateurs de visibilité stricte|strict]]
|-
|[[Classes et objets (Delphi)#Membres automatisés (Win32 seulement)|automated]]
|[[Méthodes (Delphi)#Méthodes finales|final]]
|[[Déclarations et instructions (Delphi)#La directive noreturn|noreturn]]
|[[Propriétés (Delphi)|read]]
|[[Propriétés (Delphi)#Spécificateurs de stockage|stored]]
|-
| [[Procédures et fonctions (Delphi)#Conventions d’appel|cdecl]]
| [[Procédures et fonctions (Delphi)|forward]]
| [[Surcharge d'opérateurs (Delphi)|operator]]10
| [[Objets automation (Win32 seulement)#Propriétés des interfaces de répartition|readonly]]
| unsafe
|-
| [[Packages#La clause contains|contains]]7
| [[Assistances de classes et d'enregistrements (Delphi)|helper]]8
| [[Paramètres (Delphi)#Paramètres de sortie|out]]
| [[Méthodes anonymes dans Delphi|reference]]9

| [[Procédures et fonctions (Delphi)#Déclarations externes|varargs]]
|-
| [[Propriétés (Delphi)|default]]
| [[Utilisation de implements pour la délégation|implements]]
| [[Méthodes (Delphi)#Surcharge des méthodes|overload]]
| [[Procédures et fonctions (Delphi)#Conventions d’appel|register]]
| [[Méthodes (Delphi)#Méthodes virtuelles et dynamiques|virtual]]
|-
| [[Bibliothèques et packages (Delphi)#Chargement différé (Windows seulement)|delayed]]
| [[Propriétés (Delphi)#Spécificateurs d’indice|index]]
| [[Redéfinition des méthodes|override]]
| [[Méthodes (Delphi)#Reintroduce|reintroduce]]
| [[Procédures et fonctions (Delphi)#Conventions d’appel|winapi]]6

|-
| [[Déclarations et instructions (Delphi)#Directives de conseil|deprecated]]11
| [[Utilisation du code assembleur inline|inline]]2
| [[Packages|package]]7
| [[Packages#La clause requires|requires]]7
| [[Propriétés (Delphi)|write]]
|-
| [[Objets automation (Win32 seulement)|dispid]]
|[[Ecriture de bibliothèques à chargement dynamique|library]]311



| [[Procédures et fonctions (Delphi)#Conventions d’appel|pascal]]
| resident1

| [[Objets automation (Win32 seulement)#Propriétés des interfaces de répartition|writeonly]]
|-
| [[Méthodes dynamiques|dynamic]]
| local4



| [[Déclarations et instructions (Delphi)#Directives de conseil|platform]]11
| [[Procédures et fonctions (Delphi)#Conventions d’appel|safecall]]
|
|-
| [[Déclarations et instructions (Delphi)#Directives de conseil|experimental]]11
| [[Méthodes (Delphi)#Méthodes de messages|message]]
| [[Classes et objets (Delphi)#Visibilité des membres de classe|private]]
| [[Classes et objets (Delphi)#Types classe|sealed]]5

|
|}

{{Note|

# '''far''', '''near''' et '''resident''' sont obsolètes.
# '''[[Utilisation du code assembleur inline|inline]]''' est utilisé comme style de directive à la fin de la déclaration de la procédure ou de la fonction pour marquer la procédure ou la fonction "inline", {{f|radstudio|, mais était un mot réservé pour Turbo Pascal}}.
# '''[[Ecriture de bibliothèques à chargement dynamique|library]]''' est aussi un mot clé quand il est utilisé en tant que premier token du code source du projet ; il indique une cible DLL. Sinon, il marque un symbole, de telle sorte qu’il produit un avertissement de bibliothèque lors de son utilisation.
# '''local''' était une directive Kylix et est ignoré pour {{Delphi}} pour Win32.
# '''[[Classes et objets (Delphi)#Types classe|sealed]]''' est une directive de classe avec l’ancienne syntaxe : "class sealed". Une classe sealed ne peut pas être étendue ni dérivée (comme <code>final</code> dans C++).
# '''[[Procédures et fonctions (Delphi)#Conventions d’appel|winapi]]''' définit la convention d’appel de la plate-forme par défaut. Par exemple, sur Win32, '''winapi''' est identique à '''stdcall'''.
# '''[[Packages|package]]''', quand il est utilisé en tant que premier token, indique une cible package et active la syntaxe de package. '''[[Packages#La clause requires|requires]]''' et '''[[Packages#La clause contains|contains]]''' sont des directives uniquement dans la syntaxe de package.
# '''helper''' indique [[Assistances de classes et d'enregistrements (Delphi)|"assistance de classe pour"]].
# '''[[Méthodes anonymes dans Delphi|reference]]''' indique une référence à une fonction ou à une procédure.
# '''[[Surcharge d'opérateurs (Delphi)|operator]]''' indique un opérateur de classe.
# '''platform''', '''deprecated''', '''experimental''' et '''library''' sont des [[Déclarations et instructions (Delphi)#Directives de conseil|directives de conseil (ou d’avertissement)]]. Ces directives produisent des avertissements à la compilation.
# Les directives '''assembler''' et '''export''' n’ont pas de signification. Elles existent uniquement pour des questions de compatibilité avec les versions précédentes.}}

====Types de directives====

{{Delphi}} a deux types de directives, en plus du type de directive sensible au contexte décrit dans le tableau [[#Directives|Directives]] ci-dessus.

Une '''directive''' sensible au contexte peut être un identificateur -- pas typiquement un mot clé -- que vous placez à la fin d’une déclaration pour modifier la signification de la déclaration. Par exemple :

<source lang="delphi">
procedure P; forward;
</source>

Ou :

<source lang="delphi">
procedure M; virtual; override;
</source>

Ou :

<source lang="delphi">
property Foo: Integer read FFoo write FFoo default 42;
</source>

Le dernier type de directive est la '''[[Liste des directives de compilation Delphi - Index|directive de compilation]]''' officielle, un commutateur ou une option qui influe sur le comportement du compilateur. Une directive de compilation est entourée d’accolades ({}) et commence par un signe dollar ($), comme ceci :

<source lang="delphi">
{$POINTERMATH ON}

{$D+} // DEBUGINFO ON
</source>

Comme les autres types de directives, les '''directives de compilation''' ne sont pas des mots clés. Pour obtenir la liste des directives de compilation, voir la '''[[Liste des directives de compilation Delphi - Index|liste des directives de compilation {{Delphi}}]].'''

===Nombres===

Les constantes entières et réelles peuvent être représentées en notation décimale comme une séquence de chiffres sans virgule ni espaces et préfixés par les opérateurs '''+''' ou '''-''' afin d’indiquer le signe. Par défaut les valeurs sont positives (ainsi 67258 est identique à +67258) et doivent se trouver à l’intérieur de l’intervalle du plus grand type prédéfini entier ou réel.

Les nombres avec un séparateur décimal ou un exposant désignent des réels, alors que les autres nombres désignent des entiers. Quand le caractère E ou e apparaît dans un réel, cela signifie "multiplié par dix à la puissance". Par exemple, 7E2 signifie 7 * 10^2, de même 12.25e+6 et 12.25e6 signifient tous les deux 12.25 * 10^6.

Le signe dollar utilisé comme préfixe indique un nombre hexadécimal, par exemple $8F. Les nombres hexadécimaux non précédés d’un opérateur unaire '''-''' sont considérés comme des valeurs positives. Lors d’une affectation, si une valeur hexadécimale se trouve hors de l’intervalle du type destinataire, une erreur est générée, sauf pour le type '''Integer''' (entier 32 bits), cas dans lequel un avertissement est généré. Dans ce cas, les valeurs dépassant l’intervalle positif du type '''Integer''' sont considérées comme négatives, conformément à la représentation entière en complément à deux. Pour plus d’informations sur les types réels et entiers, voir [[A propos des types de données (Delphi)|A propos des types de données (Delphi)]]. Pour plus d’informations sur les types de données des nombres, voir [[Constantes déclarées|Constantes déclarées]].

Le signe pourcentage utilisé comme préfixe indique un nombre binaire, par exemple {{code|%0010}}. Les nombres binaires n’utilisent que les chiffres 0 et 1.

L’utilisation du caractère de soulignement {{code|_}} comme séparateur de chiffres améliore la lisibilité. Lorsqu’il est correctement utilisé, ce caractère n’a aucune valeur et est ignoré par le compilateur. Les caractères de soulignement ne peuvent pas :

* Apparaître au début ou à la fin.
* Être placés à côté d’un préfixe.
* Être doublés.

'''Résumé''' :

{| frame="hsides" border="1" rules="rows"
|-
! '''Type de nombre'''
! '''Syntaxe'''
! '''Exemple'''
|-
|
Décimal
|
aucune
|
5000
|-
|
Hexadécimal
|
{{code|$}}
|
{{code|$FF}}
|-
|
Binaire
|
{{code|%}}
|
%1010
|-
|
Séparateur de chiffres
|
{{code|_}}
|
2_000_000
|-
|
Virgule flottante
|
{{code|.}} et {{code|E}}
|
1.23e4
|-
|
Code de caractère
|
{{code|#}}
|
{{code|#75}}
|}

===Libellés===

Vous pouvez utiliser un identificateur ou un nombre entier non négatif en tant que libellé. Le compilateur {{Delphi}} autorise les libellés numériques allant de 0 à 4294967295 (intervalle uint32).

Les libellés sont utilisés dans les instructions '''goto'''. Pour plus d’informations sur les instructions '''goto''' et les libellés, voir [[Déclarations et instructions (Delphi)#Instructions goto|Instructions Goto]] dans [[Déclarations et instructions (Delphi)|Déclarations et instructions (Delphi)]].

===Chaînes de caractères===

Une chaîne de caractères (appelée également littéral chaîne ou constante chaîne) est une chaîne délimitée, une chaîne de contrôle ou une combinaison de chaînes délimitées et de chaînes de contrôle. Il ne peut y avoir de séparateur qu’à l’intérieur des chaînes délimitées.

Une chaîne délimitée est une séquence de caractères, d’un jeu de caractères ANSI ou multi-octets, écrits sur une seule ligne et placés entre apostrophes. Une chaîne délimitée ne contenant rien entre les apostrophes est une chaîne vide. Deux apostrophes consécutives à l’intérieur d’une chaîne délimitée désigne un seul caractère : une apostrophe.

La chaîne est représentée en interne sous la forme d’une chaîne Unicode encodée en UTF-16. Les caractères du BMP (Basic Multilingual Plane) prennent 2 octets, et les autres caractères nécessitent 4 octets.

Par exemple :

<source lang="delphi">
'Embarcadero' { Embarcadero }
'You''ll see' { You'll see }
'アプリケーションを Unicode 対応にする'
'''' { ' }
'' { null string }
' ' { a space }
</source>

Une chaîne de contrôle est une séquence constituée d’un ou de plusieurs caractères de contrôle, chacun d’eux étant constitué du symbole '''#''' suivi d’une constante entière non signée comprise entre 0 et 65 535 (décimal) ou entre $0 et $FFFF (hexadécimal) dans l’encodage UTF-16 ; et désigne le caractère correspondant à une valeur de code spécifiée. Chaque entier est représenté en interne par 2 octets dans la chaîne. Cela est utile pour représenter des caractères de contrôle et des caractères multi-octets. La chaîne de contrôle :

#89#111#117

Est équivalente à la chaîne délimitée :

'You'

Il est possible de combiner les chaînes délimitées et les chaînes de contrôle pour constituer des chaînes plus longues. Par exemple, vous pouvez utiliser :

'Line 1'#13#10'Line 2'

pour placer une séquence retour chariot-passage à la ligne entre "Ligne 1" et "Ligne 2". Néanmoins, il n’est pas possible de concaténer deux chaînes délimitées en procédant ainsi, en effet deux apostrophes se suivant sont interprétées comme un seul caractère. Pour concaténer des chaînes délimitées, utilisez l’opérateur '''+''' ou combinez-les en une seule chaîne délimitée.

Une chaîne de caractères est compatible avec tout type de chaîne et avec le type '''PChar'''. Puisqu’un type '''AnsiString''' peut contenir des caractères multi-octets, une chaîne de caractères avec un caractère, mono ou multi-octets, est compatible avec tout type de caractère. Quand la syntaxe étendue est activée (avec la directive de compilation {$X+}), une chaîne de caractères non vide de longueur n est compatible avec des tableaux basés sur zéro et des tableaux compactés de n caractères. Pour de plus amples informations, voir [[A propos des types de données (Delphi)|A propos des types de données (Delphi)]].

Depuis RAD Studio 12.0, les littéraux chaîne peuvent dépasser 255 caractères ; en d’autres termes, les littéraux chaîne ne sont pas limités au type Pascal ShortString classique. Le langage ajoute le support des chaînes multilignes. Pour de plus amples information sur les chaînes multilignes, consultez notre page [[Types chaîne (Delphi)|Types de chaînes (Delphi)]], sous Littéraux chaîne longs et multilignes.

==Commentaires et directives de compilation==

Les commentaires ne sont pas pris en compte par le compilateur sauf quand ils agissent comme séparateur (en délimitant des tokens consécutifs) ou comme directive de compilation.

Il y a plusieurs manières de construire des commentaires :

<source lang="delphi">
{ Text between left and right braces is a comment. }
(* Text between left-parenthesis-plus-asterisk and an
asterisk-plus-right-parenthesis is also a comment *)
// Text between double-slash and end of line is a comment.
</source>

Les commentaires de même type ne peuvent pas être imbriqués. Par exemple, <code>(*{}*)</code> fonctionne. Cette dernière forme est utile pour mettre en commentaire des sections de code contenant déjà des commentaires.

Voici quelques recommandations sur l’utilisation (comment et quand) des trois types de caractères de commentaire :

*Utilisez la double barre oblique (//) pour commenter des modifications temporaires effectuées durant la phase de développement. Vous pouvez utiliser le mécanisme <code>CTRL+/</code> de l’éditeur de code afin d’insérer rapidement le caractère double barre oblique de commentaire tout en travaillant.
*Utilisez les caractères parenthèse-étoile "(*...*)" à la fois pour les commentaires de développement et pour le commentaire d’un bloc de code contenant d’autres commentaires. Ce caractère de commentaire permet à plusieurs lignes de source, incluant d’autres types de commentaires, de ne pas être pris en compte par le compilateur.
*Utilisez les accolades ({}) pour la documentation du source que vous souhaitez conserver dans le code.

Un commentaire contenant le signe dollar ('''$''') immédiatement après '''{''' ou '''(*''' est une directive de compilation. Par exemple :

<source lang="delphi">
{$WARNINGS OFF}
</source>

Indique au compilateur de ne pas générer de messages d’avertissement.

==Voir aussi==

*[[Expressions (Delphi)|Expressions (Delphi)]]
*[[Déclarations et instructions (Delphi)|Déclarations et instructions (Delphi)]]
*[[Programmes et unités (Delphi)#Références d’unité et la clause uses|Références d’unité et la clause uses]]
* [[Bibliothèques et packages (Delphi)#Chargement différé (Windows seulement)|Chargement différé]]

[[Category:Delphi]]
[[Category:Guide du langage Delphi]]
[[Category:AMMigrate]]

Fichier d'en-tête C++ (.h, .hpp)

Yukikoi — Thu, 03 Sep 2026 07:26:30 GMT

← Version précédente		Version du 3 septembre 2026 à 07:26
Ligne 1 :		Ligne 1 :
	~~{{DISPLAYTITLE:{{PAGENAME}} (.h, .hpp)}}~~
	{{Parent\|Types de fichiers - Index}}		{{Parent\|Types de fichiers - Index}}

Fichier d'en-tête C++

Yukikoi — Thu, 03 Sep 2026 07:26:12 GMT

Yukikoi a déplacé la page Fichier d'en-tête C++ vers Fichier d'en-tête C++ (*.h, *.hpp)

Nouvelle page

{{DISPLAYTITLE:{{PAGENAME}} (*.h, *.hpp)}}
{{Parent|Types de fichiers - Index}}

Les fichiers d'en-tête C++ définissent une interface C++, généralement implémentée dans un [[Fichier d'implémentation C++|fichier d'implémentation C++]].

==Fichiers d'en-tête {{CBuilder}}==

Dans {{CBuilder}} :

* Les [[Unité|unités]] contiennent généralement un fichier d'en-tête C++ avec {{Path|{{Placeholder|nom d'unité}}.h}} comme nom de fichier.
* Les projets contiennent un fichier d'en-tête C++, {{Path|{{Placeholder|nom de projet}}PCH{{Placeholder|n}}.h}}.

==Fichiers d'en-tête C++ des packages {{Delphi}}==

Lorsque vous [[Compilation de packages|construisez des packages {{Delphi}}]], {{Product}} génère un fichier d'en-tête C++ pour chaque [[Unité|unité]] de votre package ({{Path|{{Placeholder|nom d'unité}}.hpp}}), ainsi qu'un fichier d'en-tête C++ pour votre package ({{Path|{{Placeholder|nom de package}}.hpp}}), tant que l'option '''Génération des fichiers de sortie C/C++''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > [[Sortie - C/C++|Sortie - C/C++]]}} est "Générer tous les fichiers C++Builder (notamment les bibliothèques de packages)".

Les projets C++ qui utilisent votre package ont besoin de ces fichiers d'en-tête C++ pour la compilation.

Lorsque vous construisez votre package {{Delphi}}, vos fichiers d'en-tête C++ sont générés par défaut dans le dossier suivant :

* Pour les plates-formes de bureau : {{Path|{{PublicDocumentsPath}}\hpp\<platform>}}
* Pour les plates-formes mobiles : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}}

Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie .hpp C/C++''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > [[Sortie - C/C++|Sortie - C/C++]]}}.

==Voir aussi==

* [[Fichier d'en-tête précompilé C++ (*.pch)|Fichier d'en-tête précompilé C++]]
* [[Fichier d'implémentation C++|Fichier d'implémentation C++]]

* [[Fichiers de packages créés lors d'une compilation|Fichiers de packages créés lors d'une compilation]]

{{DEFAULTSORT:Fichier d'en-tete C++ (*.h, *.hpp)}}
[[Category:Référence EDI]]
[[Category:XE7]]
[[Category:AMMigrate]]

[[en:C++ Header File (*.h, *.hpp)]]
[[de:C++-Header-Datei]]
[[ja:C++ ヘッダーファイル]]

Procédures et fonctions (Delphi)

Nicolas.rios — Mon, 31 Aug 2026 19:48:09 GMT

Importation d'une routine sous un nom différent

← Version précédente		Version du 31 août 2026 à 19:48
Ligne 352 :		Ligne 352 :

	<source lang="delphi">		<source lang="delphi">
	function MessageBox(HWnd: Integer; Text, Caption: PChar; Flags: Integer): Integer; stdcall; external 'user32.dll' name '~~MessageBoxA~~';</source>		function MessageBox(HWnd: Integer; Text, Caption: PChar; Flags: Integer): Integer; stdcall; external 'user32.dll' name 'MessageBoxW';</source>

	Le nom original de la fonction est {{Code\|~~MessageBoxA~~}}, mais elle est importée sous le nom {{Code\|MessageBox}}.		Le nom original de la fonction est {{Code\|MessageBoxW}}, mais elle est importée sous le nom {{Code\|MessageBox}}.

	Dans votre déclaration d'importationn, assurez-vous de respecter exactement l'orthographe et la casse du nom de la routine. Par la suite, quand vous appelez la routine importée, le nom est insensible à la casse.		Dans votre déclaration d'importationn, assurez-vous de respecter exactement l'orthographe et la casse du nom de la routine. Par la suite, quand vous appelez la routine importée, le nom est insensible à la casse.