Index

• __declslpec(delphireturn)
  • L'extension de mot clé __declspec (L'extension de mot clé __declspec)
• __automated
  • mots clés, C++ (__automated)
• dispid
  • mots clés, C++ (__dispid)
• __except
  • mots clés, C++ (__except)
• _mbsncat
  • strncat
• _mbsnbcat
  • strncat
• _wcsmpi
  • strcmpi, _wcscmpi
• _wsetlocale
  • setlocale, _wsetlocale
• Mappage TCHAR

#

• #if (If, elif, else et endif)
• #ifdef (Ifdef et ifndef)
• #define (define)
• #undef (undef)
• #error (error)
• #include (include)
• #import (import)
• #line (line)
• # character (Conversion des arguments réels en des chaînes ayant l'opérateur #)
• #pragma (pragma)
• #pragma alignment (pragma alignment)
• #pragma argsused (pragma argsused)
• #pragma checkoption (pragma checkoption)
• #pragma codeseg (pragma codeseg)
• #pragma comments, pragma (pragma comment)
• #pragma defineonoption (pragma defineonoption et pragma undefineonoption)
• #pragma exit (pragma exit et pragma startup)
• #pragma hdrfile (pragma hdrfile)
• #pragma hdrstop (pragma hdrstop)
• #pragma inline (pragma inline)
• #pragma intrinsic (pragma intrinsic)
• #pragma link (pragma link)
• #pragma message (pragma message)
• #pragma nopushoptwarn (pragma nopushoptwarn)
• #pragma obsolete (pragma obsolete)
• #pragma option (pragma option)
• #pragma pack (pragma pack)
• #pragma package (pragma package)
• #pragma region (pragma region et pragma end region)
• #pragma resource (pragma resource)
• #pragma warn (pragma warn)

$

• {$A}
  • Alignement des champs (Alignement des champs (Delphi))
• {$ALIGN}
  • Alignement des champs (Alignement des champs (Delphi))
• {$APPTYPE}
  • Type d'application (Type d'application (Delphi))
• {$ASSERTIONS}
  • Directives d'assertion (Directives d'assertion (Delphi))
• {$B}
  • Evaluation booléenne rapide (Evaluation booléenne rapide (directive de compilation Delphi))
• {$BOOLEVAL}
  • Evaluation booléenne rapide (Evaluation booléenne rapide (directive de compilation Delphi))
• {$C}
  • Directives d'assertion (Directives d'assertion (Delphi))
• {$D}
  • Informations de débogage (Informations de débogage (Delphi))
• {$DEBUGINFO}
  • Informations de débogage (Informations de débogage (Delphi))
• {$DEFINE}
  • Directive DEFINE (Directive DEFINE (Delphi))
• {$DENYPACKAGEUNIT}
  • Directive DENYPACKAGEUNIT (Directive DENYPACKAGEUNIT (Delphi))
• {$DESCRIPTION}
  • Description (Description (Delphi))
• {$DESIGNONLY}
  • Directive DESIGNONLY (Directive DESIGNONLY (Delphi))
• {$E}
  • Extension de l'exécutable (Extension de l'exécutable (Delphi))
• {$ELSE}
  • ELSE (ELSE (Delphi))
• {$ELSEIF}
  • ELSEIF (ELSEIF (Delphi))
• {$ENDIF}
  • Directive ENDIF (Directive ENDIF)
• {$EXTENDEDSYNTAX}
  • Syntaxe étendue (Syntaxe étendue (Delphi))
• {$EXTENSION}
  • Extension de l'exécutable (Extension de l'exécutable (Delphi))
• {$EXTERNALSYM}
  • Symboles externes (Symboles externes (Delphi))
• {$FINITEFLOAT}
  • Contrôle des exceptions en virgule flottante (Contrôle des exceptions en virgule flottante (Delphi))
• {$G}
  • Données importées (Données importées)
• {$HIGHCHARUNICODE}
  • Directive HIGHCHARUNICODE (Directive HIGHCHARUNICODE (Delphi))
• {$HINTS}
  • Conseils (Conseils (Delphi))
• {$H+} ou {$H-}
  • Chaînes longues (Chaînes longues (Delphi))
• {$HPPEMIT}
  • HPPEMIT (HPPEMIT (Delphi))
• {$I}
  • Fichier d'inclusion (Fichier d'inclusion (Delphi))
• {$IF}
  • Directive IF (Directive IF (Delphi))
• {$IFDEF}
  • Directive IFDEF (Directive IFDEF (Delphi))
• {$IFEND}
  • Directive IFEND (Directive IFEND (Delphi))
• {$IFNDEF}
  • Directive IFNDEF (Directive IFNDEF (Delphi))
• {$IFOPT}
  • Directive IFOPT (Directive IFOPT (Delphi))
• {$IMAGEBASE}
  • Adresse de base de l'image (Adresse de base de l'image)
• {$IMPLICITBUILD}
  • Compilation implicite (Compilation implicite (Delphi))
• {$IMPORTEDDATA}
  • Données importées (Données importées)
• {$INCLUDE}
  • Fichier d'inclusion (Fichier d'inclusion (Delphi))
• {$IOCHECKS}
  • Contrôle des entrées et des sorties (Contrôle des entrées et des sorties (Delphi))
• {$I+} ou {$I-}
  • Contrôle des entrées et des sorties (Contrôle des entrées et des sorties (Delphi))
• {$L}
  • Liaison avec le fichier objet (Liaison avec le fichier objet (Delphi))
• {$LIB}
  • Directives de compilation pour les bibliothèques ou les objets partagés (Directives de compilation pour les bibliothèques ou les objets partagés (Delphi))
• {$LINK}
  • Liaison avec le fichier objet (Liaison avec le fichier objet (Delphi))
• {$LOCALSYMBOLS|
  • Symboles locaux (Symboles locaux (Delphi))
• {$LONGSTRINGS}
  • Chaînes longues (Chaînes longues (Delphi))
• {$L+} ou {$L-}
  • Symboles locaux (Symboles locaux (Delphi))
• {$M}
  • Informations de types à l'exécution (Informations de types à l'exécution (Delphi))
  • Tailles d'allocation mémoire (Tailles d'allocation mémoire (Delphi))
• {$MESSAGE}
  • Directive MESSAGE (Directive MESSAGE (Delphi))
• {$METHODINFO}
  • Directive METHODINFO (Directive METHODINFO (Delphi))
• {$MINENUMSIZE}
  • Taille minimum d'énumération (Taille minimum d'énumération (Delphi))
• {$MINSTACKSIZE}; {$MAXSTACKSIZE}
  • Tailles d'allocation mémoire (Tailles d'allocation mémoire (Delphi))
• {$NODEFINE}
  • NODEFINE (NODEFINE)
• {$NOINCLUDE}
  • NOINCLUDE (NOINCLUDE (Delphi))
• {$O}
  • Optimisation (Optimisation (Delphi))
• {$ObjExportAll}
  • Exportation des symboles (Exportation des symboles (Delphi))
• {$OPENSTRINGS}
  • Paramètres chaînes ouverts (Paramètres chaînes ouverts (Delphi))
• {$OPTIMIZATION}
  • Optimisation (Optimisation (Delphi))
• {$OVERFLOWCHECKS}
  • Vérification de débordement (Vérification de débordement (Delphi))
• {$P}
  • Paramètres chaînes ouverts (Paramètres chaînes ouverts (Delphi))
• {$POINTERMATH}
  • POINTERMATH (POINTERMATH (Delphi))
• {$Q}
  • Vérification de débordement (Vérification de débordement (Delphi))
• {$R}
  • Fichier ressource (Fichier ressource (Delphi))
• {$RANGECHECKS}
  • Vérification des limites (Vérification des limites)
• {$REALCOMPATIBILITY}
  • Compatibilité Real48 (Compatibilité Real48 (Delphi))
• {$REFERENCEINFO}; {$DEFINITIONINFO}
  • Déclaration de symboles et informations de référence croisée (Déclaration de symboles et informations de référence croisée (Delphi))
• {$REGION}; {$ENDREGION}
  • Régions (Régions)
• {$RESOURCE}
  • Fichier ressource (Fichier ressource (Delphi))
• {$RESOURCERESERVE}
  • Espace adresse réservé pour les ressources (Espace adresse réservé pour les ressources (Delphi))
• {$R+} ou {$R-}
  • Vérification des limites (Vérification des limites)
• {$RUNONLY}
  • Directive RUNONLY (Directive RUNONLY (Delphi))
• {$SCOPEDENUMS}
  • Enumérations de portée (Enumérations de portée (Delphi))
• {$SetPEFlags}
  • PE (Indicateurs d'en-tête PE (Portable Executable) (Delphi))
• {$STACKFRAMES}
  • Cadres de pile (Cadres de pile (Delphi))
• {$T}
  • Contrôle du type des pointeurs (Contrôle du type des pointeurs (Delphi))
• {$TYPEDADDRESS}
  • Contrôle du type des pointeurs (Contrôle du type des pointeurs (Delphi))
• {$TYPEINFO}
  • Informations de types à l'exécution (Informations de types à l'exécution (Delphi))
• {$U}
  • Opérations FDIV du Pentium sécurisées (Opérations FDIV du Pentium sécurisées (Delphi))
• {$UNDEF}
  • Directive UNDEF (Directive UNDEF (Delphi))
• {$V}
  • Contrôle des chaînes var (Contrôle des chaînes var (Delphi))
• {$VARSTRINGCHECKS}
  • Contrôle des chaînes var (Contrôle des chaînes var (Delphi))
• {$W}
  • Cadres de pile (Cadres de pile (Delphi))
• {$WARN}
  • Messages d'avertissement (Messages d'avertissement (Delphi))
• {$WARNINGS}
  • Avertissements (Avertissements (Delphi))
• {$WEAKPACKAGEUNIT}
  • Packaging faible (Packaging faible)
• {$WRITEABLECONST}
  • Constantes typées affectables (Constantes typées affectables (Delphi))
• {$X}
  • Syntaxe étendue (Syntaxe étendue (Delphi))
• {$Y} ou {$YD}
  • Déclaration de symboles et informations de référence croisée (Déclaration de symboles et informations de référence croisée (Delphi))
• {$Z}
  • Taille minimum d'énumération (Taille minimum d'énumération (Delphi))

*

• * opérateur
  • Opérateurs de référencement/déréférencement, C++ (Opérateurs de référencement/déréférencement)

+

• opérateur ++
  • opérateurs, C++ (Opérateurs d'incrémentation/décrémentation)
• opérateur +
  • opérateurs, C++ (Opérateurs plus et moins)

-

• option de compilation -D (Utilisation des options de ligne de commande -D et -U)

.

• fichiers .targets (Fichiers cibles)
• opérateur .
  • opérateurs, C++ (. (Sélecteur de membre direct ))

?

• opérateur ?:
  • opérateurs, C++ (Opérateurs conditionnels)

A

• accès
  • espaces de nommage, C++ (Accès aux éléments d'un espace de nommage)
  • espaces de nommage, C++ (Directive using)
  • espaces de nommage, C++ (Qualification d'accès explicite)
  • espaces de nommage, C++ (Using)
• Achèvement du code
  • présentation (Achèvement du code)
• action bouton de souris enfoncé (Réponse à l'action bouton de souris enfoncé)
• action bouton de souris relâché (Réponse à l'action bouton de souris relâché)
• action d'entrée et action de sortie
  • création (Conception d'un diagramme d'états UML 1.5)
• actions (Qu'est-ce qu'une action ?)
  • bandes d'action (Création des barres d'outils et des menus)
  • bandes d'action (Définition des bandes d'actions)
  • écriture de composants (Comment les actions trouvent leurs cibles)
  • écriture de composants (Conception de composants action)
  • exécution (Que se passe-t-il lors du déclenchement d'une action ?)
  • listes d'actions (Organisation des actions pour les barres d'outils et les menus)
  • listes d'actions (Programmes démo, actions, listes d'actions, menus et barres d'outils)
  • listes d'actions (Recensement d'actions)
  • prédéfinies (Classes d'actions prédéfinies)
  • utilisation (Utilisation des listes d'actions)
• actions souris
  • ajout d'un champ à une fiche (Ajout d'un champ à un objet fiche pour faire le suivi des actions de la souris)
• Activation du support (Activation du support de la modélisation UML pour les projets)
• ADO
  • connexion aux stockages de données (Connexion d'un ensemble de données ADO à un stockage de données)
  • lecture asynchrone (Lecture d'enregistrements de façon asynchrone)
  • mises à jour groupées (Utilisation des mises à jour groupées)
  • modes de connexion (Indication des types d'opérations pris en charge par la connexion)
  • objet connexion (Accès à l'objet connexion)
  • objets ensemble d'enregistrements (Utilisation des ensembles d'enregistrements)
• adresses IP
  • hôtes et (Description de l'hôte)
• affectation
  • opérateurs, C++ (Opérateurs d'affectation)
• affectation d'un nom
  • threads (Affectation de noms distincts à des threads similaires)
  • threads (Nommer un thread)
• affichage des données
  • activation et désactivation (Activation et désactivation de l'affichage des données)
• affichage des images bitmap (Affichage d'une image bitmap plein écran dans une application Fiches VCL)
• agrégation
  • interfaces (Agrégation)
  • objets COM (Serveurs Automation (COM))
• aide
  • SDK de la plate-forme Microsoft (Présentation de l'aide)
• ajout d'un contrôle image (Ajout d'un contrôle image)
• Ajouter une référence or Ajout d'une référence (Boîte de dialogue Ajouter, onglet Requiert)
• alias
  • espaces de nommage, C++ (Alias d'un espace de nommage)
• alignas
  • mots clés, C++ (Alignas)
• alignof
  • mots clés, C++ (Alignof)
• amies, des classes
  • spécificités du langage C++ (Amies de classes)
• ancrage
  • contrôles enfant ancrables (Contrôle de l'ancrage des contrôles enfant)
  • contrôles enfant ancrables (Contrôle du désancrage des contrôles enfant)
  • contrôles enfant ancrables (Transformation d'un contrôle en un enfant ancrable)
• and
  • représentations alternatives des tokens C++ (And)
• animation
  • AVI (Contrôle animation)
• annulation des modifications de données (Annulation des modifications)
• annuler
  • refactoring (Annulation d'un refactoring (Delphi))
• AnsiStringT et la page de code
  • gestion C++ (Comment gérer la spécification de page de code AnsiString Delphi dans C++)
• API Open Tools
  • API Tools (Présentation de l'API Tools)
• API Tools
  • création de modules (Création de fiches et de projets)
  • interfaces d'éditeur (Utilisation des interfaces d'éditeur)
  • interfaces de module (Utilisation des interfaces de module)
  • numéros de version (Numéros de version de l'interface)
  • objets natifs de l'EDI (Utilisation d'objets natifs de l'EDI)
  • services (Accès aux services de l'API Tools)
• appel de procédures et de fonctions
  • des procédures et des fonctions (Appel de procédures et de fonctions)
• appels de fonction (Macros avec paramètres)
  • structure du langage C++ (Appels de fonctions et conversion d'arguments)
• applications
  • compilation (Compilation des applications)
  • conception (Conception d'applications)
  • console (Applications console)
  • création (Applications GUI)
  • création (Création d'applications)
  • création (Création de projets)
  • débogage (Débogage des applications)
  • déploiement (Déploiement d'applications - vue globale)
  • déploiement (Déploiement des applications)
• applications client
  • Appel des interfaces serveur (Appel des interfaces serveur)
  • connexion aux serveurs (Connexion au serveur)
  • fermeture des connexions (Fermeture ou changement de connexion serveur)
  • multiniveaux (Structure de l'application client)
• applications COM
  • applications DCOM (Ecriture d'applications en utilisant COM)
• applications complémentaires (Applications complémentaires)
• applications de bases de données (Ecriture d'applications de bases de données)
  • applications multiniveaux (Distribution d'applications de bases de données)
  • BDE (Utilisation du moteur de bases de données Borland)
  • déploiement (Déploiement d'applications de bases de données)
  • états (Ecriture d'états)
• applications de bases de données multiniveaux
  • ensembles de données client (Utilisation d'une architecture multiniveau)
• applications distribuées
  • interfaces (Utilisation d'interfaces dans les applications distribuées)
• applications générales
  • déploiement (Déploiement d'applications générales)
• applications internationales (Création d'applications internationales - Index)
  • bidirectionnelles (Inclusion de fonctionnalités bi-directionnelles dans les applications)
  • localisation (Localisation des applications)
• applications ISAPI
  • débogage (Débogage d'applications Web sous forme de DLL)
• Applications MDI
  • Applications SDI (Modèles d'interfaces utilisateur)
  • interface de document multiple (Applications MDI)
• applications multiniveaux
  • applications client (Création d'applications multiniveaux : Vue globale)
  • avantages (Avantages du modèle de base de données multiniveau)
  • clients ActiveX (Distribution d'une application client en tant que contrôle ActiveX)
  • création (Construction d'une application multiniveau)
  • fournisseurs (Présentation des applications de bases de données multiniveaux)
  • fournisseurs de données (Utilisation des composants fournisseur)
  • informations d'état (Gestion des informations d'état dans les modules de données exposés)
  • InternetExpress (Construction des applications Web avec InternetExpress)
  • modules de données distants multiples (Connexion à un serveur d'applications qui utilise plusieurs modules de données)
  • modules de données distants multiples (Utilisation de plusieurs modules de données serveur)
  • présentation (Présentation d'une application à niveau triple)
  • protocoles de connexion (Sélection d'un protocole de connexion)
• applications multithreads
  • accès de threads simultanés (Eviter les accès de threads simultanés dans la même mémoire)
  • applications (Gestion de sessions multiples)
  • attente des threads (Attente des threads)
  • écriture de la fonction thread (Ecriture de la fonction Thread (Procédure))
  • gestion des exceptions (Gérer les exceptions)
  • initialisation des threads (Initialisation d'un thread)
  • nettoyage des threads (Ecriture du code de nettoyage)
  • objet thread (Définition de l'objet thread)
  • thread principal (Utilisation du thread VCL principal)
• Applications SDI
  • interface de document unique (Applications SDI)
• Applications serveur Web
  • adaptateurs (Adaptateurs)
  • applications (Création d'applications services Web)
  • applications WebBroker (Création d'applications WebBroker)
  • architecture (Structure d'une application WebBroker)
  • création (Création d'applications serveur Web avec WebSnap)
  • création (Création d'applications serveur Web en utilisant WebSnap)
  • création (Générateurs de page)
  • création (Sélection des options du module d'application Web)
  • création (Sélection d'un type de serveur)
  • création (Spécification des composants du module d'application)
  • création (Types de module d'application Web)
  • Création d'applications WebSnap (Création d'applications WebSnap)
  • débogage (Débogage d'applications serveur)
  • types (Types d'applications serveur Web)
  • WebSnap (A propos de WebBroker et de WebSnap)
• applications service
  • débogage (Débogage d'applications service)
  • objet Application (Applications service)
  • threads (Threads de service)
• applications VCL
  • dbExpress (Conception d'une application Fiches VCL de base de données dbExpress)
  • Fiches VCL (Construction d'une application Fiches VCL)
• applications Web
  • déploiement (Déploiement d'applications Web)
  • multiniveaux (Ecriture des applications client Web)
• application Windows Forms
  • construction (Développement d'une application Windows)
• architecture
  • applications à niveau unique (Connexion directe à un serveur de bases de données)
  • applications à niveau unique (Utilisation d'un fichier dédié sur disque)
  • applications de bases de données (Architecture des bases de données)
  • BDE (Architecture BDE)
• artefact
  • déploiement (Conception d'un diagramme de déploiement UML 2.0)
• asm
  • mots clés, C++ (Asm, asm, asm)
• assembleur en ligne (Utilisation du code assembleur en ligne (Win32 uniquement))
• assistances de classes
  • classes et objets (Assistances de classes et d'enregistrements)
• attributs des champs
  • suppression (Suppression des associations d'attributs)
• audio
  • vidéo (Ajout de séquences audio et/ou vidéo à une application)
  • vidéo (Exemple d'ajout de séquences audio et/ou vidéo (VCL seulement))
• audit
  • histogramme (Fonctionnalités des audits et des métriques)
• audit de code
  • audit de code (Utilisation de l'audit de code)
• audits
  • tri (Visualisation des résultats des audits)
• auto
  • mots clés, C++ (Auto)
• __automated
  • mots clés, C++ (Automated)
• Automation
  • gestion des événements (Gestion des événements dans un objet Automation)
  • Serveurs (Serveurs Automation)
• avi
  • animation (Ajout de séquences vidéo silencieuses à une application)
  • animation (Exemple d'ajout de séquences vidéo silencieuses)
• axiom
  • mots clés, C++ (Axiom)

B

• Bof
  • Utilisation des propriétés Eof et Bof (Utilisation des propriétés Eof et Bof)
• balises HTML transparentes (Utilisation de noms prédéfinis de balises HTML transparentes)
• bandes d'action
  • création de listes d'éléments les plus récemment utilisés (Création de listes d'éléments les plus récemment utilisés)
  • création de menus dynamiques (Création de menus dynamiques)
  • dissimulation des éléments inutilisés (Dissimilation des éléments et des catégories inutilisés dans les bandes d'action)
• barre d'outils
  • Editeur de bibliothèque de types (Barre d'outils)
• barres de défilement (Ajout de barres de défilement en mode exécution)
  • contrôles (Barres de défilement)
• Barres de modification
  • dans l'éditeur de code (Editeur de code)
• barres de progression (Barres de progression)
• barres d'état (Barres d'état)
• barres d'outils (Contrôles de la barre d'outils)
  • ajout de barres d'outils masquées (Ajout de barres d'outils masquées)
  • ajout en utilisant le composant barre d'outils (Ajout d'une barre d'outils en utilisant le composant barre d'outils)
  • ajout en utilisant un composant volet (Ajout d'une barre d'outils en utilisant un composant volet)
  • conception (Conception de barres d'outils et de barres multiples)
  • masquage et affichage (Masquage et affichage d'une barre d'outils)
  • personnalisation (Personnalisation des barres d'outils)
• barres graduées
  • contrôles (Barres graduées)
• barres multiples (Barres multiples)
  • ajout (Ajout d'un composant barre multiple)
  • définition de l'aspect (Définition de l'aspect de la barre multiple)
• base de données
  • ajouter une nouvelle connexion (Utilisation de directives du concepteur avec des composants VCL)
  • connexions (Contrôle des connexions)
  • dbExpress (Compatibilité du framework dbExpress)
  • dbExpress (Framework dbExpress)
• Base de données
  • ajouter une nouvelle connexion (Ajout d'une nouvelle connexion à l'explorateur de données)
• bases de données
  • applications de bases de données (Conception d'applications de bases de données : Vue globale)
  • association avec les sessions (Association d'un composant base de données à une session)
  • composants connexion (Connexion aux bases de données : Vue globale)
  • connexion (Connexion au serveur de bases de données)
  • connexion (Utilisation de TDatabase pour établir une connexion aux bases de données)
  • considérations (Utilisation des bases de données)
  • ensembles de données (Utilisation d'ensembles de données associés)
  • métadonnées (Obtention de métadonnées)
  • mises à jour placées en mémoire cache (Application des mises à jour en mémoire cache avec une base de données)
  • modification de données (Modification des données)
  • recherche (Recherche d'une connexion de base de données)
  • sécurité (Contrôle de la connexion au serveur)
  • sécurité (Sécurité des bases de données)
  • sessions (Interactions entre les composants base de données et session)
  • transactions (Transactions)
• BatchMove (composant)
  • ajout (Création d'un composant action groupée)
  • gestion des erreurs (Gestion des erreurs relatives aux actions groupées)
  • opérations groupées (Utilisation de TBatchMove)
• BCC32.EXE
  • ligne de commande (BCC32, le compilateur C++ en ligne de commande)
• BDE
  • utilitaires (Outils de manipulation du BDE)
• BeforeUpdateRecord (événement)
  • OnGetTableName (événement) (Intervention pendant l'application des mises à jour)
• bibliothèque de classes
  • branche TObject (Branche TObject)
• bibliothèque de types
  • activation de la liaison de données simple dans un contrôle ActiveX (Activation de la liaison de données simple avec la bibliothèque de types)
  • actualiser (Actualisation de la bibliothèque de types)
  • ajout de membres d'une CoClasse (Ajout d'une interface à une CoClasse)
  • ajout de propriétés et de méthodes (Ajout de propriétés et de méthodes à la bibliothèque de types)
  • ajout d'un alias (Ajout d'un alias à une bibliothèque de types)
  • ajout d'une CoClasse (Ajout d'une CoClasse à une bibliothèque de types)
  • ajout d'une énumération (Ajout d'une énumération à une bibliothèque de types)
  • ajout d'une interface (Ajout d'une interface à une bibliothèque de types)
  • ajout d'un enregistrement ou d'une union (Ajout d'un enregistrement ou d'une union à une bibliothèque de types)
  • ajout d'un module (Ajout d'un module à une bibliothèque de types)
  • Appliquer les modifications (boîte de dialogue) (Boîte de dialogue Appliquer les modifications)
  • création (Création d'une nouvelle bibliothèque de types)
  • déploiement (Déploiement des bibliothèques de types)
  • enregistrement (Enregistrement d'une bibliothèque de types)
  • enregistrement et recensement des informations (Enregistrement et recensement des informations d'une bibliothèque de types)
  • modification d'une interface (Modification d'une interface en utilisant la bibliothèque de types)
  • ouverture (Ouverture d'une bibliothèque de types existante)
  • recensement (Recensement de la bibliothèque de types)
• bibliothèques chargées dynamiquement
  • bibliothèques (Ecriture de bibliothèques à chargement dynamique)
• bibliothèques de types (Utilisation des bibliothèques de types : Vue globale)
  • manipulation (Utilisation des bibliothèques de types : Vue globale)
  • tâches (Utilisation de l'éditeur de bibliothèques de types)
• bibliothèques et packages (Bibliothèques et packages)
• bibliothèques javascript (Utilisation des bibliothèques javascript)
• biseaux (Biseaux)
• bitand
  • spécificités du langage C++ (Bitand)
• bitmaps
  • bitmaps hors écran (Bitmaps hors écran)
  • définition de la taille (Définition de la taille initiale du bitmap)
  • dessin sur (Dessiner sur un bitmap)
• bitor
  • représentations alternatives des tokens C++ (Bitor)
• BLOB
  • en mémoire cache (Mise en cache des BLOBS)
• bloc conditionnel
  • ajout (Ajout d'un bloc conditionnel)
• blocs
  • structure du langage C++ (Blocs)
• boîte de dialogue en composant
  • écriture des composants (Transformation d'une boîte de dialogue en composant : Vue globale)
• boîtes à options (Boîtes à options)
• boîtes à peindre
  • dessin (Boîtes à peindre)
• boîtes de défilement (Boîtes de défilement)
• boîtes de dialogue
  • boîtes de dialogue communes (Développement de boîtes de dialogue)
• boîtes de dialogue standard
  • utilisation (Utilisation des boîtes de dialogue standard de Windows)
• boîtes groupe
  • groupes de boutons radio (Boîtes groupe et groupes de boutons radio)
• boîtes liste (Boîtes liste et boîtes liste de cases à cocher)
  • orientées données (Affichage et édition de données dans les boîtes liste et les boîtes à options)
  • orientées données (Utilisation de TDBListBox et de TDBComboBox)
• boîtes liste de référence
  • boîtes à options de référence (Affichage et édition de données dans les boîtes liste et les boîtes à options de référence)
• _Bool
  • mots clés, C++ (Bool)
• bool
  • mots clés, C++ (Bool, false, true)
• bool __has_nothrow_assign ( typename T )
  • Fonctions trait de type C++0x (Has nothrow assign)
• bool __ has_nothrow_copy_constructor( typename T )
  • Fonctions trait de type C++0x (Has nothrow copy constructor)
• bool __has_nothrow_default_constructor (typename T )
  • Fonctions trait de type C++0x (Has nothrow default constructor)
• bool __has_trivial_assign (typename T )
  • Fonctions trait de type C++0x (Has trivial assign)
• bool __has_trivial_default_constructor (typename T )
  • Fonctions trait de type C++0x (Has trivial default constructor)
• bool_has __trivial_default_constructor( typename T )
  • Fonctions trait de type C++0x (Has trivial copy constructor)
• _bool __has_trivial_destructor (typename T )
  • Fonctions trait de type C++0x (Has trivial destructor)
• bool __has_virtual_destructor (typename T )
  • Fonctions trait de type C++0x (Has virtual destructor)
• bool __is_abstract( typename T )
  • Fonctions trait de type C++0x (Is abstract)
• bool __is_arithmetic(Typename T)
  • Fonctions trait de type C++0x (Is arithmetic)
• bool __is_array( Typename T )
  • Fonctions trait de type C++0x (Is array)
• bool __is_base_of ( typename Base, typename Derived )
  • Fonctions trait de type C++0x (Is base of)
• bool __is_class(T)
  • Fonctions trait de type C++0x (Is class)
• bool __is_complete_type(T)
  • Fonctions trait de type C++0x (Is complete type (typename T ))
• bool __is_compound( typename T )
  • Fonctions trait de type C++0x (Is compound)
• bool __is_const(typename T)
  • Fonctions trait de type C++0x (Is const)
• bool __is_convertible (typename From, typename To )(typename T)
  • Fonctions trait de type C++0x (Is convertible)
• bool __is_empty( typename T )
  • Fonctions trait de type C++0x (Is empty)
• bool __is_enum_type( typename T )
  • Fonctions trait de type C++0x (Is enum)
• bool __is_floating_point(typename T)
  • Fonctions trait de type C++0x (Is floating point)
• bool __is_function( typename T )
  • Fonctions trait de type C++0x (Is function)
• bool __is_fundamental( typename T )
  • Fonctions trait de type C++0x (Is fundamental)
• bool __is_integral(typename T)
  • Fonctions trait de type C++0x (Is integral)
• bool __is_lvalue_expr( typename T )
  • Fonctions trait de type C++0x (Is lvalue expr)
• bool __is_lvalue_reference( typename T )
  • Fonctions trait de type C++0x (Is lvalue reference)
• bool __is_member_function_pointer( typename T )
  • Fonctions trait de type C++0x (Is member function pointer)
• bool __is_member_object_pointer( typename T )
  • Fonctions trait de type C++0x (Is member object pointer)
• bool __is_member_pointer( typename T )
  • Fonctions trait de type C++0x (Is member pointer)
• bool __is_object( typename T)
  • Fonctions trait de type C++0x (Is object)
• bool __is_pod( typename T )
  • Fonctions trait de type C++0x (Is pod)
• bool __is_pointer(Typename T )
  • Fonctions trait de type C++0x (Is pointer)
• bool __is_polymorphic( typename T )
  • Fonctions trait de type C++0x (Is polymorphic)
• bool __is_reference( typename T )
  • Fonctions trait de type C++0x (Is reference)
• bool __is_rvalue_expr( typename T )
  • Fonctions trait de type C++0x (Is rvalue expr)
• bool __is_rvalue_reference( typename T )
  • Fonctions trait de type C++0x (Is rvalue reference)
• bool __is_same( typename T, typename U )
  • Fonctions trait de type C++0x (Is same)
• bool __is_scalar( typename T )
  • Fonctions trait de type C++0x (Is scalar)
• bool __is_signed( typename T )
  • Fonctions trait de type C++0x (Is signed)
• bool __is_standard_layout(typename T)
  • Fonctions trait de type C++0x (Is standard layout)
• bool __is_trivial( typename T )
  • Fonctions trait de type C++0x (Is trivial)
• bool __is_union( typename T )
  • Fonctions trait de type C++0x (Is union)
• bool __is_unsigned( typename T )
  • Fonctions trait de type C++0x (Is unsigned ( typename T ))
• bool __is_void( typename T )
  • Fonctions trait de type C++0x (Is void)
• bool __is_volatile( typename T )
  • Fonctions trait de type C++0x (Is volatile)
• boutons bascule (Utilisation de boutons bascule)
• boutons bitmap (Boutons bitmap)
• boutons outil
  • affectation des images (Affectation d'images à des boutons outil)
  • affectation d'un menu aux (Affectation d'un menu à un bouton outil)
  • ajout (Ajout d'un bouton outil)
  • création de groupes (Création de groupes de boutons outil)
  • création de groupes (Utilisation de boutons outil bascule)
  • définition de l'aspect et des conditions initiales (Définition de l'aspect et de l'état initial d'un bouton outil)
• boutons radio (Boutons radio)
• Branche TComponent
  • présentation (Branche TComponent)
• Branche TControl
  • présentation (Branche TControl)
• Branche TPersistent
  • présentation (Branche TPersistent)
• branche TWinControl
  • présentation (Branche TWinControl/TWidgetControl)
• BRC32.EXE (BRC32, le Shell de ressources)
• BRCC32.EXE (BRCC32.EXE, le compilateur de ressources)
• break
  • mots clés, C++ (Break)
• Broadcast (méthode)
  • envoi des messages (Diffusion d'un message à tous les contrôles d'une fiche)
• bureau de débogage
  • définir le bureau de débogage (Sélectionner le bureau de débogage)

C

• cadre
  • propriétés publiées (Initialisation des propriétés à la conception)
• cadres (Manipulation des cadres)
  • création (Création de cadres)
  • partage (Partage des cadres)
  • partage (Utilisation et modification des cadres)
• canevas
  • graphiques (Utilisation du canevas)
  • propriétés et méthodes (Propriétés et méthodes communes du canevas)
• #, caractère (Macros avec paramètres)
• caractère inerte (whitespace)
  • éléments lexicaux, C++ (Caractère inerte)
• caractères étendus
  • caractères Unicode (Jeux de caractères)
• case
  • mots clés, C++ (Case)
• cases à cocher (Cases à cocher)
  • orientées données (Manipulation de champs booléens avec des cases à cocher)
• catch
  • mots clés, C++ (Catch)
• Catégories de l'API
  • Allocation dynamique (Routines d'allocation mémoire dynamique)
  • Constantes d'attributs de fichiers (Liste des attributs de fichiers)
  • Constantes de couleur (Constantes de couleur)
  • Constantes de mode de copie (Constantes de mode de copie)
  • Constantes de mode de fichier (Constantes de mode de fichier)
  • Constantes des opérateurs (Constantes des opérateurs)
  • Constantes des types de variants (Codes touche virtuelle)
  • Constantes des types de variants (Constantes des types de variants)
  • Constantes du curseur de la souris (Constantes du curseur de la souris)
  • Constantes du résultat modal (Constantes du résultat modal)
  • Contrôle de la FPU (Membres du contrôle de la FPU)
  • Flux, concepteurs et lecteurs (Flux, lecteurs et concepteurs)
  • Gestion des threads (Membres de gestion des threads)
  • Informations de niveau application (Informations de niveau application)
  • Manipulation des caractères (Routines de manipulation des caractères)
  • Manipulation des chemins (Routines de manipulation des chemins)
  • Routines de conversion des types (Routines de conversion des types)
  • Routines de gestion (Routines financières et de gestion)
  • Routines intrinsèques (Routines intrinsèques de Delphi)
  • Routines mathématiques (Contrôles BDE)
  • Routines mathématiques (Contrôles Client DataSnap)
  • Routines mathématiques (Contrôles d'accès aux données)
  • Routines mathématiques (Contrôles DBExpress)
  • Routines mathématiques (Contrôles DbGo)
  • Routines mathématiques (Contrôles de données)
  • Routines mathématiques (Contrôles Dialogues)
  • Routines mathématiques (Contrôles Dialogues Vista)
  • Routines mathématiques (Contrôles Internet)
  • Routines mathématiques (Contrôles Internet Express)
  • Routines mathématiques (Contrôles Ruban)
  • Routines mathématiques (Contrôles Serveur DataSnap)
  • Routines mathématiques (Contrôles Standard)
  • Routines mathématiques (Contrôles supplémentaires)
  • Routines mathématiques (Contrôles Système)
  • Routines mathématiques (Contrôles WebSnap)
  • Routines mathématiques (Contrôles Win 3.1)
  • Routines mathématiques (Contrôles Win32)
  • Routines mathématiques (Routines de comparaison)
  • Routines mathématiques (Routines mathématiques)
  • Routines mathématiques (Services Web)
  • Support BCD (Routines de support BCD)
  • Support COM/OLE (Membres du support COM/OLE)
  • Support date/heure (Support date/heure)
  • Support de la ligne de commande (Routines de support de la ligne de commande)
  • Support de l'interface et du GUID (Routines de support de l'interface et du GUID)
  • Support des actions (Routines de support des actions)
  • Support des dialogues (Routines de support des dialogues)
  • Support des disques et des répertoires (Routines de support des disques et des répertoires)
  • Support des entrées/sorties des fichiers (Support des entrées/sorties des fichiers)
  • Support des menus (Membres du support des menus)
  • Support des nombres aléatoires (Membres du support des nombres aléatoires)
  • Support des nombres complexes (Routines de support des nombres complexes)
  • Support des variants (Routines de support des variants)
  • Support du Presse-papiers (Routines de support du Presse-papiers)
  • Support UCS4 (Routines de conversion UTF-8)
  • Support UTF-8 (Routines de conversion UTF-8)
  • Support XML (Membres du support XML)
• cdecl
  • mots clés, C++ (Cdecl, cdecl, cdecl)
• chaînes
  • accès à une liste de chaînes (Accès à une chaîne spécifique)
  • Codage de l'application pour différents paramètres régionaux (Codage de l'application)
  • déclaration et initialisation (Déclaration et initialisation de chaînes)
  • manipulation (Utilisation des chaînes)
• champs
  • classes et objets (Champs)
  • mise à jour des valeurs (Edition des données affichées dans un contrôle)
  • restriction de saisie (Contrôle ou dissimulation de la saisie utilisateur)
  • valeurs par défaut (Définition de la valeur par défaut d'un champ)
• champs ADT (Utilisation des champs ADT)
• champs agrégat
  • définition (Définition d'un champ agrégat)
• champs calculés (Champs calculés)
  • affectation de valeurs (Programmation d'un champ calculé)
  • définition (Définition d'un champ calculé)
• champs de bits
  • structure du langage C++ (Champs de bits)
• champs de référence (Utilisation des champs de référence)
  • définition (Définition d'un champ de référence)
• champs ensemble de données (Utilisation des champs ensemble de données)
• champs mémo
  • affichage avec des informations de format (Affichage et édition dans un contrôle mémo de texte formaté)
  • affichage et édition (Affichage et édition de texte dans un contrôle mémo)
• champs objet
  • champs (Utilisation des champs objet)
• champs persistants
  • création (Création de champs persistants)
  • définition (Définition de nouveaux champs persistants)
  • objets champ (Composants champ persistant)
  • organisation (Modification de l'ordre des champs persistants)
  • suppression (Suppression de composants champ persistant)
• changement d'outil en utilisant des turboboutons (Changement d'outil en utilisant des turboboutons)
• Change (méthode) (Modification de la méthode Change)
• ChangeScale
  • transtypages (Mise à l'échelle d'écran et ChangeScale)
• char
  • mots clés, C++ (Char)
• char16_t
  • mots clés, C++ (Char16 t)
• char32_t
  • mots clés, C++ (Char32 t)
• chargement des images
  • fichiers (Chargement et stockage des graphiques)
• chemin de recherche (Ajouter le chemin de recherche de la table des symboles)
• chemin de recherche (Chemins et répertoires (C++))
• chemin de recherche (Compilateur)
• chemin de recherche (Répertoires et Conditions)
• class
  • mots clés, C++ (Class)
• classe
  • filtrage (Utilisation des filtres d'affichage)
• classe d'association
  • delete (Création d'une classe d'association)
• classe lien de données sur un champ (Mise à jour de la classe lien de données sur un champ)
• classes
  • définition (Définition de nouvelles classes)
  • définition (Définition de nouvelles classes (Delphi))
  • dérivation (Dérivation de nouvelles classes)
  • dérivation (Dérivation du composant)
  • suppression des dépendances (Suppression des dépendances)
• classes,
  • spécificités du langage C++ (Classes C++)
• classes abstraites
  • spécificités du langage C++ (Classes abstraites)
• classes ancêtres (Ajout de nouvelles capacités à une classe)
  • classes dérivées (Ancêtres, descendants et hiérarchies des classes)
• classes de base
  • spécificités du langage C++ (Accès aux classes de base et dérivées)
• classes de base virtuelles
  • spécificités du langage C++ (Classes de base virtuelles)
• classes de stockage
  • structure du langage C++ (Types et classes de stockage)
• classes et objets
  • classes et objets (Classes et objets)
• classes, forward
  • spécificités du langage C++ (Déclarations de classes VCL)
• classes, liste de membres
  • spécificités du langage C++ (Liste des membres de classe)
• classes, objets
  • spécificités du langage C++ (Objets de classes)
• classes polymorphes
  • spécificités du langage C++ (Classes polymorphes - Index)
• classes, portée
  • spécificités du langage C++ (Portée de classe)
• classes, types
  • spécificités du langage C++ (Types de classes)
• __classid
  • mots clés, C++ (Classid)
• classificateur inner
  • création (Création d'un classificateur inner)
• __classmethod
  • mots clés, C++ (Classmethod)
• clics
  • réponse (Réponse aux clics)
• clients
  • applications multiniveaux (Création de l'application client)
  • COM (Clients COM)
• Clients COM
  • écriture (Contrôle d'un objet importé)
  • importer une bibliothèque de types (Importation des informations d'une bibliothèque de types)
• client Web (Propriétés décrivant le client Web)
• Clipboard (Ajout de l'objet Presse-papiers)
• __closure
  • mots clés, C++ (Closure)
• code
  • modification (Modification du code)
• CodeGuard
  • avertissements (Avertissements de comparaison de chaînes)
  • avertissements (Avertissements pour la comparaison de blocs mémoire)
  • avertissements (Avertissements sur la fusion et la scission de noms de chemins)
  • erreurs (Erreurs d'accès)
  • erreurs (Erreurs d'échec de fonction)
  • erreurs (Erreurs de ressources)
  • erreurs (Erreurs d'exceptions)
  • présentation (Présentation de CodeGuard)
  • utilisation (Utilisation de CodeGuard)
• COFF2OMF.EXE (COFF2OMF.EXE, l'outil de conversion d'une bibliothèque d'importation)
• colonnes
  • listes de référence (Définition d'une colonne de liste de référence)
  • propriétés (Affichage des champs ADT et tableau)
  • propriétés (Définition des propriétés de colonne en mode conception)
  • propriétés (Restauration des valeurs par défaut d'une colonne)
• colonnes persistantes
  • ajout de boutons (Insertion d'un bouton dans une colonne)
  • création (Création de colonnes persistantes)
  • réorganisation (Modification de l'ordre des colonnes persistantes)
  • suppression dans l'éditeur de colonnes (Suppression de colonnes persistantes)
• COM
  • clients (Création de clients COM)
  • exposition des propriétés (Définition de l'interface d'un objet COM)
  • présentation (Présentation des technologies COM)
  • présentation de la création des objets (Création de serveurs COM simples : Vue globale)
• COM+ (Objets Abonnement d'événement et Evénement COM+)
• commande MSBuild (Construction d'un projet à l'aide d'une commande MSBuild)
• CommandText
  • ensembles de données client (Redéfinition de l'ensemble de données sur le serveur d'applications)
• commentaire (Annotation d'un diagramme)
• commentaires
  • éléments lexicaux, C++ (Commentaires)
• commentaires (Delphi) (Eléments syntaxiques fondamentaux)
• compatibilité de type
  • types de données (Compatibilité et identité de types)
• compilation (Compilation, construction et exécution d'applications)
  • directives du compilateur, Delphi (Compilation conditionnelle (Delphi))
• compl
  • représentations alternatives des tokens C++ (Compl)
• _Complex
  • mots clés, C++ (Complex)
• Composant
  • Importer un composant (Expert Importer un composant)
• composantes d'une application COM (Composantes d'une application COM)
• Composant (expert)
  • composants (Création d'un composant avec l'expert composant)
• composants (Vue globale de la création d'un composant)
  • ajout à la palette d'outils (Accessibilité des composants au moment de la conception : Vue globale)
  • catégories de propriétés (Catégories de propriétés)
  • catégories de propriétés (Recensement de plusieurs propriétés en une seule fois)
  • catégories de propriétés (Recensement d'une propriété à la fois)
  • catégories de propriétés (Spécification de catégories de propriétés)
  • catégories de propriétés (Utilisation de la fonction IsPropertyInCategory)
  • classes (Composants et classes)
  • conception (Contenu d'un composant)
  • création (Création de composants)
  • création (Création d'un nouveau composant)
  • création et enregistrement (Création et enregistrement du composant modifié)
  • dépannage (Problèmes d'installation de composants personnalisés (C++))
  • enregistrement (Enregistrement des composants (Introduction))
  • gestion de la mémoire (Composants et appartenance)
  • graphiques (Utilisation des graphiques et des composants Vue globale)
  • installation (Ajout de composants personnalisés à la palette d'outils)
  • installation (Compilation des composants en packages)
  • propriétés (Définition des propriétés, des méthodes et des événements)
  • recensement (Enregistrement du composant)
  • regroupement (Regroupement de contrôles)
  • renommer (Changement du nom d'un composant)
  • test (Test des composants installés)
  • test (Test des composants non installés)
• Composants ADO
  • bases de données (Utilisation des composants ADO)
• composants connexion
  • applications client (Connexion au serveur d'applications)
  • implicites (Utilisation de connexions implicites)
• composants connexion ADO
  • commandes associées (Accès aux ensembles de données d'une connexion)
  • connexions (Connexion à un stockage de données avec TADOConnection)
  • connexions (Optimisation d'une connexion)
• composants de commande ADO
  • commandes SQL (Utilisation d'objets commande)
• Composants de la page InterBase
  • prise en main (Introduction à InterBase Express)
• composants non visuels
  • création (Création de composants non visuels)
• composants WebSnap (Composants WebSnap de base)
• concept
  • mots clés, C++ (Concept)
• concepteur de menus
  • menu contextuel (Utilisation du menu contextuel du concepteur de menus)
  • ouverture (Ouverture du concepteur de menus)
• Concepteur visuel Rave (Concepteur visuel Rave)
• concept_map
  • mots clés, C++ (Concept map)
• configurations
  • vue globale (Présentation des configurations de construction)
• Configurations
  • création et modification (Création et modification de configurations de construction)
• Configurations de construction
  • activation (Activation d'une configuration de construction pour un projet)
• configurations de construction (C++) (Présentation des en-têtes précompilés)
• connecteur
  • création (Création d'un connecteur)
• connexions
  • ADO (Connexion à des stockages de données ADO)
  • asynchrones (Connexions asynchrones)
  • dépassement de délais (Contrôle des dépassements de délais)
  • nécessitant (Configuration des pages nécessitant des connexions)
• connexions ADO
  • événements (Evénements connexion ADO)
• connexions bloquantes (Connexions bloquantes)
• connexions client (Connexions client)
• connexions de bases de données
  • déconnexion (Fermeture des connexions de bases de données)
  • fermeture (Interruption des connexions de bases de données inactives)
  • gestion (Gestion des connexions de bases de données)
  • ouverture (Ouverture de connexions de bases de données)
• connexions d'écoute (Connexions d'écoute)
• connexions distantes
  • courtage (Courtage de connexions)
  • gestion (Gestion des connexions serveur)
  • utilisation de DCOM (Spécification d'une connexion à l'aide de DCOM)
  • utilisation de HTTP (Spécification d'une connexion à l'aide de HTTP)
  • utilisation de SOAP (Spécification d'une connexion à l'aide de SOAP)
  • utilisation de TCP/IP (Spécification d'une connexion à l'aide de sockets)
• Connexions non bloquantes (Connexions non bloquantes)
• connexions persistantes (Spécification du comportement de la connexion de base de données par défaut)
• connexions serveur (Connexions serveur)
• conseils d'aide
  • aide (Propriétés d'aide ou de conseil d'aide)
• conseils développables (Utilisation des conseils durant le débogage)
• const
  • mots clés, C++ (Const)
• constantes
  • éléments lexicaux, C++ (Constantes)
  • types de données (Constantes déclarées)
• constantes, caractère
  • éléments lexicaux, C++ (Constantes caractère)
• constantes, caractère large
  • éléments lexicaux, C++ (Constantes à caractères larges et à caractères multiples)
• constantes, chaîne
  • éléments lexicaux, C++ (Constantes chaîne)
• constantes, entières
  • éléments lexicaux, C++ (Constantes entières)
• constantes, énumération
  • éléments lexicaux, C++ (Constantes énumération)
• constantes, représentation interne
  • éléments lexicaux, C++ (Constantes et représentation interne)
  • éléments lexicaux, C++ (Représentation interne des types numériques)
• constantes, virgule flottante
  • éléments lexicaux, C++ (Constantes en virgule flottante)
• const_cast, opérateur de transtypage
  • transtypage, C++ (Const cast (opérateur de transtypage))
• constexpr
  • mots clés, C++ (Constexpr)
• constructeurs
  • redéfinition (Redéfinition du constructeur)
  • spécificités du langage C++ (Constructeurs)
  • spécificités du langage C++ (Introduction aux constructeurs et destructeurs)
• constructeurs, copie
  • spécificités du langage C++ (Constructeur de copie)
• constructeurs, implicites
  • spécificités du langage C++ (Constructeur implicite)
• constructeurs, ordre d'appel
  • spécificités du langage C++ (Ordre d'appel des constructeurs)
• constructeurs, surcharge
  • spécificités du langage C++ (Surcharge des constructeurs)
• constructor
  • déclaration (Déclaration d'un nouveau constructeur (C++))
• conteneurs OLE
  • liaison et incorporation d'objets (Création de clients pour les serveurs n'ayant pas une bibliothèque de types)
• continuation d'une ligne (Utilisation de la barre oblique inversée de poursuite de ligne)
• continue
  • mots clés, C++ (Continue)
• contrainte d'objet OCL
  • création (Création d'une contrainte OCL)
• contraintes
  • champs (Utilisation de contraintes)
  • ensembles de données client (Gestion des contraintes liées au serveur)
  • intégrité des données (Gestion des contraintes du serveur)
  • personnalisées (Création d'une contrainte personnalisée)
  • serveur (Utilisation des contraintes du serveur)
• contrôle de source
  • principes (Utilisation du contrôle de source)
• contrôle des programmes (Contrôle des programmes)
• contrôles
  • classes ancêtres (Modification de contrôles existants)
  • contrôles graphiques (Création de contrôles graphiques)
  • contrôles haut-bas (Contrôles flèches haut-bas)
  • fenêtrés (Création de contrôles originaux)
  • orientés données (Contrôles orientés données)
  • orientés données (Fonctionnalités communes des contrôles de données)
  • sous-classement des contrôles Windows (Sous-classement de contrôles Windows)
• Contrôles ActiveX
  • ajout de propriétés supplémentaires (Ajout de propriétés, méthodes et événements supplémentaires)
  • conception (Conception d'un contrôle ActiveX)
  • connexion à la page de propriétés (Connexion d'une page de propriétés à un contrôle ActiveX)
  • création d'une page de propriétés (Création d'une page de propriétés pour un contrôle ActiveX)
  • déploiement (Déploiement des contrôles ActiveX)
  • description (Contrôles ActiveX)
  • éléments (Eléments d'un contrôle ActiveX)
  • licence (Licences des contrôles ActiveX)
  • personnalisation (Personnalisation de l'interface du contrôle ActiveX)
  • pour le déploiement sur le Web (Génération d'un contrôle ActiveX basé sur une fiche VCL)
• contrôles bouton (Boutons et contrôles similaires)
• contrôles de compartiments
  • consultation (Modification de l'apparence des compartiments)
• contrôles de saisie
  • affichage des données (Affichage et édition de champs dans une zone de saisie)
  • contrôles (Contrôles de saisies spécialisées)
  • contrôles texte (Contrôles de saisie)
• contrôles dessinés par le propriétaire (Dimensionnement des éléments dessinés par le propriétaire)
• contrôles de visualisation de texte
  • contrôles (Contrôles de visualisation de texte)
• contrôles en-têtes (Contrôles en-têtes)
• contrôle séparateur
  • redimensionnement (Contrôles séparateur)
• contrôles fenêtrés
  • ancrage (Transformation d'un contrôle fenêtré en un site d'ancrage)
• contrôles onglets (Contrôles onglets)
• contrôles orientés données
  • affichage des données (Actualisation de l'affichage des données)
  • association à des ensembles de données (Association d'un contrôle de données à un ensemble de données)
  • champs (Affichage, conversion et accès aux valeurs des champs)
  • modification (Activation de l'édition des contrôles lors d'une saisie utilisateur)
  • modification (Edition et mise à jour des données)
• contrôles pages (Contrôles pages)
• Contrôles Ribbon (Ruban)
  • ajout de commandes au ruban (Ajout de commandes au ruban)
  • création d'une application (Création d'une application qui utilise les contrôles ruban)
• contrôles texte (Contrôles texte)
• contrôles texte formaté
  • contrôles mémo (Contrôles mémo et texte formaté)
• contrôles touche d'accès rapide (Contrôles touche d'accès rapide)
• contrôleur Automation
  • interface de répartition (Contrôle d'un serveur Automation en utilisant une interface de répartition)
• contrôleurs Automation
  • écriture (Ecriture de code client basé sur les définitions de la bibliothèque de types)
  • importer une bibliothèque de types (Code généré par l'importation des informations d'une bibliothèque de types)
• conventions d'attribution de nom
  • méthodes (Noms des méthodes)
• conversions
  • chaîne en PChar (Conversions de chaînes en PChar)
  • types chaîne (Mélange et conversion de types chaîne)
• couleur du crayon (Changement de la couleur du crayon)
• couleur du pinceau (Changement de la couleur du pinceau)
• courtiers XML (Utilisation d'un courtier XML)
• crayons (Utilisation des crayons)
• création
  • composant graphique (Création d'un composant graphique)
  • contrôle de modification de données (Création d'un contrôle de modification de données)
  • contrôle pour scruter les données (Création d'un contrôle pour scruter les données)
• Création de jeux d'options (Jeux d'options : Création, Application, Edition et Suppression)
• critères de recherche
  • recherche des données (Utilisation de la méthode Lookup)
  • recherches indexées (Utilisation de la méthode Locate)
• _crotr, _crotl (Crotl, crotr)
• cycle de vie du développement
  • outil, présentation (Présentation de la gestion du cycle de développement)

D

• DataRequest (méthode)
  • ensembles de données client (Communication avec des fournisseurs à l'aide d'événements personnalisés)
• DBCtrlGrid (composant) (Création d'une grille qui contient d'autres contrôles orientés données)
• dbExpress
  • débogage (Débogage d'applications dbExpress)
• DBGrid (composant)
  • DBGridColumns (composant) (Visualisation et édition des données avec un contrôle TDBGrid)
• DCC32.EXE
  • compilation C++ (DCC32.EXE, le compilateur en ligne de commande Delphi.)
• DCOM
  • avantages (Utilisation de connexions DCOM)
• débogage
  • ajouter un point de suivi (Ajout d'un point de suivi)
  • applications distantes (Installation, démarrage et arrêt du serveur de débogage distant)
  • applications distantes (Métaprocédure pour le débogage d'applications distantes)
  • inspection des éléments de données (Inspection et modification de la valeur d'éléments de données)
  • liaison avec un processus (Liaison avec un processus en cours d'exécution)
  • modification des expressions (Modification d'expressions variables)
  • points d'arrêt (Définition et modification de points d'arrêt)
  • préparation (Préparation d'un projet pour le débogage)
  • présentation (Parcours de la chaîne d'attente)
  • présentation (Présentation du débogage)
• Débogueur d'applications Web (Utilisation du débogueur d'application Web)
• déclaration des méthodes
  • méthodes (Déclaration des méthodes)
• déclaration de types
  • types de données (Déclaration de types)
• déclaration de types de composants
  • dérivation de classes (Déclaration d'une nouvelle classe de composant)
• déclaration d'une variable et d'un champ
  • type initial (Présentation des concepts de déclaration des variables et des champs (Delphi))
• déclarations
  • structure du langage C++ (Déclarations possibles)
• déclarations, espaces de nommage
  • espaces de nommage, C++ (Déclaration d'un espace de nommage)
• déclarations et instructions
  • directives du compilateur,, delphi (Déclarations et instructions)
• déclarations, externes
  • structure du langage C++ (Définitions et déclarations externes)
• déclarations, incomplètes
  • structure du langage C++ (Déclarations incomplètes)
• __declspec,
  • mots clés, C++ (Declspec)
• __declspec, dllexport
  • mots clés, C++ (Declspec(dllexport))
• __declspec, dllimport
  • mots clés, C++ (Declspec(dllimport))
• __declspec, naked
  • mots clés, C++ (Declspec(naked))
• __declspec, noreturndeclspec, noreturn
  • mots clés, C++ (Declspec(noreturn))
• __declspec, nothrow
  • mots clés, C++ (Declspec(nothrow))
• __declspec, novtable
  • mots clés, C++ (Declspec(novtable))
• __declspec, property
  • mots clés, C++ (Declspec(property))
• __declspec, selectany
  • mots clés, C++ (Declspec(selectany))
• __declspec, thread
  • mots clés, C++ (Declspec(thread))
• __declspec, uuid
  • mots clés, C++ (Declspec(uuid("ComObjectGUID")))
• decltype
  • mots clés, C++ (Decltype)
• default
  • mots clés, C++ (Default)
• #define (Define)
• defined (Defined)
• définition
  • espaces de nommage, C++ (Définition d'un espace de nommage)
• définitions
  • structure du langage C++ (Définitions facultatives)
• delete
  • spécificités du langage C++ (Delete)
• déplacement
  • suivi (Suivi des déplacements)
• déplacement de la souris
  • réponse (Réponse au déplacement de la souris)
• déploiement
  • présentation (Déploiement des applications : vue globale)
• déploiement d'applications de bases de données dbExpress
  • déploiement (Déploiement d'applications BDE)
  • déploiement (Déploiement d'applications de bases de données dbExpress)
• dérivation de classes
  • éditeurs de propriété (Dérivation d'une classe éditeur de propriétés)
• des procédures et des fonctions
  • des procédures et des fonctions (Procédures et fonctions)
• dessin
  • lignes droites (Dessin de lignes droites dans une application Fiches VCL)
  • polygones (Dessin d'un polygone dans une application Fiches VCL)
  • rectangles à coins arrondis (Dessin d'un rectangle arrondi dans une application Fiches VCL)
  • rectangles et ellipses (Dessin de rectangles et d'ellipses dans une application Fiches VCL)
• dessin de formes (Dessin de formes (Code))
• dessin de ligne (Dessin de lignes)
  • amélioration (Amélioration du dessin des lignes)
• dessin de lignes et de polylignes (Dessin de lignes et de polylignes)
• dessin de rectangle (Dessin de rectangles et d'ellipses)
• dessin d'objets (Gestion de plusieurs objets de dessin dans votre application)
• destructeurs
  • spécificités du langage C++ (Destructeurs)
• destructeurs, directives et
  • spécificités du langage C++ (Abort et les destructeurs)
  • spécificités du langage C++ (Atexit, pragma Exit et les destructeurs)
  • spécificités du langage C++ (Exit et les destructeurs)
• destructeurs, invocation
  • spécificités du langage C++ (Appel des destructeurs)
• destructeurs virtuels
  • spécificités du langage C++ (Destructeurs virtuels)
• diagram layout options
  • general group (Modélisation - Options de disposition des diagrammes)
• diagramme
  • renommage (Renommer un diagramme)
• diagramme d'activités
  • exemple (Projet exemple UML 2.0, Package Behavior)
• diagramme de classes
  • exemple (Projet exemple UML 2.0, Package Structure)
• diagramme d'interaction
  • lien de retour (Utilisation d'un message UML 1.5)
• Dictionnaire de données
  • attributs des champs (Création des ensembles d'attributs pour les composants champ)
• dictionnaire de données
  • attributs des champs (Dictionnaire de données)
• directive nulle ((directive null))
• directives du compilateur
  • chaînes (Directives de compilation portant sur les chaînes)
• directives du préprocesseur cpp32 (Directives du préprocesseur - Index)
• Directives pour MAKE (Directives MAKE)
• dispid
  • mots clés, C++ (Dispid)
• disposition
  • mise en place (Disposition automatique d'un diagramme)
• Dispositions du bureau
  • enregistrement des dispositions du bureau (Enregistrement des dispositions du bureau)
• division
  • opérateurs, C++ (Opérateurs de multiplication)
• DLL
  • bibliothèques de liens dynamiques, utilisation (Utilisation des DLL dans RAD Studio (C++))
  • création (Création de DLL contenant des composants VCL (C++))
  • emplacements (Emplacements des DLL)
  • lier (Liaison de DLL)
• do
  • mots clés, C++ (Do)
• documents Active (Documents Active)
• documents HTML
  • bases de données et (Utilisation des bases de données dans les réponses)
• documents XML
  • composants (Utilisation des composants XML)
  • conversion en paquets de données (Conversion de documents XML en paquets de données)
  • paquets de données (Correspondance entre les noeuds XML et les champs du paquet de données)
• Document XML
  • utilisation de l'expert Liaison de données (Utilisation du code généré par l'expert Liaison de données XML)
• DOM
  • Document Object Model (Utilisation du modèle DOM)
• données
  • affichage (Affichage de valeurs dans les contrôles standard)
  • analyse (Analyse des données)
• -D, option du compilateur (Utilisation des options de ligne de commande -D et -U)
• Dossiers virtuels (Utilisation des dossiers virtuels)
• double
  • mots clés, C++ (Double)
  • mots clés, C++ (Long)
• durée
  • structure du langage C++ (Durée)
• dynamic_cast, opérateur de transtypage
  • transtypage, C++ (Dynamic cast (opérateur de transtypage))

E

• E1008 Integer et HRESULT échangés (Delphi) (X1008 Integer et HRESULT échangés (Delphi))
• E1012 L'expression constante dépasse les limites de sous-étendue (Delphi) (X1012 L'expression constante dépasse les limites de sous-étendue (Delphi))
• E1019 La variable de contrôle de boucle FOR doit être une variable locale simple (Delphi) (X1019 La variable de contrôle de boucle FOR doit être une variable locale simple (Delphi))
• E1020 Construction d'instance de '%s' contenant des méthodes abstraites '%s.%s' (Delphi) (X1020 Construction d'instance de '%s' contenant des méthodes abstraites '%s.%s' (Delphi))
• E1025 Fonctionnalité de langage non supportée : '%s' (Delphi) (X1025 Fonctionnalité de langage non supportée : '%s' (Delphi))
• E1026 Fichier introuvable : '%s' (Delphi) (X1026 Fichier introuvable : '%s' (Delphi))
• E1028 Définition de symbole global incorrecte : '%s' dans le fichier objet '%s' (Delphi) (X1028 Définition de symbole global incorrecte : '%s' dans le fichier objet '%s' (Delphi))
• E1030 Directive de compilation incorrecte : '%s' (Delphi) (X1030 Directive de compilation incorrecte : '%s' (Delphi))
• E1033 L'unité '%s' a été importée implicitement dans le package '%s' (Delphi) (X1033 L'unité '%s' a été importée implicitement dans le package '%s' (Delphi))
• E1054 Erreur du lieur : %s (Delphi) (X1054 Erreur du lieur : %s (Delphi))
• E1056 Ressource dupliquée Type %s, ID %s ; Ressource %s de fichier conservée ; Ressource %s de fichier ignorée (Delphi) (X1056 Ressource dupliquée Type %s, ID %s ; Ressource %s de fichier conservée ; Ressource %s de fichier ignorée (Delphi))
• E2041 Erreur de lecture dans '%s' (Delphi) (X2041 Erreur de lecture dans '%s' (Delphi))
• E2042 Erreur d'écriture sur '%s' (Delphi) (X2042 Erreur d'écriture sur '%s' (Delphi))
• E2043 Erreur de fermeture sur '%s' (Delphi) (X2043 Erreur de fermeture sur '%s' (Delphi))
• E2044 Erreur Chmod dans '%s' (Delphi) (X2044 Erreur Chmod dans '%s' (Delphi))
• E2141 Format de fichier incorrect: '%s' (Delphi) (X2141 Format de fichier incorrect: '%s' (Delphi))
• E2243 L'expression ne nécessite pas de Initialize/Finalize (Delphi) (X2243 L'expression ne nécessite pas de Initialize/Finalize (Delphi))
• E2269 La méthode virtuelle redéfinie '%s.%s' a une visibilité inférieure (%s) que la classe de base '%s' (%s) (Delphi) (X2269 La méthode virtuelle redéfinie '%s.%s' a une visibilité inférieure (%s) que la classe de base '%s' (%s) (Delphi))
• E2367 La casse de la méthode de l'accesseur de propriété %s.%s devrait être %s.%s (Delphi) (X2367 La casse de la méthode de l'accesseur de propriété %s.%s devrait être %s.%s (Delphi))
• Eof
  • Eof (C++) (Eof)
  • Utilisation des propriétés Eof et Bof (Utilisation des propriétés Eof et Bof)
• ECO Framework (Importation et exportation d'un modèle avec XMI (XML Metadata Interchange))
• écriture des composants (Modification d'un composant existant : Vue globale)
  • ajout de fonctionnalités graphiques (Ajout de fonctionnalités graphiques)
  • contrôle des accès (Contrôle des accès)
  • dessin de l'image du composant (Dessin de l'image du composant)
  • fonctionnement du contrôle en lecture seulement (Fonctionnement du contrôle en lecture seulement)
  • fourniture d'un événement OnChange (Fourniture d'un événement OnChange)
  • masquer les détails d'implémentation (Masquer les détails d'implémentation)
  • propriétés (Publication des propriétés héritées)
  • publication des propriétés héritées (Publication des propriétés héritées (Graphique))
  • valeurs de propriété par défaut (Spécification de la nouvelle valeur par défaut de la propriété)
• EDI
  • ajout d'actions (Ajout d'une action à la liste d'actions)
  • ajout d'images (Ajout d'une image à la liste d'images)
  • extension (Extensions de l'EDI)
  • réponse aux événements de l'EDI (Notification d'un expert des événements de l'EDI)
  • suppression de boutons de barres d'outils (Suppression de boutons de barres d'outils)
• éditeur d'action
  • éléments d'action (Ajout d'actions au répartiteur)
• Editeur de balise HTML
  • modification des balises HTML (Utilisation de l'éditeur de balise HTML)
• Editeur de bibliothèque de types (Editeur de bibliothèques de types)
  • barre d'état (Barre d'état)
  • description (Composants de l'éditeur de bibliothèque de types)
  • fichier RIDL (Fichier RIDL)
  • GenTLB.exe (GenTLB.exe)
  • pages d'informations (Eléments de la bibliothèque de types)
  • pages d'informations (Pages d'informations de type)
  • types supportés (Types autorisés)
  • Volet liste des objets (Volet liste des objets)
• Editeur de code
  • personnalisation (Personnalisation de l'éditeur de code)
• éditeur de méthodes de saisie
  • IME (Fonctionnalités spécifiques aux cibles locales)
• éditeur de page web (Utilisation de l'éditeur de pages Web)
• éditeurs de composants
  • création (Ajout d'éditeurs de composants)
  • double-clics (Modification du comportement suite à un double-clic)
  • formats de presse-papiers (Ajout de formats de presse-papiers)
  • menus contextuels (Ajout d'éléments au menu contextuel)
  • recensement (Recensement d'un éditeur de composants)
• éditeurs de propriété (Utilisation des éditeurs de propriétés)
  • création (Ajout d'éditeurs de propriétés)
• élément de modèle
  • masquage et affichage (Affichage et masquage des éléments de modèle)
• éléments d'action (Eléments d'action)
  • activation (Activation et désactivation des éléments d'action)
  • par défaut (Choix d'un élément d'action par défaut)
  • propriétés (Choix du déclenchement des éléments d'action)
  • requêtes HTTP (Réponse aux messages de requête avec des éléments d'action)
• éléments de menu
  • désactivation (Désactivation des éléments de menu)
• éléments lexicaux
  • éléments lexicaux, C++ (Eléments lexicaux)
• éléments Web
  • propriétés (Définition des propriétés des éléments Web)
• enregistrements
  • actualisation (Actualisation des enregistrements)
  • ajout (Ajout de nouveaux enregistrements)
  • avancés (Types structurés)
  • filtres (Affichage et édition d'ensembles de données en utilisant des filtres)
  • marquage (Marquage d'enregistrements)
  • mise à jour (Mise à jour des enregistrements)
  • modification (Modification d'enregistrements entiers)
  • navigation dans les (Navigation dans les ensembles de données)
  • navigation dans les (Navigation parmi les enregistrements d'un ensemble de données filtré)
  • navigation et manipulation (Navigation et manipulation d'enregistrements)
  • parcourir (Utilisation des propriétés Eof et Bof)
  • recherche (Recherche dans les ensembles de données)
  • spécification de portées (Spécification de portées)
  • suppression (Suppression d'enregistrements)
  • traditionnels (Types structurés)
  • validation (Validation des données)
• ensembles
  • utilisation (Utilisation d'un ensemble d'audits)
  • utilisation (Utilisation d'un ensemble de métriques)
• ensembles de données
  • association aux bases de données (Association d'un ensemble de données avec les connexions de bases de données et de sessions)
  • BDE (Utilisation d'ensembles de données BDE)
  • composant Dataset (Présentation des ensembles de données : Vue globale)
  • états (Détermination des états d'un ensemble de données)
  • mise à jour (Mise à jour de l'ensemble de données)
  • mises à jour placées en mémoire cache (Application des mises à jour en mémoire cache avec les méthodes de composant base de données)
  • ouverture (Ouverture et fermeture des ensembles de données)
  • procédures stockées (Utilisation d'ensembles de données de type procédure stockée)
  • représentation HTML (Utilisation des générateurs de page ensemble de données)
  • représentation HTML (Utilisation des générateurs de tableau)
  • requêtes (Spécification de la requête)
  • requêtes (Utilisation d'ensembles de données de type requête)
  • résolution (Détermination du mode d'application des mises à jour à l'aide d'un fournisseur d'ensemble de données)
  • tables (Utilisation d'ensembles de données de type table)
  • types (Types d'ensembles de données)
  • types (Utilisation des descendants de TDataSet)
  • unidirectionnels (Types d'ensembles de données dbExpress)
• ensembles de données ADO (Utilisation de TADODataSet)
• ensembles de données client (Utilisation d'ensembles de données client : Vue globale)
  • agrégats maintenus (Obtention de valeurs d'agrégat)
  • agrégats maintenus (Spécification d'agrégats)
  • agrégats maintenus (Utilisation des agrégats maintenus)
  • ajout d'index (Ajout d'un nouvel index)
  • annulation des modifications (Annuler les modifications)
  • applications à base de fichiers (Utilisation d'un ensemble de données client avec des données basées sur des fichiers)
  • architecture (Connexion d'un ensemble de données client à un autre ensemble de données dans la même application)
  • avec ensemble de données source interne (Utilisation d'un ensemble de données simple)
  • champs calculés de façon interne (Utilisation de champs calculés de façon interne dans les ensembles de données client)
  • contraintes (Définition de contraintes pour les valeurs des données)
  • copie des données (Affectation directe des données)
  • copie des données (Copie de données d'un autre ensemble de données)
  • création (Création d'un nouvel ensemble de données)
  • enregistrement des modifications (Enregistrement des modifications)
  • fournisseurs (Connexion à un autre ensemble de données)
  • fournisseurs (Spécification d'un fournisseur)
  • limitation des enregistrements dans les paquets de données (Limitation des enregistrements avec des paramètres)
  • manipulation des données (Manipulation des données avec un ensemble de données client)
  • mises à jour placées en mémoire cache (Présentation de l'utilisation d'un cache pour les mises à jour)
  • mises à jour placées en mémoire cache (Utilisation d'un ensemble de données client pour mettre en cache les mises à jour)
  • modification (Edition des données)
  • navigation dans les (Navigation parmi les données des ensembles de données client)
  • paquets de données (Extraction des données dans l'ensemble de données ou le document source)
  • paramètres (Transmission de paramètres à l'ensemble de données source)
  • paramètres de requêtes (Envoi de paramètres de requête ou de procédure stockée)
  • paramètres optionnels (Ajout d'informations d'application aux données)
  • partage de données (Clonage d'un curseur d'ensemble de données client)
  • regroupement de données (Utilisation des index pour regrouper les données)
  • suppression d'index (Suppression et permutation d'index)
  • tri et indexation (Tri et indexation)
  • types (Choix du type d'ensemble de données pour les mises à jour en cache)
  • types (Indication des enregistrements modifiés)
  • utilisation des fournisseurs (Utilisation d'un ensemble de données client avec un fournisseur)
  • valeurs calculées (Représentation des valeurs calculées)
• ensembles de données unidirectionnels
  • accès aux métadonnées (La structure des ensembles de métadonnées)
  • définition d'ensembles d'enregistrements (Spécification des données à afficher)
  • définition des requêtes (Représentation des résultats d'une requête)
  • ensembles de données (Utilisation des ensembles de données dbExpress)
  • exécution des commandes SQL (Exécution de la commande)
  • ouverture (Récupération des données)
  • procédures stockées (Représentation des résultats d'une procédure stockée)
  • représentation des tables (Représentation des enregistrements d'une table)
• en-têtes
  • HTTP (En-tête de message de requête HTTP)
  • SOAP (Définition et utilisation des en-têtes SOAP)
  • SOAP (Traitement des en-têtes dans les applications client)
• enum
  • mots clés, C++ (Enum)
• enum, affectation
  • structure du langage C++ (Affectation aux types enum)
• énumérations
  • structure du langage C++ (Enumérations)
• enveloppes de composants
  • COM (Utilisation des composants enveloppe)
• environnements hôtes
  • programmation (Programmation pour des environnements hôtes hétérogènes)
• envoi des messages
  • présentation (Envoi des messages)
• épaisseur du crayon (Changement de l'épaisseur du crayon)
• ERC.EXE (RC.EXE, le compilateur de ressources Microsoft SDK)
• erreurs de mise à jour
  • conciliation (Conciliation des erreurs de mise à jour)
• Erreurs d'E/S (Erreurs d'E/S)
• erreurs d'exécution (Erreurs d'exécution Delphi)
• erreurs du système d'exploitation (Erreurs du système d'exploitation)
• erreurs fatales (Erreurs fatales)
• erreurs internes
  • résolution (C++) (Résolution des erreurs internes (C++))
  • résolution (Delphi) (Résolution des erreurs internes (Delphi))
• #error (Error)
• espaces de nommage
  • programmes et unités (Utilisation des espaces de nommage avec Delphi)
• espaces de nommage anonymes
  • espaces de nommage, C++ (Espaces de nommage anonymes)
• espaces de nommage, présentation
  • spécificités du langage C++ (Namespace)
• état
  • imbriqué (Utilisation d'un état complexe)
• états
  • Rave Reports (Utilisation de Rave Reports dans RAD Studio)
• événements (Qu'est-ce qu'un événement ?)
  • classes et objets (Evénements)
  • contrôleurs Automation (Gestion des événements dans un contrôleur Automation)
  • création (Création d'événements : Vue globale)
  • déclenchement des événements (Déclenchement de l'événement)
  • événements définis par l'utilisateur (Définition de vos propres événements)
  • gestion (Affichage et codage des événements partagés)
  • gestion (Association d'un événement à un gestionnaire d'événement existant)
  • gestion (Génération d'un nouveau gestionnaire d'événement)
  • gestion (Recherche de gestionnaires d'événements)
  • gestion (Utilisation des événements et des gestionnaires d'événements)
  • gestion (Utilisation du paramètre Sender)
  • menu (Association d'événements de menu à des gestionnaires d'événements)
  • OnUpdateRecord (Création d'un gestionnaire d'événement OnUpdateRecord)
  • par défaut (Génération du gestionnaire de l'événement par défaut d'un composant)
  • types (Types d'événements)
• événements de souris
  • contrôles de données (Activation des événements souris, clavier et timer)
  • paramètres (Définition d'un événement de souris)
• événements standard
  • événements (Implémentation des événements standard)
• __except
  • mots clés, C++ (Except)
• exceptions
  • blocs finally (Ecriture de blocs finally)
  • blocs try (Ecriture du bloc try)
  • classes et objets (Exceptions)
  • déclenchement (Déclenchement d'une exception)
  • déclenchement (Déclenchement d'une exception (C++))
  • gestionnaires (Ecriture de gestionnaires d'exceptions)
  • silencieuses (Exceptions silencieuses)
• exceptions, déroulement (Déroulement des exceptions(C++))
• exemple techniques de dessin (Techniques de dessin dans une application)
• expert d'application SOAP
  • utilisation (Utilisation de l'expert d'application SOAP)
• expert Page propriétés
  • création d'une nouvelle page de propriétés (Création d'une nouvelle page de propriétés)
• experts
  • débogage (Débogage d'un expert)
  • écriture (Conception d'une classe expert)
  • implémentation (Implémentation des interfaces de l'expert)
  • installation (Installation du package de l'expert)
  • utilisation des fichiers et des éditeurs (Utilisation des fichiers et des éditeurs)
• Experts COM (Utilisation des experts COM)
• explicit
  • mots clés, C++ (Explicit)
• Explorateur de données
  • exécution de SQL (Exécution SQL dans l'explorateur de données)
  • modification des connexions (Modification des connexions dans l'explorateur de données)
• Explorateur de métadonnées d'assemblage (Explorateur de métadonnées d'assemblage (visualiseur de réflexion))
• Explorateur de métadonnées d'assemblage (Exploration de bibliothèques de types Windows)
• exploration d'une base de données
  • explorer les objets (Exploration d'une base de données dans l'explorateur de données)
  • explorer les objets (Utilisation de l'explorateur de données pour obtenir des informations de connexion)
• _export
  • mots clés, C++ (Export, export)
• export,
  • mots clés, C++ (Export)
• expressions
  • expressions (Expressions (Delphi))
  • structure du langage C++ (Expressions)
  • structure du langage C++ (Expressions et C++)
• expressions assembleur
  • assembleur en ligne (Expressions assembleur (Win32 uniquement))
• expressions constantes
  • éléments lexicaux, C++ (Expressions constantes)
• expressions, erreurs
  • structure du langage C++ (Erreurs et débordements)
• expressions, ordre d'évaluation
  • structure du langage C++ (Ordre d'évaluation)
• extension
  • espaces de nommage, C++ (Extension d'un espace de nommage)
• Extensions de COM (Extensions de COM)
• extern
  • mots clés, C++ (Extern)
• extraction d'une méthode
  • refactoring (Présentation de l'extraction d'une méthode (Delphi))

F

• fabricants de classes
  • objets COM (CoClasses et factories de classes)
• _fastcall
  • mots clés, C++ (Fastcall, fastcall)
  • mots clés, C++ (Final)
  • mots clés, C++ (Noreturn)
• fiche principale
  • masquer (Dissimulation de la fiche principale)
• fiches
  • affichage des fiches créées automatiquement (Affichage d'une fiche créée automatiquement)
  • ajout (Ajout de fiches)
  • création (Utilisation des fiches)
  • création de fiches non modales (Création de fiches non modales comme fenêtres)
  • création dynamique (Création dynamique de fiches)
  • disposition (Gestion de la disposition)
  • gestion de la mémoire (Contrôle du stockage en mémoire des fiches)
  • récupération des données depuis (Récupération des données des fiches)
  • récupération des données depuis (Récupération des données des fiches non modales)
  • récupération des données des fiches modales (Récupération des données des fiches modales)
  • transfert de paramètres supplémentaires (Transfert de paramètres supplémentaires aux fiches)
  • utilisation de variables locales pour créer une instance (Création d'une instance de fiche en utilisant une variable locale)
• Fiches actives
  • applications client (Création d'une fiche active pour l'application client)
• Fiches VCL
  • applications de bases de données (Conception d'une application Fiches VCL de base de données ADO)
  • Applications MDI (Construction d'une application MDI Fiches VCL à l'aide d'un expert)
  • Applications MDI (Construction d'une application MDI Fiches VCL sans utiliser d'expert)
  • applications multithreads (Construction d'une application multithread)
  • Applications SDI (Construction d'une application SDI Fiches VCL)
  • boutons ActiveX (Création d'un bouton ActiveX Fiches VCL)
  • composants (Création d'un nouveau composant VCL)
  • Composants XML (Construction d'une application avec des composants XML)
  • fiches actives ActiveX (Création d'une fiche active VCL ActiveX)
• fichiers (Utilisation des fichiers)
  • copie (Copie d'un fichier)
  • lecture et écriture (Approches des E/S fichier)
  • manipulation (Manipulation de fichiers)
  • recherche (Recherche d'un fichier)
  • routines date-heure (Routines date-heure de fichier)
  • suppression (Suppression d'un fichier)
  • TFileStream (Utilisation de flux de fichier)
• fichiers{}
  • renommer (Modification d'un nom de fichier)
• fichiers cibles (Fichiers cibles)
• Fichiers d'aide des composants (Création du fichier d'aide)
• Fichiers de définition de module (Fichiers de définition de module)
• fichiers de l'application
  • extensions de noms de fichiers (Les fichiers de l'application, par extension de fichier)
  • identification (Identification des fichiers de l'application)
• fichiers de transformation
  • mappeur XML (Définition des transformations)
• Fichiers d'inclusion (C++) (Utilisation des fichiers d'inclusion)
• Fichiers en-tête précompilés (Fichiers en-tête précompilés)
• fichiers exécutables
  • internationalisation (Basculement dynamique de DLL de ressource)
  • internationalisation (Utilisation des DLL de ressource)
• fichiers graphiques
  • chargement et enregistrement (Chargement et enregistrement de fichiers graphiques)
• fichiers linéaires
  • chargement (Chargement des données depuis un fichier ou un flux)
  • enregistrement (Sauvegarde des données dans un fichier ou un flux)
• fichiers ressource
  • menus (Importation de fichiers ressource)
• filters
  • member (Modélisation - Options de filtres d'affichage des diagrammes)
• filtres
  • basés sur les signets (Filtrage d'enregistrements à partir de signets)
  • ensembles de données client (Limitation des enregistrements affichés)
  • portées (Présentation des différences entre les portées et les filtres)
  • spécification (Définition de la propriété Filter)
  • spécification (Ecriture d'un gestionnaire d'événement OnFilterRecord)
• __finally,
  • mots clés, C++ (Finally)
• __finally, mot clé (Ecriture d'un bloc finally (C++))
• float
  • mots clés, C++ (Float)
• flux (Utilisation des flux)
  • copie des données (Copier de données d'un flux vers un autre)
  • lecture et écriture de données (Utilisation des flux pour lire ou écrire des données)
  • position (Spécification de la position et de la taille du flux)
• fonctionnalités C++0x
  • Attributs C++0x (Attributs C++0x))
  • Attribut C++0x deprecated (Attribut C++0x deprecated)
  • Attribut C++0x final (Attribut C++0x final)
  • Attribut C++0x noreturn (Attribut C++0x noreturn)
  • énumérations fortement typées (Enumérations fortement typées (C++0x))
  • fonctions trait de type (Présentation des fonctions trait de type (C++0x))
  • opérateur alignof (Assertions statiques (C++0x))
  • opérateur alignof (Déclaration forward des énumérations (C++0x))
  • opérateur alignof (Méthodes anonymes)
  • opérateur alignof (Spécificateur de type decltype (C++0x))
  • opérateur alignof (Littéraux et types de caractères Unicode (C++0x))
  • opérateur alignof (Opérateur alignof (C++0x))
  • opérateur alignof (Références rvalue (C++0x))
  • opérateur alignof (Templates extern (C++0x))
  • Opérateurs de conversion explicite (C++0x) (Opérateurs de conversion explicite (C++0x))
• fonctions
  • conversion (Utilisation d'une classe pour gérer les conversions)
  • conversion (Utilisation d'une fonction de conversion)
  • structure du langage C++ (Définitions)
• fonctions, déclarations
  • structure du langage C++ (Déclarations et définitions)
  • structure du langage C++ (Déclarations et prototypes)
• fonctions dynamiques
  • spécificités du langage C++ (Fonctions dynamiques)
• fonctions inline
  • spécificités du langage C++ (Fonctions inline)
• fonctions membres
  • spécificités du langage C++ (Fonctions membres)
• fonctions, paramètres
  • structure du langage C++ (Déclarations de paramètres formels)
• fonctions thread
  • Execute (méthode) (Ecriture de la fonction Thread)
• fonctions virtuelles
  • spécificités du langage C++ (Fonctions virtuelles)
• fontes
  • déploiement (Fontes)
• for
  • mots clés, C++ (For)
• formatage des données
  • formats de données (Utilisation des formats par défaut pour les champs numériques, date et heure)
• formats
  • internationalisation (Formats et ordre de tri)
• formats de données
  • affectation (Association des ensembles d'attributs aux composants champ)
• fournisseurs
  • événements personnalisés (Comment répondre aux événements générés par le client)
  • gestion des erreurs (Résolution des erreurs de mise à jour par le fournisseur)
  • mise à jour de données (Comment répondre aux demandes de mise à jour des clients)
  • récupération des données (Spécification de la source de données)
  • XML (Utilisation d'un document XML comme source pour un fournisseur)
• fragment combiné (Opérateur et opérande pour un fragment combiné)
• friend
  • mots clés, C++ (Friend)

G

• générateurs de page
  • chaînage (Chaînage de générateurs de page)
• générateurs de page InternetExpress
  • modèles (Personnalisation du modèle d'un générateur de page InternetExpress)
  • pages Web (Création de pages Web avec un générateur de page InternetExpress)
• génération de la documentation (Fonctionnalité de génération de la documentation)
• Génériques (Génériques - Index)
  • changements apportés à la grammaire et aux fonctions (Changements apportés à la grammaire et aux fonctions standard)
  • contraintes (Contraintes dans les génériques)
  • gestion C++ (Comment gérer les génériques Delphi dans C++)
  • terminologie (Terminologie des génériques)
  • types procéduraux (Déclaration des génériques)
  • vue globale (Présentation des génériques)
• GenTLB.exe
  • compilateur de bibliothèque de types (Fenêtre de l'éditeur de bibliothèques de types)
• gestion de la mémoire
  • Delphi pour Win32 (Gestion de la mémoire sous Win32)
  • objets interfacés (Gestion mémoire des objets interface)
  • objets interfacés (Situations où il ne faut pas utiliser le comptage de références)
  • objets interfacés (Utilisation du comptage de références)
• gestion des exceptions
  • constructeurs (Constructeurs dans la gestion d'exceptions (C++))
  • exceptions (Définition des blocs protégés)
  • exceptions (Gestion des exceptions)
  • options du compilateur (Options de gestion des exceptions (C++))
  • pointeurs sécurisés (Pointeurs intelligents (C++))
  • VCL (Gestion des exceptions dans les applications VCL)
  • VCL (Gestion des exceptions par défaut dans la VCL)
• Gestionnaire de configurations de construction
  • Gestionnaire de configurations (Utilisation des fichiers cibles)
• Gestionnaire de l'historique (Utilisation du gestionnaire de l'historique)
• Gestionnaire d'événement
  • Définition du type de gestionnaire (Définition du type de gestionnaire)
• gestionnaires de messages
  • création (Création de nouveaux gestionnaires de messages)
  • messages Windows (Modification de la gestion des messages)
  • paramètres (Utilisation des paramètres d'un message)
  • redéfinition des gestionnaires de messages (Redéfinition de la méthode Handler)
• gestionnaires d'événements
  • déclaration des événements (Appel de l'événement)
  • événements (Changement de la gestion des événements standard)
  • suppression (Suppression de gestionnaires d'événements)
• gestionnaires d'exceptions
  • mot clé (Instructions de gestion des exceptions)
  • portée (Portée des gestionnaires d'exceptions)
  • redéclenchement (Redéclenchement d'exceptions)
• glisser-ancrer
  • ancrage (Contrôle de la réponse des contrôles enfant aux opérations glisser-ancrer)
  • ancrage (Implémentation du glisser-ancrer dans les contrôles)
• glisser-déplacer (Début de l'opération glisser)
• glisser-déplacer (Fin de l'opération glisser-déplacer)
• goto
  • mots clés, C++ (Goto)
• graphe
  • création (Création d'un graphe de métriques)
• graphiques (Présentation de la programmation relative aux graphiques)
  • affichage (Contrôles graphiques)
  • ajout à des contrôles (Ajout de graphiques à des contrôles)
  • applications Fiches VCL (Comment construire une application Fiches VCL avec des graphiques)
  • canevas (Encapsulation des graphiques)
  • coller depuis le Presse-papiers (Coller des graphiques depuis le Presse-papiers)
  • copie dans le Presse-papiers (Copie de graphiques dans le Presse-papiers)
  • couper dans le Presse-papiers (Couper des graphiques dans le Presse-papiers)
  • défilables (Création de graphiques défilables)
  • dessin sur (Dessiner sur un graphique)
  • formes (Formes)
  • internationalisation (Images graphiques)
  • présentation (Utilisation des graphiques et du multimédia : Vue globale)
  • types d'objets (Types des objets graphiques)
  • utilisation du Presse-papiers (Utilisation du presse-papiers avec les graphiques)
• GREP.EXE
  • GREP.EXE (GREP.EXE, l'utilitaire de recherche de texte)
• grilles
  • éditeur de liste de valeurs (Editeurs de liste de valeurs)
  • grilles de chaînes (Grilles de chaînes)
  • grilles de dessin (Grilles de dessin)
  • non base de données (Grilles)
• grilles de données
  • colonnes par défaut (Utilisation d'un contrôle grille à son état par défaut)
  • dessin (Contrôle du dessin de la grille)
  • gestion d'événements (Comment répondre aux actions de l'utilisateur à l'exécution)
  • options d'exécution du composant DBGrid (Définition des options de la grille)
  • personnalisation (Création d'une grille personnalisée)

H

• hello world
  • Fiches VCL (Construction d'une application Fiches VCL "Hello World")
  • Fiches VCL (Copie de données d'un flux vers un autre)
  • Fiches VCL (Lecture d'une chaîne et écriture de cette chaîne dans un fichier)
• héritage
  • objets (Héritage des données et du code d'un objet)
• HTML
  • génération (Utilisation du composant générateur de page)
• HTML, commandes
  • informations de base de données (Représentation HTML d'un ensemble de données)
• HTTP
  • avantages (Utilisation de connexions Web)
  • présentation (Activité d'un serveur HTTP)
  • requêtes (Réponses aux requêtes client)
  • requêtes (Traitement des requêtes client par le serveur)

I

• IAppServer (interface)
  • modules de données distants (Communication avec l'ensemble de données client)
• IBConnection non supporté (Conception d'une application Fiches VCL de base de données dbExpress)
• ide
  • page Bienvenue (Présentation de l'EDI)
  • visuels, composants (Concepteur de fiche)
• identificateurs
  • éléments lexicaux, C++ (Identificateurs)
• identification de type à l'exécution
  • spécificités du langage C++ (Identification de type à l'exécution et destructeurs)
• IDL
  • syntaxe de la bibliothèque de types (Utilisation de la syntaxe Pascal Objet ou IDL)
• #if (If, elif, else et endif)
• if
  • mots clés, C++ (If, else)
• #ifdef (Ifdef et ifndef)
• IInterface (interface)
  • dérivation des interfaces (Implémentation de IInterface)
• ILINK32.EXE (ILINK32.EXE, le lieur incrémentiel)
• image
  • chargement depuis un fichier (Chargement d'une image depuis un fichier)
  • enregistrement dans un fichier (Enregistrement d'une image dans un fichier)
• images
  • affichage (Images)
  • ajout à une application (Ajout d'images à une application)
  • ajout à une liste de chaînes (Ajout d'images à une liste de chaînes)
  • graphiques (Travail sur les images)
  • orientées données (Affichage et édition de champs graphiques dans un contrôle image)
  • remplacement (Remplacement de l'image)
• _Imaginary
  • mots clés, C++ (Imaginary)
• imbrication (Macros avec paramètres)
• IMPDEF.EXE
  • IMPDEF.EXE (IMPDEF.EXE, le gestionnaire de définition de module)
• implémentation des interfaces
  • interfaces (Implémentation des interfaces)
• implémentation de stub
  • utilisation (Utilisation du pattern d'implémentation de stub)
• implements (mot clé)
  • interfaces (Utilisation de implements pour la délégation)
• IMPLIB.EXE (IMPLIB.EXE, l'outil bibliothèque d'importation)
• #import (Import)
• __import
  • mots clés, C++ (Import, import, import)
• #include (Include)
• index
  • affichage des listes (Obtention d'informations sur les index)
  • recherche des enregistrements (Utilisation d'index pour chercher des enregistrements)
  • spécification d'une alternative (Spécification d'un index avec IndexName)
  • tri des enregistrements (Tri des enregistrements avec des index)
• index dBASE
  • spécification (Spécification d'un fichier d'index dBASE)
• initialisation
  • structure du langage C++ (Initialisation)
• initialisation de classe
  • spécificités du langage C++ (Initialisation de classe)
• inline
  • mots clés, C++ (Inline)
• insertion d'images bitmap (Insertion d'une image bitmap dans un contrôle d'une application Fiches VCL)
• instructions
  • structure du langage C++ (Instructions)
• instructions, branchement
  • structure du langage C++ (Instructions de branchement)
• instructions, étiquette
  • structure du langage C++ (Instructions étiquette)
• instructions, expression
  • structure du langage C++ (Instructions d'itération)
  • structure du langage C++ (Instructions expression)
• instructions, sélection
  • structure du langage C++ (Instructions de sélection)
• instructions SQL
  • transparent (Utilisation du SQL transparent)
• instructions try...finally
  • mot clé finally (Ecriture d'un bloc finally (Delphi))
• int
  • mots clés, C++ (Int)
• __int8, __int16, et ainsi de suite
  • éléments lexicaux, C++ (Int8, int16, int32, int64, int64 non signés, types entiers étendus)
• intégrité référentielle
  • procédures stockées (Intégrité référentielle, procédures stockées et déclencheurs)
• interface (Définition des diagrammes de classes UML 2.0)
  • masquer (Utiliser une interface)
  • modification de la notation (Modification de l'apparence des interfaces)
• interface double
  • contrôleur Automation (Contrôle d'un serveur Automation en utilisant une interface double)
  • interfaces (Interfaces doubles)
• interface requise
  • création (Utilisation d'une interface fournie ou d'une interface requise)
• interfaces (Utilisation des interfaces)
  • Automation (Interfaces d'Automation)
  • invocables (Présentation des interfaces invocables)
  • modules de données distants (Extension de l'interface du serveur d'applications)
  • polymorphisme (Utilisation des interfaces au travers de la hiérarchie)
  • propriétés (Création des propriétés pour interfaces)
  • répartition (Interfaces de répartition)
  • réutilisation du code (Réutilisation de code et délégation)
  • TInterfacedObject (TInterfacedObject)
• Interfaces COM
  • Interfaces (Interfaces COM)
  • IUnknown (L'interface COM de base, IUnknown)
  • pointeurs (Pointeurs d'interface COM)
• interfaces d'objets
  • interfaces (Interfaces d'objets)
• interfaces invocables
  • appel (Appel des interfaces invocables)
  • types non scalaires (Recensement des types non scalaires)
  • types non scalaires (Utilisation de types non scalaires dans des interfaces invocables)
• interfaces personnalisées
  • interfaces (Interfaces personnalisées)
• interfaces utilisateur
  • enregistrement unique (Affichage d'un seul enregistrement)
  • internationalisation (Considérations de localisation dans la conception de l'interface utilisateur)
  • IU (Conception de l'interface utilisateur)
  • plusieurs enregistrements (Affichage de plusieurs enregistrements)
• interface utilisateur
  • développement (Conception de l'interface utilisateur des applications : Vue globale)
• Internationalisation (Internationalisation des applications)
• IntraWeb
  • VCL pour le Web (Changement de la VCL pour le type d'application Web)
  • VCL pour le Web (Création d'applications serveur Web avec IntraWeb)
  • VCL pour le Web (Ecriture d'un gestionnaire d'événement pour le bouton)
  • VCL pour le Web (Exécution de l'application achevée)
  • VCL pour le Web (Modification de la fiche principale)
  • VCL pour le Web (Utilisation de IntraWeb avec WebBroker et WebSnap)
• Introduction à IntraWeb
  • VCL pour le Web (Introduction à IntraWeb)
• invariant d'état
  • connexion (Création d'un invariant d'état)
• _itow, itoa (Itoa, itow)

J

• jeu de caractères (Delphi)
  • mots réservés (Eléments syntaxiques fondamentaux)
• jeux de caractères
  • caractères étendus (Jeux de caractères)
  • jeux de caractères ANSI (Jeux de caractères)
  • jeux de caractères multi-octets (Jeux de caractères)
  • jeux de caractères OEM (Jeux de caractères)
  • pages de code (Jeux de caractères)
  • pages de code Windows (Jeux de caractères)
  • Unicode (Jeux de caractères)
• jeux de caractères sur deux octets
  • codes de caractères sur deux octets (Jeux de caractères)
• jeux d'options (C++) (Présentation des jeux d'options)

L

• langage C++
  • spécificités du langage C++ (Spécificités du C++)
• late_check
  • mots clés, C++ (Late check)
• liaison
  • structure du langage C++ (Lien)
• libellés
  • affichage des données (Affichage de données en tant que libellés)
  • contrôles texte statiques (Libellés)
• Lien par nom seulement
  • Liaison C++ (Liaison des fichiers objet et de la bibliothèque C++)
• liens de données
  • ajout aux composants (Ajout du lien de données)
• #line (Line)
• listes (Utilisation des listes)
  • chaîne (Utilisation des listes de chaînes)
  • contrôles (Contrôles liste)
  • opérations (Opérations de listes courantes)
  • persistante(s) (Listes persistantes)
• listes A faire
  • planification (Utilisation des listes A faire)
• listes d'actions
  • actions (Définition des listes d'actions)
• listes de chaînes
  • ajout d'une chaîne (Ajout d'une chaîne à une liste)
  • chargement et enregistrement (Lecture et enregistrement des listes de chaînes)
  • comptage (Comptage des chaînes d'une liste)
  • contrôles graphiques (Ajout d'objets graphiques à une liste de chaînes)
  • copie (Copie de la totalité d'une liste de chaînes)
  • création (Création d'une nouvelle liste de chaînes)
  • manipulation (Manipulation des chaînes d'une liste)
  • objets associés (Association d'objets à une liste de chaînes)
  • recherche de chaînes (Recherche d'éléments dans une liste de chaînes)
  • suppression (Suppression d'une chaîne d'une liste)
• _lrotr, _lrotl (Lrotl, lrotr)
• _ltoa, _ltow, ltoa (Ltoa, ltoa, ltow)

M

• macro
  • enregistrement (Enregistrement d'une macro de touches)
• macros
  • prédéfinies (C++) (Macros prédéfinies)
• Macros MAKE (Macros MAKE)
• MAKE.EXE (MAKE)
• Mappage TCHAR Unicode
  • spécificités du langage C++ (Fonctions flottantes)
• mappeur XML
  • définition (Utilisation de XMLMapper)
• marshaling
  • mécanismes (Le mécanisme du marshaling)
• masquage des noms
  • spécificités du langage C++ (Masquage)
• _mbslen, strlen, wcslen, _mbstrlen (Strlen, mbslen, wcslen, mbstrlen)
• MDA (Synchronisation entre les modèles et le code source)
• membres de classes
  • visibilité (Déclarations privées, protégées, publiques et publiées)
• membres, portée
  • spécificités du langage C++ (Portée des membres)
• membres statiques
  • spécificités du langage C++ (Membres statiques)
• menus
  • affectation d'un nom (Nom des menus)
  • ajout d'éléments de menu (Ajout, insertion et suppression d'éléments de menu)
  • ajout d'images (Ajout d'images à des éléments de menu)
  • basculer entre (Déplacement parmi les menus à la conception)
  • construction (Construction de menus)
  • couleur et bitmaps (Ajout de couleurs, motifs ou images aux menus, boutons et barres d'outils)
  • création (Création et gestion de menus)
  • création de sous-menus (Création de sous-menus)
  • déplacement d'éléments de menu (Déplacement d'éléments de menu)
  • édition des éléments de menu (Edition des éléments de menu dans l'inspecteur d'objets)
  • Fiches VCL (Affichage d'une fiche VCL créée automatiquement)
  • Fiches VCL (Création d'actions dans une application Fiches VCL)
  • Fiches VCL (Création d'une instance de fiche VCL en utilisant une variable locale)
  • Fiches VCL (Utilisation de ActionManager pour créer des actions dans une application Fiches VCL)
  • fusion (Fusion de menus)
  • fusion (Ordre des éléments de menu fusionnés : propriété GroupIndex)
  • icônes (Ajout d'icônes aux menus et aux barres d'outils)
  • icônes (Sélection de styles de menu et de barre d'outils)
  • manipulation d'éléments de menu à l'exécution (Manipulation d'éléments de menu à l'exécution)
  • modèles (Conventions de nom pour les éléments et les gestionnaires d'événements des modèles de menu)
  • modèles (Enregistrement d'un menu en tant que modèle)
  • modèles (Utilisation des modèles de menu)
  • noms des éléments de menu (Noms des éléments de menu)
  • personnalisables (Création de barres d'outils et de menus personnalisables)
  • spécification du menu actif (Spécification du menu actif : propriété Menu)
  • touches accélératrices (Spécification de touches accélératrices et de raccourcis clavier)
  • visualisation (Affichage du menu)
• menus surgissants (Ajout d'un menu surgissant)
• message
  • réflexive (Utilisation d'un message UML 2.0)
• messages
  • interception des messages (Interception des messages)
  • présentation (Gestion des messages et des notifications système : Vue globale)
  • répartition des messages (Répartition des messages)
• Messages (C+) (Options des messages)
• messages de frappes de touches (Réponse aux messages indiquant la manipulation du clavier)
• messages de réponse
  • statut (Indication du statut de la réponse)
• messages de requête HTTP
  • objet TWebRequest (Accès aux informations de requêtes client)
• messages HTTP
  • contenu (Contenu d'un message de requête HTTP)
  • contenu (Définition du contenu de la réponse)
  • contenu de la réponse (Génération du contenu des messages de réponse)
  • en-têtes (Informations d'en-tête de réponse)
  • en-têtes (Propriétés contenant des informations d'en-tête de requête)
  • envoi (Envoi de la réponse)
  • réponse (Création de messages de réponse HTTP)
  • traitement (Répartition des messages de requête)
  • types (Type de méthode de requête)
• messages liés à la souris (Réponse aux messages indiquant la manipulation de la souris)
  • messages de frappes de touches (Gestion des messages liés à la souris ou au clavier)
• mesures
  • ajout d'unités (Ajout de nouveaux types de mesure)
  • ajout d'unités (Création d'une famille de conversion simple et ajout d'unités)
• métadonnées
  • dbExpress (Accès aux informations de schéma dbExpress)
  • dbExpress (Récupération de métadonnées dans un ensemble de données dbExpress)
• méthodes (Appel de méthodes)
  • classes et objets (Méthodes)
  • dynamique (Méthodes dynamiques)
  • fonctions (Création de méthodes : Vue globale)
  • méthodes virtuelles (Méthodes virtuelles)
  • non virtuelles (Méthodes standard (C++))
  • répartition (Répartition des méthodes)
  • statiques (Méthodes statiques)
• méthodes abstraites (Méthodes abstraites)
  • méthodes (Membres abstraits d'une classe)
• méthodes anonymes
  • gestion C++ (Comment gérer les méthodes anonymes Delphi dans C++)
• méthodes de classe
  • spécificités du langage C++ (Méthodes de classe)
• méthodes du canevas
  • objets graphiques (Utilisation des méthodes du canevas pour dessiner des objets graphiques)
• méthodes protégées
  • méthodes (Protection des méthodes)
• méthodes virtuelles
  • méthodes (Rendre virtuelles des méthodes)
• métriques
  • tri des résultats (Visualisation des résultats des métriques)
• mise à jour
  • actions (Mise à jour des actions)
• mises à jour
  • ensemble de données client (Application des mises à jour)
  • filtrage (Filtrage des mises à jour)
  • procédures stockées (Application des mises à jour à des ensembles de données représentant plusieurs tables)
• mises à jour groupées
  • annulation (Annulation des mises à jour groupées)
• mises à jour placées en mémoire cache
  • application (Application des mises à jour BDE en mémoire cache)
  • BDE (Activation des mises à jour BDE en mémoire cache)
  • BDE (Utilisation du BDE pour placer en mémoire cache les mises à jour)
  • gestion des erreurs (Gestion des erreurs de mise à jour en mémoire cache)
• modales
  • Fiches VCL (Création dynamique d'une fiche VCL modale)
• mode du crayon (Changement du mode du crayon)
• modèle
  • rechargement (Réparation d'un modèle)
• modèle briefcase
  • informatique nomade (Combinaison des approches)
• modèles
  • composant (Création et utilisation des modèles de composants)
  • projet (Utilisation de modèles de projet)
• modèles de composants (Création d'un modèle de composant)
• modèles de réponses
  • Modèles HTML (Modèles HTML)
• Modeling options
  • Diagram Appearance General (Modélisation - Options d'apparence des diagrammes)
• modificateur de visibilité
  • définition (Utilisation d'un champ)
• modificateurs
  • mots clés, C++ (Unsigned)
• modificateurs, fonction
  • structure du langage C++ (Modificateurs de fonctions)
• modification de données
  • dans les grilles (Saisie de modifications dans la grille)
• modification des paramètres
  • refactoring (Présentation de la modification des paramètres (Delphi))
• modification du code
  • achèvement de classe (Utilisation de l'achèvement de classe)
• modules de données (Utilisation des propriétés et événements des composants dans un module de données)
  • accès depuis une fiche (Accès à un module de données depuis une fiche)
  • affectation d'un nom (Nom d'un module de données et de son fichier unité)
  • création et modification (Création et modification de modules de données standard)
  • distants (Ajout d'un module de données distant à un projet serveur d'application)
  • placement des composants (Placer et nommer les composants)
  • présentation (Utilisation de modules de données)
  • règles d'entreprise (Création de règles de gestion dans un module de données)
• modules de données distants
  • création (Configuration de TMTSDataModule)
  • création (Configuration de TRemoteDataModule)
  • création (Configuration de TSOAPDataModule)
  • mise en place (Configuration du module de données)
• Modules de données Web
  • applications Web (Modules de données Web)
• modules de fusion
  • packages (Modules de fusion)
• Modules de page Web
  • applications Web (Modules de page Web)
• Modules Web
  • modules de données (Création d’applications serveur Web avec WebBroker)
  • modules de données (Le module Web)
  • modules de données (Modules Web)
  • modules de données (Utilisation de WebBroker)
  • répartiteur Web (Répartiteur Web)
• Moteur de bases de données Borland
  • alias (Définition des paramètres d'alias BDE)
  • alias (Identification de la base de données)
  • alias (Manipulation des alias BDE)
  • appels directs (Utilisation des propriétés de handle BDE)
  • déploiement (Moteur de bases de données Borland)
• mots clés (Mots clés et mots protégés dans les macros)
  • éléments lexicaux, C++ (Extensions des mots clés)
  • éléments lexicaux, C++ (Mots clés)
  • éléments lexicaux, C++ (Mots clés spécifiques au C++)
• mots-clés
  • structure du langage C++ (Spécificateurs de type)
• MSBuild (Présentation de MSBuild)
• __msfastcall
  • mots clés, C++ (Msfastcall)
• __msreturn
  • mots clés, C++ (Msreturn)
• MTS
  • applications de bases de données (Utilisation de modules de données transactionnels)
• multimédia (Utilisation du multimédia)
• mutable
  • mots clés, C++ (Mutable)

N

• namespace
  • consultation (Utilisation d'un espace de nommage ou d'un package)
• navigateur de base de données
  • panneaux d'informations (Affichage de panneaux d'information)
  • plusieurs ensembles de données (Utilisation d'un navigateur pour plusieurs ensembles de données)
• navigateur web
  • Fiches VCL (Construction d'une application de navigateur Web Fiches VCL)
• new
  • représentations alternatives des tokens C++ (And eq)
  • spécificités du langage C++ (New)
• noeud
  • optimisation de la taille (Redimensionnement des éléments de modèle)
• Noeuds XML
  • manipulation (Utilisation des noeuds XML)
• noms de classes
  • spécificités du langage C++ (Noms de classes)
  • spécificités du langage C++ (Portée du nom de classe)
• non modales
  • Fiches VCL (Création dynamique d'une fiche VCL non modale)
• not
  • représentations alternatives des tokens C++ (Not, !)
• not_eq
  • représentations alternatives des tokens C++ (Not eq, !=)
• Nouveau champ (boîte de dialogue) (Définition d'un champ de données)
• nullptr
  • mots clés, C++ (Nullptr)

O

• objet application Web
  • WebBroker (Objet application Web)
• objet canevas
  • propriétés (Utilisation des propriétés de l'objet canevas)
• objets
  • classes (Qu'est ce qu'un objet ?)
  • composants (Objets, composants et contrôles)
  • création (Création, instanciation et destruction d'objets)
  • Delphi (Examen d'un objet Delphi)
  • structure du langage C++ (Objets)
  • variables (Utilisation de variables objet)
• objets Active Server
  • recensement (Recensement d'un objet Active Server)
  • serveurs hors processus (Création d'ASP pour des serveurs en et hors processus)
  • test et débogage (Test et débogage d'une application ASP (Active Server Page))
• objets automation
  • interfaces (Objets automation (Win32 uniquement))
• objets champ
  • champs (Manipulation des composants champ : Vue globale)
  • dynamiques ou persistants (Composants champ dynamique)
  • événements (Gestion des événements)
  • méthodes (Manipulation des méthodes de champ lors de l'exécution)
  • propriétés (Définition des événements et des propriétés des champs persistants)
  • propriétés (Définition des propriétés d'affichage et d'édition en mode conception)
  • propriétés (Définition des propriétés des composants champ à l'exécution)
• objets COM
  • choix d'un modèle de thread (Choix d'un modèle de thread)
  • conception (Conception d'un objet COM)
  • création (Utilisation de l'expert Objet COM)
  • implémentation (Code généré par les experts)
  • implémentation (Implémentation des objets COM à l'aide d'experts)
  • marshaling des données (Marshaling des données)
  • recensement (Recensement d'un objet COM)
  • types d'instanciation (Types d'instanciation des objets COM)
• objets distants (Exemple d'objet distant)
• objets exception
  • classes (Gestion des classes d'exceptions)
  • définition (Définition d'exceptions VCL personnalisées)
  • VCL (Classes d'exception VCL)
• objets mise à jour
  • accès aux requêtes (Utilisation de la propriété Query d'un composant mise à jour)
  • application (Appel de la méthode Apply)
  • application (Exécution des instructions SQL)
  • TUpdateSQL (composant) (Utilisation d'objets mise à jour pour mettre à jour un ensemble de données)
• objets thread
  • Nouvel objet thread (boîte de dialogue) (Définition d'objets thread)
• OCL
  • contrainte (Support OCL)
• OnPopup (événement)
  • gestion (Gestion de l'événement OnPopup)
• opérateur
  • opérateurs, C++ (Opérateurs binaires - Index)
  • opérateurs, C++ (Opérateurs d'expressions postfixées - Index)
  • opérateurs, C++ (Opérateurs unaires - Index)
  • opérateurs, C++ (Présentation de la surcharge des fonctions opérateurs - Index)
• opérateur ?:
  • opérateurs, C++ (Opérateurs conditionnels)
• opérateur .
  • opérateurs, C++ (Sélecteur de membre direct (.))
• opérateur [ ]
  • opérateurs, C++ (Opérateur d'accès à un tableau)
• opérateur *
  • opérateurs, C++ (Opérateurs de référencement/déréférencement)
• opérateur +
  • opérateurs, C++ (Opérateurs plus et moins)
• opérateur ++
  • opérateurs, C++ (Opérateurs d'incrémentation/décrémentation)
• opérateur as
  • opérateurs (Utilisation de l'opérateur as avec des interfaces)
• opérateur new
  • spécificités du langage C++ (Opérateur new)
  • spécificités du langage C++ (Opérateur new avec les tableaux)
  • spécificités du langage C++ (Syntaxe des arguments de l'opérateur new)
• opérateurs, appels de fonctions
  • opérateurs, C++ (Opérateur d'appel de fonction)
• opérateurs arithmétiques
  • opérateurs, C++ (Opérateurs arithmétiques)
• opérateurs, binaires
  • opérateurs, C++ (Opérateurs binaires)
• opérateurs bit à bit,
  • opérateurs, C++ (Opérateurs bit à bit)
• opérateurs, C++ présentation
  • opérateurs, C++ (Présentation des opérateurs)
• opérateurs, égalité
  • structure du langage C++ (Opérateurs d'égalité)
• opérateurs, expressions
  • opérateurs, C++ (Opérateurs d'expressions primaires)
• opérateurs logiques
  • opérateurs, C++ (Opérateurs logiques)
• opérateurs relationnels
  • opérateurs, C++ (Opérateurs relationnels)
• opérateurs, surcharge
  • surcharge des opérateurs, C++ (Exemple de surcharge des opérateurs)
  • surcharge des opérateurs, C++ (Opérateurs surchargés et héritage)
  • surcharge des opérateurs, C++ (Surcharge de l'opérateur d'accès)
  • surcharge des opérateurs, C++ (Surcharge de l'opérateur d'accès aux membres de classe -)
  • surcharge des opérateurs, C++ (Surcharge de l'opérateur d'affectation =)
  • surcharge des opérateurs, C++ (Surcharge de l'opérateur d'appel de fonction ( ))
  • surcharge des opérateurs, C++ (Surcharge des fonctions opérateurs)
  • surcharge des opérateurs, C++ (Surcharge des opérateurs)
  • surcharge des opérateurs, C++ (Surcharge des opérateurs binaires)
  • surcharge des opérateurs, C++ (Surcharge des opérateurs unaires)
• opérateurs, unaires
  • opérateurs, C++ (Opérateurs unaires)
• opérations groupées
  • exécution (Exécution d'une action groupée)
  • mappage des types de données (Mappage des types de données)
  • modes (Spécification d'un mode d'action groupée)
• operator
  • mots clés, C++ (Operator)
• options
  • désactivation des modifications (Configuration de la modélisation UML)
  • general (Modélisation - Options générales)
  • generate documentation general (Modélisation - Options de génération de la documentation)
• options du compilateur
  • options du projet (Définition des options de l'EDI, du projet et du compilateur)
• or
  • représentations alternatives des tokens C++ (Or)
• ordre de tri
  • spécification (Création d'un index avec IndexFieldNames)
• or_eq
  • représentations alternatives des tokens C++ (Or eq)
• organisation des programmes
  • programmes et unités (Programmes et unités)
• orientés données
  • contrôles (Utilisation de contrôles de données)
• outils de dessin (Utilisation des outils de dessin)
• outils de traduction
  • ajout de langues à un projet (Ajout de langues à un projet)
  • configuration, module de traduction externe (Configuration du gestionnaire de traductions externe)
  • définition de la langue active (Définition de la langue active d'un projet)
  • édition avec le module de traduction (Modification des fichiers de ressources dans le gestionnaire de traductions)
  • mise à jour des modules de ressources (Mise à jour de modules de ressources)
  • Module de traduction externe (Utilisation du gestionnaire de traductions externe)
  • présentation (Présentation de la localisation des applications avec le gestionnaire de traductions)
  • vue globale (Noms Langue-Culture, codes et valeurs ISO)

P

• packages
  • chargement/déchargement (Chargement des packages avec la fonction LoadPackage)
  • compilation (Compilation de packages)
  • compilation (Packages)
  • conception (Packages de conception)
  • création (Création d'un package)
  • définis à l'exécution (Packages d'exécution)
  • déploiement (Déploiement de packages)
  • déploiement (Fichiers package)
  • directives du compilateur (Directives de compilation spécifiques aux packages)
  • et les DLL (Les packages et les DLL standard)
  • fichiers (Fichiers de packages créés lors d'une compilation)
  • installation d'un composant (Installation de packages de composants)
  • introduction à la création et à la modification (Création et modification de packages)
  • modification d'un package existant (Modification d'un package existant)
  • modification manuelle de fichiers source (Modification manuelle de fichiers source de packages)
  • packages (Utilisation des packages et des composants : Vue globale)
  • packaging faible (Utilisation de la directive d'empaquetage faible)
  • personnalisés (Packages personnalisés)
  • Pourquoi les utiliser ? (Pourquoi utiliser des packages ?)
  • quand les utiliser (Utilisation des packages et des DLL)
  • quelle exécution utiliser ? (Choix des packages d'exécution à utiliser)
  • structure (Présentation de la structure d'un package)
  • unités (Construction de packages)
  • utilisation dans une application (Chargement des packages dans une application)
  • utilisation du compilateur et du lieur en ligne de commande (Compilation et liaison à partir de la ligne de commande)
• Packages Delphi (C++)
  • Compilation des packages de conception C++ contenant du source Delphi (Compilation des packages de conception C++ contenant du source Delphi)
• packages et DLL
  • création (Création de packages et de DLL)
• page Active Server
  • création (Création d'un objet Active Server)
  • objets intrinsèques (Utilisation des éléments intrinsèques ASP)
  • présentation (Création de pages Active Server : Vue globale)
• page de propriétés
  • ajout de contrôles (Ajout de contrôles à une page de propriétés)
  • associer aux contrôles ActiveX (Association des contrôles de la page de propriétés aux propriétés du contrôle ActiveX)
  • mise à jour (Mise à jour de la page de propriétés)
• page Internet de la palette
  • Applications serveur Web (Création d'applications Internet : Vue globale)
• Pages Active Server
  • présentation (Pages Active Server)
• Palette d'outils
  • composants (Ajout de composants à une fiche)
• palettes
  • graphiques (Gestion des palettes)
• paquets de données
  • attributs des champs (Contrôle des informations placées dans les paquets de données)
  • champs persistants (Spécification des champs apparaissant dans les paquets de données)
  • conversion en documents XML (Utilisation d'un document XML comme client d'un fournisseur)
  • options d'un fournisseur (Spécification des options caractérisant les paquets de données)
  • paramètres optionnels (Ajouter des informations personnalisées aux paquets de données)
• paquets delta
  • modification (Modification des paquets delta avant la mise à jour de la base de données)
• Paradox (tables)
  • fichiers de contrôle de réseau (Spécification des répertoires Paradox)
  • mots de passe (Manipulation des tables Paradox et dBASE protégées par mot de passe)
  • transactions locales (Utilisation de transactions locales)
• paramètre d'activité
  • ajout (Conception d'un diagramme d'activités UML 2.0)
• paramètres
  • commandes ADO (Gestion des paramètres de commande)
  • des procédures et des fonctions (Paramètres (Delphi))
  • obtention à partir des fournisseurs (Obtention des paramètres du serveur d'applications)
• paramètres des icônes pour l'application (Application)
• partage de code entre plusieurs gestionnaires d'événements (Partage de code entre plusieurs gestionnaires d'événements)
• pascal
  • mots clés, C++ (Pascal, pascal, pascal)
• PASCALIMPLEMENTATION (Declspec(pascalimplementation))
• Patterns de première classe (FCC, First Class Citizens)
  • ajout de participants (Ajout de participants aux patterns de première classe (FCC, First Class Citizens))
• paValueList
  • paSubProperties (Spécification des attributs de l'éditeur)
• Perform (méthode)
  • envoi des messages (Appel direct du gestionnaire de message d'un contrôle)
• personnalisation d'une grille (Personnalisation d'une grille : Vue globale)
• pilotes
  • dbExpress (Configuration de TSQLConnection)
• pinceaux (Utilisation des pinceaux)
• pixels
  • lecture et définition (Lecture et définition de pixels)
• pliage de code
  • réduction du code (Utilisation du pliage de code)
• pointeur de la souris
  • glisser-déplacer (Changement du pointeur de la souris)
• pointeurs
  • classes (Classes et pointeurs)
  • structure du langage C++ (Déclarations de pointeurs)
  • structure du langage C++ (Pointeurs)
  • structure du langage C++ (Pointeurs de fonctions)
  • structure du langage C++ (Pointeurs d'objets)
• pointeurs, constantes
  • structure du langage C++ (Constantes pointeur)
• pointeurs, conversions
  • structure du langage C++ (Conversions de pointeurs)
• pointeurs, objets
  • structure du langage C++ (Opérations arithmétiques et pointeurs)
• polygones (Dessin de polygones)
• polylignes (Dessin de polylignes)
• portée
  • objets (Portée et qualificateurs)
  • spécificités du langage C++ (Portée en C++)
  • structure du langage C++ (Portée)
• portée, opérateur de résolution
  • surcharge des opérateurs, C++ (Opérateur de résolution de portée)
• portée, règles
  • spécificités du langage C++ (Résumé des règles de portée en C++)
• portées
  • application (Application ou annulation d'une portée)
  • enregistrements (Limitation des enregistrements avec des portées)
  • modification (Modification d'une portée)
• ports (Utilisation des ports)
  • services et (Services et ports)
• position du crayon (Renvoi de la position du crayon)
• positionnement du contrôle (Positionnement du contrôle)
• PostMessage (méthode)
  • envoi des messages (Envoi d'un message qui ne s'exécute pas immédiatement)
• #pragma (Pragma)
• #pragma alignment (Pragma alignment)
• #pragma argsused (Pragma argsused)
• #pragma checkoption (Pragma checkoption)
• #pragma codeseg (Pragma codeseg)
• #pragma comment, pragma (Pragma comment)
• #pragma defineonoption (Pragma defineonoption et pragma undefineonoption)
• #pragma exit (Pragma exit et pragma startup)
• #pragma hdrfile (Pragma hdrfile)
• #pragma hdrstop (Pragma hdrstop)
• #pragma inline (Pragma inline)
• #pragma intrinsic (Pragma intrinsic)
• #pragma link (Pragma link)
• #pragma message (Pragma message)
• #pragma nopushoptwarn (Pragma nopushoptwarn)
• #pragma obsolete (Pragma obsolete)
• #pragma option (Pragma option)
• #pragma pack (Pragma pack)
• #pragma package (Pragma package)
• #pragma region (Pragma region et pragma end region)
• #pragma resource (Pragma resource)
• #pragma warn (Pragma warn)
• Présentation des composants Rave (Présentation des composants Rave)
• Présentation du langage Delphi (Présentation du langage)
• priorité
  • opérateurs, C++ (Priorité des opérateurs)
• Prise en charge des applications Web
  • Win32 (Présentation des applications Web Win32)
• prise en main
  • ajout de fichiers à un projet (Ajout et suppression de fichiers)
  • ajout de modèles au référentiel (Ajout de modèles au référentiel d'objets)
  • ancrage des fenêtres d'outils (Ancrage de fenêtres d'outils)
  • configuration des options d'un projet (Définition des options de projet)
  • copie de références (Copie de références vers un chemin local)
  • définition des préférences pour les outils (Définition des préférences pour les outils)
  • définition des propriétés d'un composant (Initialisation des propriétés d'un composant (Procédure))
  • définition des propriétés et des événements (Définition des propriétés et des événements)
  • écriture de gestionnaires d'événements (Ecriture de gestionnaires d'événements)
  • filtrage des composants recherchés (Recherche d'éléments sur la palette d'outils)
  • personnalisation de la palette d'outils (Personnalisation de la palette d'outils)
  • personnalisation des fiches (Personnalisation de la fiche)
  • renommer des fichiers (Renommage des fichiers à l'aide du gestionnaire de projet)
• private
  • mots clés, C++ (Private)
• procédure
  • Register (Ecriture de la procédure Register)
• procédures
  • interfaces (Utilisation d'interfaces avec des procédures)
• procédures et fonctions assembleur
  • assembleur en ligne (Procédures et fonctions assembleur (Win32 uniquement))
• procédures stockées
  • ensembles de données (Utilisation de TStoredProc)
  • exécution (Exécution de procédures stockées qui ne renvoient pas d'ensemble de résultats)
  • liaison des paramètres (Liaison des paramètres)
  • Oracle surchargées (Manipulation des procédures stockées redéfinies d'Oracle)
  • paramètres (Utilisation de paramètres avec les procédures stockées)
  • plusieurs ensembles de résultats (Lecture de plusieurs ensembles de résultats)
  • préparation (Préparation des procédures stockées)
• programmation orientée objet (Utilisation du modèle objet)
  • écriture des composants (Programmation orientée objet et écriture des composants : Vue globale)
• programmes d'installation
  • InstallShield Express (Utilisation des programmes d'installation)
• Projet
  • Nettoyer (Gestionnaire de projets)
• projets
  • création de projets (Création d'un projet)
  • types de (Démarrage d'un projet)
• property
  • mots clés, C++ (Property)
• propriété bitmap du pinceau (Définition de la propriété Bitmap du pinceau)
• propriétés
  • classes et objets (Propriétés)
  • écriture des composants (Création de propriétés : Vue globale)
  • écriture des composants (Définition des propriétés)
  • événements (Fournir l'aide pour vos composants)
  • initialisation (Initialisation des propriétés à l'exécution)
  • initialisation (Initialisation des propriétés d'un composant)
  • méthodes (Propriétés, méthodes et événements)
  • propriétés de stockage (Stockage et chargement des propriétés)
  • types (Types de propriétés)
• propriétés de requête Web (Propriétés identifiant le but de la requête)
• propriétés modifiables
  • propriétés (Modification globale de la propriété)
• propriétés statiques
  • spécificités du langage C++ (Propriétés statiques)
• protected
  • mots clés, C++ (Protected)
• protocoles
  • Internet (Terminologie et standards)
• pseudo variables
  • éléments lexicaux, C++ (Tableau des pseudo variables de registre C++ de Embarcadero)
• public
  • mots clés, C++ (Public)
• published
  • mots clés, C++ (Published)

R

• raccourci
  • create (Création d'un raccourci)
• raccourcis
  • autre (Raccourcis clavier de l'outil de modélisation)
• raccourci vers un classificateur
  • création (Association d'un objet à un classificateur)
• rafraîchissement de l'écran (Rafraîchissement de l'écran)
• Rave Reports
  • Outils (Ajout de Rave Reports à RAD Studio)
  • présentation (Rave Reports : Vue globale)
  • prise en main (Introduction à Rave Reports)
• read
  • write (Méthodes d'accès (propriétés))
• ReadOnly (propriété)
  • FReadOnly (Modification de la valeur par défaut de FReadOnly)
• Recensement des composants
  • Palette d'outils (Recensement des composants)
• recherche
  • clés partielles (Recherche sur des clés partielles)
  • méthodes Find (Exécution d'une recherche avec les méthodes Find)
  • méthodes Goto (Exécution d'une recherche avec les méthodes Goto)
  • répétition ou extension (Réitération ou extension d'une recherche)
  • spécification de l'enregistrement en cours (Spécification de l'enregistrement en cours après une recherche réussie)
• rechercher les références
  • rechercher les références locales (Recherche de références)
  • rechercher le symbole de déclaration (Présentation de la recherche de références (Delphi, C++))
• rectangles à coins arrondis (Dessin de rectangles à coins arrondis)
• redéfinition des méthodes
  • méthodes (Redéfinition des méthodes)
• redimensionnement
  • dynamique (Redimensionnement dynamique des fiches et des contrôles)
• refactoring (Présentation du refactoring)
  • extraction d'une chaîne de ressource (Extraction d'une chaîne de ressource (Delphi))
  • prévisualisation (Prévisualisation et application des opérations de refactoring)
  • procédures (Refactoring de code)
• Référencement (C++)
  • Références rvalue (C++0x)
  • Références lvalue (C++)
• références de classe
  • classes et objets (Références de classes)
• références d'interfaces
  • interfaces (Références d'interfaces)
• Référentiel d'objets
  • Référentiel (Ajout d'éléments au référentiel d'objets)
  • Référentiel (Copie d'un élément)
  • Référentiel (Héritage d'un élément)
  • Référentiel (Modification d'éléments partagés)
  • Référentiel (Partage d'éléments au sein d'un projet)
  • Référentiel (Partage d'objets au sein d'une équipe)
  • Référentiel (Utilisation d'un élément)
  • Référentiel (Utilisation d'un élément du référentiel d'objets dans un projet)
  • Référentiel (Utilisation du référentiel d'objets)
• register
  • mots clés, C++ (Register)
• RegisterPropertyEditor
  • recensement des éditeurs de propriétés (Recensement de l'éditeur de propriétés)
• Registre
  • registre système (Utilisation des fichiers ini et du registre système)
• Registre du pattern
  • patterns (Patterns)
• regroupement d'objets
  • modules de données distants (Gestion de la durée de vie des modules de données)
• reinterpret_cast (opérateur de transtypage)
  • transtypage, C++ (Reinterpret cast (opérateur de transtypage))
• relations maître/détail
  • applications multiniveaux (Gestion des relations maître/détail)
  • requêtes (Etablissement de relations maître/détail en utilisant des paramètres)
  • tables (Création de relations maître/détail)
• renommer
  • renommage (Renommage de fichiers)
• renommer le symbole
  • déplacement des membres (Refactoring : Déplacement des membres)
  • extraction d'une interface (Refactoring : Extraction d'une interface)
  • extraction d'une méthode (Refactoring : Extraction d'une méthode)
  • extraction d'une super-classe (Refactoring : Extraction d'une super-classe)
  • introduction d'une variable (Refactoring : Introduction de variables)
  • introduire un champ (Refactoring : Introduction de champs)
  • modification des paramètres (Refactoring : Modification des paramètres)
  • refactoring (Renommage d'un symbole)
  • Remonter/Redescendre (Refactoring : Remonter les membres et Redescendre les membres)
  • supprimer en toute sécurité (Refactoring : "Supprimer en toute sécurité")
  • variable inline (Refactoring : Création de variables inline)
• Réponse aux changements de données (Réponse aux changements de données)
• requêtes
  • curseurs unidirectionnels (Utilisation d'ensembles de résultats unidirectionnels)
  • définition des paramètres à la conception (Fourniture des paramètres pendant la conception)
  • définition des paramètres pendant l'exécution (Fourniture des paramètres pendant l'exécution)
  • ensembles de données (Utilisation de TQuery)
  • exécution (Exécution de requêtes qui ne renvoient pas d'ensemble de résultats)
  • hétérogènes (Création de requêtes hétérogènes)
  • hétérogènes (Obtention d'un ensemble de résultats modifiable)
  • mise à jour d'un ensemble de résultats en lecture seule (Mise à jour d'un ensemble de résultats en lecture seule)
  • objets mise à jour (Création d'instructions SQL pour les composants mise à jour)
  • objets mise à jour (Utilisation de l'éditeur SQL de mise à jour)
  • paramètres (Utilisation de paramètres dans les requêtes)
  • préparation (Préparation des requêtes)
• requires
  • mots clés, C++ (Requires)
• résolution
  • influencer le SQL généré (Comment contrôler l'application des mises à jour)
• ressource DLL
  • localisation (Création de DLLs de ressources)
• ressources
  • isolation (Isolation des ressources)
• restrict
  • mots clés, C++ (Restrict)
• Resume (méthode)
  • Suspend (méthode) (Démarrage et arrêt des threads)
• rétroaction visuelle (Contrôles d'affichage)
• return
  • mots clés, C++ (Return)
• réutilisation du code
  • techniques (Réutilisation des composants et des groupes de composants)
• RLINK32.DLL (RLINK32.DLL, le lieur de ressources (C++))
• rôle
  • liaison à différents classificateurs (Utilisation d'un diagramme d'utilisation de collaboration)
• _rotr, _rotl (Rotl, rotr)
• routines de caractères étendus (Routines manipulant les caractères étendus)
• routines de manipulation des chaînes à zéro terminal
  • chaînes (Routines couramment utilisées pour les chaînes à zéro terminal)
• routines de manipulation des chaînes longues
  • chaînes (Routines usuelles de manipulation des chaînes longues)
• routines globales
  • objets utilitaires (Utilisation de la VCL/RTL : Vue globale)
• Routines standard
  • unité System (Routines standard et Entrées/Sorties)
• __rtti
  • spécificités du langage C++ (Mot clé rtti et option -RT)
• RTTI
  • spécificités du langage C++ (Identification de type à l'exécution (RTTI))

S

• safecall
  • événements (Comment Delphi ajoute-t-il des événements)
  • propriétés (Comment Delphi ajoute-t-il des propriétés)
• sections critiques (Utilisation de sections critiques)
• SelectAll (Sélection de la totalité d'un texte)
• SendMessage (méthode)
  • envoi des messages (Envoi d'un message à l'aide de la file d'attente des messages Windows)
• séparateurs
  • éléments lexicaux, C++ (Séparateurs)
• séquence de navigation (Hyperliens dans les modèles UML)
• séquences d'échappement
  • éléments lexicaux, C++ (Séquences d'échappement)
• Serveur Automation
  • création (Utilisation de l'expert Objet Automation)
• serveurs Automation
  • connexion (Connexion à un serveur)
  • débogage (Test et débogage de l'application)
• Serveurs COM
  • objet COM (Serveurs COM)
  • types de (Serveurs en processus, hors processus et distants)
• serveurs d'applications
  • clients Web (Construction d'une application InternetExpress)
  • création (Création de l'application serveur)
  • droits d'accès et de lancement (Droits d'accès au serveur d'applications et à son lancement)
  • fourniture de données (Comment répondre aux demandes de données des clients)
  • recensement (Recensement du serveur d'applications)
  • structure (Structure du serveur d'applications)
• serveurs de base de données
  • connexion (Connexion à un serveur de base de données)
  • connexion (Ouverture d'une connexion avec TDataBase)
  • déconnexion (Déconnexion d'un serveur de base de données)
• services
  • sockets (Implémentation des services)
• Services web
  • utilisation (Utilisation de services Web)
• Services Web
  • ajout (Ajout de nouveaux services Web)
  • clients (Conception de clients pour les services Web)
  • exceptions (Création de classes d'exception personnalisées pour les services Web)
  • importation (Utilisation de l'importateur WSDL)
• sessions
  • activation (Activation d'une session)
  • affectation d'un nom (Affectation d'un nom à une session)
  • dans les applications Web (Ajout d'une session au module Web)
  • multiple (Création de sessions supplémentaires)
  • récupération des informations (Récupération des informations d'une session)
  • Session (composant) (Gestion des sessions de bases de données)
• set_new_handler
  • spécificités du langage C++ (Gestion des erreurs pour l'opérateur new)
• settime (Gettime, settime)
• Sévérité du compilateur C++
  • initialisation et conversion (Compilateur C++ plus strict - Initialisation et conversion)
  • liaison des références et des qualificateurs (Compilateur C++ plus strict - Liaison des références et des qualificateurs)
  • littéraux chaîne (Compilateur C++ plus strict - Les littéraux chaîne sont maintenant des constantes)
  • modifications des templates (Compilateur C++ plus strict - Modifications des templates)
  • résolution des fonctions surchargées (Compilateur C++ plus strict - Résolution des surcharges de fonction)
• short
  • mots clés, C++ (Short)
• signed
  • mots clés, C++ (Signed)
• signets, utilisation (Utilisation des signets)
• sizeof, opérateur
  • mots clés, C++ (Sizeof)
• SOAP
  • avantages (Utilisation de connexions SOAP)
  • serveurs (Conception de serveurs gérant les services Web)
• sockets
  • description (Description des sockets)
  • erreurs (Evénements erreur)
  • gestion d'événements (Réponse aux événements socket)
  • lecture et écriture (Lecture et écriture sur des connexions socket)
  • protocole TCP/IP (Utilisation des sockets)
  • types de connexions (Types de connexions par socket)
• Sockets
  • avantages (Utilisation de connexions Socket)
• sockets client
  • ClientSocket (composant) (Utilisation de sockets client)
  • événements (Evénements client)
• sockets serveur
  • événements (Evénements serveur)
  • ServerSocket (composant) (Utilisation de sockets serveur)
• sources de données
  • activation et désactivation (Activation et désactivation de la source de données)
  • association à des ensembles de données (Modification de l'ensemble de données associé à l'exécution)
  • événements (Réponse aux modifications effectuées par le biais de la source de données)
• souris
  • réponse (Comment répondre à la souris)
• sous-composants
  • propriétés (Création de propriétés pour sous-composants)
• spécificateurs d'accès
  • spécificités du langage C++ (Contrôle d'accès aux membres)
• spécification d'instance
  • instanciation (Utilisation d'une spécification d'instance)
• SQL
  • commandes de métadonnées (Création et modification des métadonnées du serveur)
  • exécution des commandes (Envoi de commandes au serveur)
  • exécution des commandes (Exécution des commandes ne renvoyant pas d'enregistrement)
  • spécification des commandes (Spécification de la commande à exécuter)
• static
  • mots clés, C++ (Static)
• static_assert
  • mots clés, C++ (Static assert)
• static_cast (opérateur de transtypage)
  • transtypage, C++ (Static cast (opérateur de transtypage))
• _stdcall
  • mots clés, C++ (Stdcall, stdcall)
• stéréotype
  • affectation (Affectation du stéréotype d'un élément)
• strings
  • ajout et tri (Copie de la totalité d'une liste de chaînes (VCL))
  • ajout et tri (Création de chaînes)
  • ajout et tri (Parcours des chaînes d'une liste)
  • ajout et tri (Suppression de chaînes)
  • liste de tri (Ajout et tri de chaînes)
• struct
  • mots clés, C++ (Struct)
• structures
  • structure du langage C++ (Structures)
  • structure du langage C++ (Structures et fonctions)
• structures, accès aux membres
  • structure du langage C++ (Accès aux membres d'une structure)
• structures, anonymes (Pragma anon struct)
• structures, déclarations de membres
  • structure du langage C++ (Déclarations des membres d'une structure)
• structures, espaces de nommage
  • structure du langage C++ (Espaces de nommage des structures)
• structures, sans sélecteur
  • structure du langage C++ (Structures sans sélecteur et typedef)
• style du crayon (Changement du style du crayon)
• Style, propriété
  • pinceaux (Changement du style du pinceau)
• suivi
  • point d'origine (Suivi du point d'origine)
• surcharge des opérateurs
  • spécificités du langage C++ (Surcharge de l'opérateur delete)
  • spécificités du langage C++ (Surcharge de l'opérateur new)
• surcharge d'opérateurs
  • classes et objets (Surcharge d'opérateurs)
• switch
  • mots clés, C++ (Switch)
• symbole (renommer)
  • refactoring (Présentation du renommage des symboles (Delphi, C++))
• synchronisateur à écriture exclusive et à lecture multiple
  • synchronisateur (Utilisation du synchronisateur à écriture exclusive et lecture multiple)
• Synchronisation des modifications
  • modification du code (Mode de synchronisation des modifications (Delphi, C++))
• Synchroniser les modifications (Utilisation de la synchronisation des modifications)
• syntaxe assembleur
  • assembleur en ligne (Présentation de la syntaxe assembleur (Win32 uniquement))
• système d'aide (Utilisation de l'aide dans une application VCL)
  • Gestionnaire d'aide (Implémentation de IHelpSelector)
  • Gestionnaire d'aide (Recensement des objets du système d'aide)
  • IHelpSystem (Utilisation de IHelpSystem)
  • pages Man (Activation de l'aide dans les applications)
  • pages Man (Implémentation de ICustomHelpViewer)
  • personnalisation (Personnalisation du système d'aide de l'EDI)
  • TApplication (Appel direct à un système d'aide)
  • TApplication (VCL) (Comment TApplication traite-il l'aide VCL)
  • TControl (VCL) (Comment les contrôles VCL traitent-ils l'aide)
  • visualiseurs d'aide (Affichage de l'aide basée sur un mot clé)
  • visualiseurs d'aide (Affichage des sommaires)
  • visualiseurs d'aide (Communication avec le gestionnaire d'aide)
  • visualiseurs d'aide (Demande d'informations au gestionnaire d'aide)
  • visualiseurs d'aide (Interfaces avec les systèmes d'aide)

T

• tableau
  • champs (Utilisation des champs tableau)
  • propriétés (Création de propriétés tableau)
• tableaux
  • spécificités du langage C++ (Opérateur delete avec les tableaux)
  • structure du langage C++ (Tableaux)
• Tableaux sécurisés (Tableaux sécurisés)
• tables
  • accès exclusif (Contrôle des accès en lecture/écriture aux tables locales)
  • création (Création et suppression des tables)
  • droits d'accès (Contrôle des accès en lecture/écriture aux tables)
  • ensembles de données (Utilisation de TTable)
  • opérations groupées (Importation des données d'une autre table)
  • relations maître/détail (Comment faire de la table la partie détail d'un autre ensemble de données)
  • relations maître/détail (Utilisation de tables détail imbriquées)
  • renommer (Modification du nom d'une table)
  • synchronisation (Synchronisation des tables)
  • types de table locale (Spécification du type d'une table locale)
  • vidage (Vidage des tables)
• tables maître-détail
  • ensembles de données unidirectionnels (Définition de relations liées maître/détail)
• TApplication
  • TScreen (Contrôle du comportement de l'application)
  • utilisation (Manipulation de l'application)
• TCanvas
  • présentation (Création d'espaces de dessin)
• TCP/IP
  • distribution d'applications (Création d'applications serveur Web)
• TDUMP.EXE (TDUMP.EXE, l'utilitaire de vidage de fichier)
• templates
  • création (Création de templates dynamiques)
  • création (Utilisation des templates dynamiques)
  • spécificités du langage C++ (Template)
  • templates, C++ (Fonctions template implicites et explicites)
  • templates, C++ (Suppression des pointeurs dans les templates)
  • templates, C++ (Utilisation des crochets angulaires dans les templates)
  • templates, C++ (Utilisation des listes génériques à type fiable dans les templates)
  • templates, C++ (Utilisation des templates)
• templates, arguments
  • templates, C++ (Arguments des templates)
• templates, classe
  • templates, C++ (Templates de classes)
• templates, dans la version 3.0
  • templates, C++ (Sémantique de génération des templates)
• templates, DLL
  • spécificités du langage C++ (Exportation et importation de templates)
• templates, fonction
  • templates, C++ (Templates de fonctions)
• templates, options du compilateur
  • templates, C++ (Commutateurs du compilateur relatifs aux templates)
• templates, surcharge
  • templates, C++ (Surcharge d'une fonction template)
• templates, vérification de la syntaxe
  • templates, C++ (Analyse du corps de template)
• TEncoding
  • utilisation pour Unicode (Utilisation de TEncoding pour les fichiers Unicode)
• termes du contrat de licence
  • termes du contrat de licence logicielle (Termes du contrat de licence logicielle)
• tests unitaires
  • Ajout du source à un projet de test (Développement de tests)
• test unitaire (Présentation des tests unitaires)
• texte
  • couper (Comment couper, copier et coller du texte)
  • dans les contrôles (Manipulation du texte dans les contrôles)
  • définition de l'alignement (Définition de l'alignement du texte)
  • internationalisation (Texte)
  • sélection (Sélection de texte)
  • suppression (Effacement du texte sélectionné)
• TForm
  • fiches (Utilisation de la fiche principale)
• this
  • mots clés, C++ (This)
• thread_local
  • mots clés, C++ (Thread local)
• threads
  • applications multithreads (Ecriture d'applications multithreads)
  • arrêt (Vérification de l'arrêt par d'autres threads)
  • attente (Attente de l'achèvement d'une tâche)
  • attente (Attente de la fin d'exécution d'un thread)
  • attente (Attente des autres threads)
  • code de nettoyage (Ecrire du code de nettoyage)
  • constructeurs (Initialisation du thread)
  • débogage (Débogage des applications multithreads)
  • éviter les accès simultanés (Eviter les accès simultanés)
  • exceptions (Gestion des exceptions dans la fonction thread)
  • Exécution (Exécution d'objets thread)
  • figement dans le débogueur (Figer et libérer des threads dans le débogueur)
  • libération dans le débogueur (Figer et libérer des threads dans le débogueur)
  • partage de mémoire (Autres techniques de partage de la mémoire)
  • priorité (Redéfinition de la priorité par défaut)
• threads non nommés
  • affectation d'un nom (Conversion d'un thread anonyme en thread nommé)
• throw
  • mots clés, C++ (Throw)
• TIniFile
  • utilisation (Utilisation de TIniFile et TMemIniFile)
• TLIB.EXE (TLIB.EXE, le gestionnaire de bibliothèques)
• tokens (Fusion de tokens avec)
  • éléments lexicaux, C++ (Tokens)
• TOUCH.EXE (Utilisation de TOUCH.EXE)
• ToolsAPI
  • Extension de l'EDI (ToolsAPI) (Extension de l'EDI - Index)
• Tools API
  • création de modules (Création de fiches et de projets)
  • extension de l'EDI(Tools API) (Extension de l'EDI - Index)
  • interfaces d'éditeur (Utilisation des interfaces d'éditeur)
  • interfaces de module (Utilisation des interfaces de module)
  • objets natifs de l'EDI (Utilisation d'objets natifs de l'EDI)
  • services (Accès aux services de l'API Tools)
  • versionnage (Numéros de version de l'interface)
• Bibliothèques de types (Utilisation des bibliothèques de types : Vue globale)
  • tâches (Utilisation de l'éditeur de bibliothèques de types)
• TPrinter
  • présentation (Impression)
• transactions
  • applications multiniveaux (Gestion des transactions dans les applications multiniveaux)
  • automatiques (Spécification de l'exécution automatique des transactions par la connexion)
  • bases de données (Gestion des transactions)
  • bases de données (Utilisation des transactions avec le BDE)
  • niveaux d'isolement (Spécification du niveau d'isolement des transactions)
• transformation en code source (Transformation en code source)
• transition
  • multiple (Transition)
  • multiple (Transition des diagrammes d'activités UML 1.5)
  • multiple (Transition UML 1.5)
  • réflexive (Création d'une transition réflexive)
• transtypage, style C++
  • spécificités du langage C++ (Nouveau style de transtypage)
• TRegistry
  • utilisation (Utilisation de TRegistry)
• TRegistryIniFile
  • utilisation (Utilisation de TRegistryIniFile)
• TRIGRAPH.EXE (TRIGRAPH)
• try
  • mots clés, C++ (Try)
• TScreen
  • utilisation (Gestion de l'écran)
• TService
  • TDependency (Propriétés de nom d'un service)
• TSimpleDataSet
  • avantages et inconvénients (Quand faut-il utiliser TSimpleDataSet ?)
  • utilisation (Installation d'un ensemble de données simple)
• turboboutons (Turboboutons)
  • affectation d'un glyphe (Spécification du glyphe d'un turbobouton)
  • ajout à un volet (Ajout d'un turbobouton à un volet)
  • création d'un groupe (Création d'un groupe de turboboutons)
  • définition de la condition initiale (Définition de l'état initial d'un turbobouton)
• TVarData (type)
  • variants personnalisés (Stockage des données d'un type Variant personnalisé)
• TXMLDocument (Utilisation de TXMLDocument)
• typedef
  • mots clés, C++ (Typedef)
• typeid
  • mots clés, C++ (Typeid)
• typename
  • mots clés, C++ (Typename)
• types caractère
  • éléments lexicaux, C++ (Les trois types char)
• types chaîne
  • conversions (Dépendances de chaîne)
  • types de données (Types chaîne)
• Types de données
  • scalaire et réel (Types simples)
• types de données, variables et constantes (Types de données, variables et constantes)
• types, fondamentaux
  • structure du langage C++ (Types fondamentaux)
• types imbriqués
  • classes et objets (Déclarations de types imbriqués)
  • spécificités du langage C++ (Types imbriqués)
• types pointeurs
  • types de données (Pointeurs et types pointeur)
• types procédure
  • types de données (Types procédure)
• types structurés
  • types de données (Types structurés)
• types variants
  • types de données (Types variants)

U

• _ui64tow, _ui64toa (Ui64toa, ui64tow)
• _ultow, ultoa (Ultoa, ultow)
• UML (Spécifications UML prises en charge)
• UML en couleurs
  • utilisation (Utilisation du profil UML en couleur)
• #undef (Undef)
• Unicode
  • activation des applications (Activation des applications pour Unicode)
  • Activation des applications C++ (Activation des applications C++ pour Unicode)
  • dans la console de commandes (Utilisation d'Unicode dans la console de commandes)
  • dans RAD Studio (Unicode dans RAD Studio)
  • Mappage TCHAR pour C++ (Mappage TCHAR)
  • nouvelles fonctionnalités 2009 (Nouveautés de Delphi et C++Builder 2009)
• union
  • mots clés, C++ (Union)
• unions
  • structure du langage C++ (Unions)
• unions, anonymes
  • structure du langage C++ (Unions anonymes)
• unions, déclarations
  • structure du langage C++ (Déclarations d'union)
• unités
  • espaces de nommage (Recherche d'unités (Delphi))
• unités de traduction
  • structure du langage C++ (Unités de traduction)
• _unsigned __int_alignment_of( typename T )
  • Fonctions trait de type C++0x (Alignment of)
• unsigned int __array_extent( typename T, unsigned intI )
  • Fonctions trait de type C++0x (Array extent)
• unsigned __int_array_rank( typename T )
  • Fonctions trait de type C++0x (Array rank)
• UpdateObject
  • pages de propriétés (Mise à jour de l'objet)
• URL
  • cibles de requête (URL de destination)
  • hôtes (Composants d'une URL)
• Utilisation des composants IntraWeb
  • VCL pour le Web (Utilisation des composants IntraWeb)
• utilisation d'interaction (Interaction)
  • création (Conception d'un diagramme de séquence ou de communication UML 2.0)
• utilitaires de conversion
  • mesures (Conversion de mesures)
  • mesures (Exécution des conversions)

V

• valeurs de propriété par défaut
  • propriétés (Valeurs par défaut d'une propriété)
• variables
  • types de données (Variables)
• variables locales aux threads
  • threadvar (Utilisation de variables locales aux threads)
• variables locales PChar (Renvoi d'une variable locale PChar)
• variables, multithreads
  • structure du langage C++ (Thread, Variables multithreads)
• variants
  • personnalisés (Définition de variants personnalisés)
• variants personnalisés
  • activation (Utilisation du descendant de TCustomVariantType)
  • chargement et enregistrement (Chargement et enregistrement des valeurs des variants personnalisés)
  • copie (Copie et effacement des variants personnalisés)
  • définition (Création d'une classe pour le type variant personnalisé)
  • opérations binaires (Implémentation d'opérations binaires)
  • opérations de comparaison (Implémentation d'opérations de comparaison)
  • opérations unaires (Implémentation d'opérations unaires)
  • propriétés (Support des propriétés et des méthodes dans les variants personnalisés)
  • transtypages (Activation du transtypage)
  • utilitaires (Ecriture d'utilitaires fonctionnant avec un type variant personnalisé)
• VCL
  • bibliothèque de classes (Bibliothèque de classes)
  • CLX (Présentation des bibliothèques de composants)
  • composants (Présentation de la VCL)
• VCL pour le Web
  • IntraWeb (Création d'une nouvelle VCL pour l'application Web)
• verrouillage des objets (Verrouillage d'objets)
• versions de Windows (Versions des systèmes d'exploitation)
• virtual
  • mots clés, C++ (Virtual)
• visibilité
  • structure du langage C++ (Visibilité)
• Vista
  • composants disponibles (Composants disponibles seulement sur un système d'exploitation spécifique)
• void
  • mots clés, C++ (Void)
• volatile
  • mots clés, C++ (Volatile)
• volets (Volets)
• Vue Diagramme
  • ouverture (Synchronisation de la vue Modèle, de la vue Diagramme et du code source)
• vues arborescentes (Vues arborescentes)
• vues listes (Vues liste)
• Vue Messages (Vue Messages)

W

• W1008 Integer et HRESULT échangés (Delphi) (X1008 Integer et HRESULT échangés (Delphi))

• W1012 L'expression constante dépasse les limites de sous-étendue (Delphi) (X1012 L'expression constante dépasse les limites de sous-étendue (Delphi))

• W1019 La variable de contrôle de boucle FOR doit être une variable locale simple (Delphi) (X1019 La variable de contrôle de boucle FOR doit être une variable locale simple (Delphi))

• W1020 Construction d'instance de '%s' contenant des méthodes abstraites '%s.%s' (Delphi) (X1020 Construction d'instance de '%s' contenant des méthodes abstraites '%s.%s' (Delphi))

• W1025 Fonctionnalité de langage non supportée : '%s' (Delphi) (X1025 Fonctionnalité de langage non supportée : '%s' (Delphi))

• W1026 Fichier introuvable : '%s' (Delphi) (X1026 Fichier introuvable : '%s' (Delphi))

• W1028 Définition de symbole global incorrecte : '%s' dans le fichier objet '%s' (Delphi) (X1028 Définition de symbole global incorrecte : '%s' dans le fichier objet '%s' (Delphi))

• W1030 Directive de compilation incorrecte : '%s' (Delphi) (X1030 Directive de compilation incorrecte : '%s' (Delphi))

• W1033 L'unité '%s' a été importée implicitement dans le package '%s' (Delphi) (X1033 L'unité '%s' a été importée implicitement dans le package '%s' (Delphi))

• W1054 Erreur du lieur : %s (Delphi) (X1054 Erreur du lieur : %s (Delphi))

• W1056 Ressource dupliquée Type %s, ID %s ; Ressource %s de fichier conservée ; Ressource %s de fichier ignorée (Delphi) (X1056 Ressource dupliquée Type %s, ID %s ; Ressource %s de fichier conservée ; Ressource %s de fichier ignorée (Delphi))

• W2041 Erreur de lecture dans '%s' (Delphi) (X2041 Erreur de lecture dans '%s' (Delphi))

• W2042 Erreur d'écriture sur '%s' (Delphi) (X2042 Erreur d'écriture sur '%s' (Delphi))

• W2043 Erreur de fermeture sur '%s' (Delphi) (X2043 Erreur de fermeture sur '%s' (Delphi))

• W2044 Erreur Chmod dans '%s' (Delphi) (X2044 Erreur Chmod dans '%s' (Delphi))

• W2141 Format de fichier incorrect: '%s' (Delphi) (X2141 Format de fichier incorrect: '%s' (Delphi))

• W2243 L'expression ne nécessite pas de Initialize/Finalize (Delphi) (X2243 L'expression ne nécessite pas de Initialize/Finalize (Delphi))

• W2269 La méthode virtuelle redéfinie '%s.%s' a une visibilité inférieure (%s) que la classe de base '%s' (%s) (Delphi) (X2269 La méthode virtuelle redéfinie '%s.%s' a une visibilité inférieure (%s) que la classe de base '%s' (%s) (Delphi))

• W2367 La casse de la méthode de l'accesseur de propriété %s.%s devrait être %s.%s (Delphi) (X2367 La casse de la méthode de l'accesseur de propriété %s.%s devrait être %s.%s (Delphi))

• W1061 La réduction de la constante WideChar donnée en AnsiChar génère une perte d'information (H2451: La réduction de la constante WideChar donnée en AnsiChar génère une perte d'information (Delphi))
• _wargv, _argv
  • _argv (Argv, wargv)
• wchar_t
  • mots clés, C++ (Wchar t)
• _wcstod, wcstod (Strtod, strtold, wcstod, wcstold)
• wcstol, strtol (Strtol, wcstol)
• wcstoul (Strtoul, wcstoul)
• WebSnap
  • ajout d'une prise en charge des ouvertures de session (Ajout d'une prise en charge des ouvertures de session)
  • composants répartiteur (Composants répartiteur)
  • droits d'accès (Droits d'accès utilisateur)
  • hello world (Construction d'une application "Hello world" WebSnap)
  • objets de script (Objets de script)
  • pages de connexion (Pages de connexion)
  • prise en charge des ouvertures de session (Prise en charge des ouvertures de session)
  • projets (Construction d'une application WebSnap)
  • répartiteur d'adaptateur (Fonctions d'un répartiteur d'adaptateur)
  • répartiteur de page (Fonctions du répartiteur de page)
  • répartition des éléments d'action (Répartition des éléments d'action)
  • répartition des requêtes et des réponses (Répartition des requêtes et des réponses)
  • requêtes et réponses des adaptateurs (Réception de requêtes de l'adaptateur et génération des réponses)
  • scripts côté serveur (Utilisation de scripts côté serveur avec WebSnap)
  • service de sessions (Utilisation du service de sessions)
  • tutoriel (Conception HTML avancée)
• _wenviron, _environ (Environ, wenviron)
• _wgetenv, getenv (Getenv, wgetenv)
• while
  • mots clés, C++ (While)
• Windows Forms
  • hello world (Construction d'une application console "Hello World" Windows)
• Windows XP
  • thèmes (Contrôles communs et thèmes XP)
• _wputenv, putenv (Putenv, wputenv)
• WSDL
  • génération (Génération de documents WSDL pour une application de service Web)
  • importation (Importation de documents WSDL)
• _wsearchenv,, _searchenv (Searchenv, wsearchenv)
• _wsearchstr, _searchstr (Searchstr, wsearchstr)
• _wsplitpath, _splitpath (Splitpath, wsplitpath)
• _wsystem, system (System, wsystem)
• _wtoi64, _atoi64 (Atoi64, wtoi64)
• _wtoi, atoi
  • routine de conversion (Atoi, wtoi)
• _wtol, atol (Atol, wtol)

X

• XML (Utilisation de documents XML)
  • applications de bases de données (Utilisation de XML dans les applications de bases de données)
  • Expert Liaison de données (Abstraction de documents XML avec l'expert Liaison de données)
  • Expert Liaison de données (Utilisation de l'expert Liaison de données XML)
• xor
  • représentations alternatives des tokens C++ (Xor, ^)
• xor_eq
  • représentations alternatives des tokens C++ (Xor eq, ^=)

[

• [ ] operator
  • opérateurs, C++ (Opérateur d'accès à un tableau)

_

• _unsigned __int_alignment_of( typename T )
  • fonctions trait de type C++0x (__alignment_of)
• _bool __has_trivial_destructor (typename T )
  • fonctions trait de type C++0x (__has_trivial_destructor)
• __classid
  • mots clés, C++ (__classid)
• __classmethod
  • mots clés, C++ (__classmethod)
• __closure
  • mots clés, C++ (__closure)
• __declspec,
  • mots clés, C++ (__declspec)
• __msfastcall
  • mots clés, C++ (__msfastcall)
• __msreturn
  • mots clés, C++ (__msreturn)
• __rtti
  • spécificités du langage C++ (Mot clé rtti et option -RT)
• __try
  • mots clés, C++ (__try)
• _Bool
  • mots clés, C++ (_Bool)
• _Complex
  • mots clés, C++ (_Complex)
• _export
  • mots clés, C++ (_export, __export)
• _fastcall
  • mots clés, C++ (_fastcall, __fastcall)
  • mots clés, C++ (final)
  • mots clés, C++ (noreturn)
• _Imaginary
  • mots clés, C++ (_Imaginary)
• _stdcall
  • mots clés, C++ (_stdcall, __stdcall)
• __declspec, dllexport
  • mots clés, C++ (__declspec(dllexport))
• __declspec, dllimport
  • mots clés, C++ (__declspec(dllimport))
• __declspec, naked
  • mots clés, C++ (__declspec(naked))
• __declspec, noreturndeclspec, noreturn
  • mots clés, C++ (__declspec(noreturn))
• __declspec, nothrow
  • mots clés, C++ (__declspec(nothrow))
• __declspec, novtable
  • mots clés, C++ (__declspec(novtable))
• __declspec, property
  • mots clés, C++ (__declspec(property))
• __declspec, selectany
  • mots clés, C++ (__declspec(selectany))
• __declspec, thread
  • mots clés, C++ (__declspec(thread))
• __declspec, uuid
  • mots clés, C++ (__declspec(uuid(“ComObjectGUID”)))
• __int8, __int16, and so forth
  • éléments lexicaux, C++ (__int8, __int16, __int32, __int64, __int64 non signés, types entiers étendus)
• __finally,
  • mots clés, C++ (__finally)
• __import
  • mots clés, C++ (_import, __import)
• _wargv, _argv
  • _argv (_argv, _wargv)
• _wtoi64, _atoi64 (_atoi64, _wtoi64)
• _crotr, _crotl (_crotl, _crotr)
• _lrotr, _lrotl (_lrotl, _lrotr)
• _rotr, _rotl (_rotl, _rotr)
• _wsearchenv,, _searchenv (_searchenv, _wsearchenv)
• _wsearchstr, _searchstr (_searchstr, _wsearchstr)
• _wsplitpath, _splitpath (_splitpath, _wsplitpath)
• _ui64tow, _ui64toa (_ui64toa, _ui64tow)
• _wtoi, atoi
  • routine de conversion (atoi, _wtoi)
• _wtol, atol (atol, _wtol)
• _wenviron, _environ (_environ, _wenviron)
• _wgetenv, getenv (getenv, _wgetenv)
• _itow, itoa (itoa, _itow)
• _ltoa, _ltow, ltoa (ltoa, _ltoa, _ltow)
• _wputenv, putenv (putenv, _wputenv)
• _mbslen, strlen, wcslen, _mbstrlen (strlen, _mbslen, wcslen, _mbstrlen)
• _wcstod, wcstod (strtod, _strtold, wcstod, _wcstold)
• _wsystem, system (system, _wsystem)
• _ultow, ultoa (ultoa, _ultow)
• mot clé __finally (Ecriture d'un bloc finally (C++))