Index

$

• {$A}
  • Alignement des champs (Aligner les champs (Delphi))
• {$ALIGN}
  • Alignement des champs (Aligner les 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 (Delphi))
• {$EXTENDEDSYNTAX}
  • Syntaxe étendue (Syntaxe étendue (Delphi))
• {$EXTENSION}
  • Extension de l'exécutable (Extension de l'exécutable (Delphi))
• {$EXTERNALSYM}
  • Symboles externes (Symboles externes (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 type à 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 (Directive NODEFINE (Delphi))
• {$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 intervalles)
• {$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 intervalles)
• {$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 type à 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))

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 de 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 (Définition des bandes d'actions)
  • bandes d'action (Gestion des actions VCL à l'aide d'un gestionnaire 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 (Gestion des actions VCL à l'aide d'une liste 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 de la prise en charge 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 (Assignation 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 (Agrégation (COM))
• aide
  • SDK de la plate-forme Microsoft (Utilisation de l'aide - CHM)
• 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, && (C++))
• 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 Tools
  • création de modules (Création d'experts fiches et 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 (Delphi))
• appels de fonction (Macros avec paramètres (C++))
  • 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 des applications)
  • déploiement (Déploiement des applications - Présentation)
• 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 base de données)
  • applications multiniveaux (Distribution d'applications de bases de données)
  • BDE (Utilisation du BDE)
  • déploiement (Déploiement des applications de base de données)
• 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 des 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 - Présentation)
  • 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 de données (Utilisation des composants fournisseur)
  • fournisseurs (Présentation des applications de bases de données multiniveaux)
  • informations d'état (Gestion des informations d'état dans les modules de données exposés)
  • 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
  • applications (Création d'applications services Web)
  • applications WebBroker (Création d'applications WebBroker)
  • architecture (Structure d'une application WebBroker)
  • débogage (Débogage d'applications serveur)
  • types (Types d'applications serveur Web)
• 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 des 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 inline)
• assistances de classes
  • classes et objets (Assistances de classes et d'enregistrements (Delphi))
• attributs des champs
  • suppression (Suppression des associations d'attributs)
• audio
  • vidéo (Ajout de clips audio ou vidéo à une application)
  • vidéo (Exemple d'ajout de clips audio 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)
• __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 clips vidéo silencieux à une application)
  • animation (Exemple d'ajout de clips vidéo silencieux)
• axiom
  • mots clés, C++ (axiom)

B

• 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 base de données - Présentation)
  • association avec les sessions (Association d'un composant base de données à une session)
  • composants connexion (Connexion aux bases de données - Présentation)
  • connexion (Connexion à un serveur de bases de données en utilisant dbExpress)
  • 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.EXE, le compilateur C++ 32 bits 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 mises à jour)
  • 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 - Présentation)
  • manipulation (Utilisation des bibliothèques de types - Présentation)
  • tâches (Utilisation de l'éditeur de bibliothèques de types)
• Bibliothèques de types (Utilisation des bibliothèques de types - Présentation)
  • tâches (Utilisation de l'éditeur de bibliothèques de types)
• bibliothèques et packages (Bibliothèques et packages (Delphi))
• 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 - UML 1.5)
• blocs
  • structure du langage C++ (Blocs)
• Bof
  • Utilisation des propriétés Eof et Bof (Utilisation des propriétés Eof et Bof)
• 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 (C++))
• _Bool
  • mots clés, C++ (_Bool)
• 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_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 (Assignation d'images à des boutons outil)
  • affectation d'un menu aux (Assignation 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)
• BRC32.EXE (BRC32.EXE, 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 (Définition 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 inerte (whitespace)
  • éléments lexicaux, C++ (Caractère inerte)
• #, caractère (Macros avec paramètres (C++))
• caractères étendus
  • caractères Unicode (Jeux de caractères)
• case
  • mots clés, C++ (case (C++))
• 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 (Routines de contrôle des nombres à virgule flottante)
  • Flux, concepteurs et lecteurs (Flux, lecteurs et concepteurs)
  • Gestion des threads (Routines 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 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 (Routines du support COM et OLE)
  • Support date/heure (Support date et 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 et des sorties des fichiers)
  • Support des menus (Routines de la prise en charge des menus)
  • Support des nombres aléatoires (Routines 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 (Routines du support XML)
• cdecl
  • mots clés, C++ (cdecl, _cdecl, __cdecl (C++))
• 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 (Permettre au code de l'application de fonctionner pour différentes régions)
  • déclaration et initialisation (Déclaration et initialisation de chaînes)
  • manipulation (Utilisation des chaînes)
• champs
  • classes et objets (Champs (Delphi))
  • 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)
• # character (Macros avec paramètres (C++))
• 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 Delphi)
• chemin de recherche (C++ (options partagées))
• class
  • mots clés, C++ (class (C++))
• 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 (Delphi))
• classes, forward
  • spécificités du langage C++ (Déclarations de classes Delphi (__declspec))
• 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)
• __classid
  • mots clés, C++ (__classid)
• classificateur inner
  • création (Création d'un classificateur inner)
• __classmethod
  • mots clés, C++ (__classmethod)
• __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)
• __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 de la création des objets (Création de serveurs COM simples - Présentation)
  • présentation (Présentation des technologies 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 et illustration des diagrammes)
• commentaires
  • éléments lexicaux, C++ (Commentaires)
• commentaires (Delphi) (Eléments syntaxiques fondamentaux (Delphi))
• COM+ (Objets Abonnement d'événement et Evénement COM+)
• compatibilité de type
  • types de données (Compatibilité et identité de types (Delphi))
• 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)
• _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 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 (Présentation de la création d'un composant)
  • ajout à la palette d'outils (Accessibilité des composants au moment de la conception - Présentation)
  • 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 - Présentation)
  • 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 (Recensement 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)
• concept
  • mots clés, C++ (concept)
• concepteur de menus
  • menu contextuel (Concepteur de menus)
  • ouverture (Ouverture du Concepteur de menus)
• 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 - UML 2.0)
• 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)
• 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 étendus 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 à 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 (Delphi))
• 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'une fiche active basée 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 d'édition)
• 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 de 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)
• _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 (Débogage distant - Procédures d'ancien style)
  • applications distantes (Installation, démarrage et arrêt du serveur de débogage distant)
  • inspection des éléments de données (Inspection et modification de la valeur d'éléments de données)
  • liaison avec un processus (Attachement à 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éclaration des méthodes
  • méthodes (Déclaration des méthodes)
• déclaration de types
  • types de données (Types de données, variables et constantes - Index (Delphi))
• 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 de la 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 (Delphi))
• 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)
• __declslpec(delphireturn)
  • L'extension de mot clé __declspec (L'extension de mot clé __declspec)
• __declspec,
  • mots clés, C++ (__declspec)
• __declspec,
  • mots clés, C++ (__declspec)
• __declspec, dllexport
  • mots clés, C++ (__declspec(dllexport))
• __declspec, dllexport
  • mots clés, C++ (__declspec(dllexport))
• __declspec, dllimport
  • mots clés, C++ (__declspec(dllimport))
• __declspec, dllimport
  • mots clés, C++ (__declspec(dllimport))
• __declspec, naked
  • mots clés, C++ (__declspec(naked))
• __declspec, naked
  • mots clés, C++ (__declspec(naked))
• __declspec, noreturndeclspec, noreturn
  • mots clés, C++ (__declspec(noreturn))
• __declspec, noreturndeclspec, noreturn
  • mots clés, C++ (__declspec(noreturn))
• __declspec, nothrow
  • mots clés, C++ (__declspec(nothrow))
• __declspec, nothrow
  • mots clés, C++ (__declspec(nothrow))
• __declspec, novtable
  • mots clés, C++ (__declspec(novtable))
• __declspec, novtable
  • mots clés, C++ (__declspec(novtable))
• __declspec, property
  • mots clés, C++ (__declspec(property))
• __declspec, property
  • mots clés, C++ (__declspec(property))
• __declspec, selectany
  • mots clés, C++ (__declspec(selectany))
• __declspec, selectany
  • mots clés, C++ (__declspec(selectany))
• __declspec, thread
  • mots clés, C++ (__declspec(thread))
• __declspec, thread
  • mots clés, C++ (__declspec(thread))
• __declspec, uuid
  • mots clés, C++ (__declspec(uuid("ComObjectGUID")))
• __declspec, uuid
  • mots clés, C++ (__declspec(uuid("ComObjectGUID")))
• decltype
  • mots clés, C++ (decltype)
• default
  • mots clés, C++ (default (C++))
• defined (defined)
• #define (#define (C++))
• #define (#define (C++))
• 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 (Présentation du déploiement des applications)
• déploiement d'applications de bases de données dbExpress
  • déploiement (Déploiement des applications BDE)
  • déploiement (Déploiement des applications de base 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 (Delphi))
• 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)
• 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 (C++))
• 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 (C++))
  • 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 C++))

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' est implicitement importée 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))
• 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)
  • 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èques 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)
• é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 diagramme)
• é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 - Index)
• enregistrements
  • actualisation (Actualisation des enregistrements)
  • ajout (Ajout de nouveaux enregistrements)
  • avancés (Types structurés (Delphi))
  • 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 (Delphi))
  • validation (Validation des données)
• ensembles
  • utilisation (Utilisation des ensembles 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 (Compréhension des ensembles de données - Présentation)
  • é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 - Présentation)
  • 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 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)
  • paramètres (Transmission de paramètres à l'ensemble de données source)
  • 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)
• Eof
  • Eof (C++) (eof)
  • Utilisation des propriétés Eof et Bof (Utilisation des propriétés Eof et Bof)
• é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)
• #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)
• é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 (Qu'est-ce qu'un événement ?)
  • classes et objets (Evénements (Delphi))
  • 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énement)
  • gestion (Utilisation des événements et des gestionnaires d'événement)
  • gestion (Utilisation du paramètre Sender)
  • menu (Association d'événements de menu à des gestionnaires d'événement)
  • 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 standard
  • événements (Implémentation des événements standard)
• __except
  • mots clés, C++ (__except)
• __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 des exceptions structurées (C++))
  • déclenchement (Déclenchement d'une exception)
  • 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 (Ecriture d'une classe d'expert)
  • implémentation (Implémentation des interfaces d'expert)
  • installation (Recensement d'une classe d'expert dans l'EDI)
  • 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 (visionneuse 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 (C++))
• _export
  • mots clés, C++ (_export, __export (C++))
• export,
  • mots clés, C++ (export (C++))
• expressions
  • expressions (Expressions (Delphi))
  • structure du langage C++ (Expressions (C++))
  • structure du langage C++ (Expressions et C++)
• expressions assembleur
  • assembleur en ligne (Expressions assembleur)
• 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 (C++))
  • mots clés, C++ (noreturn)
• _fastcall
  • mots clés, C++ (_fastcall, __fastcall)
  • mots clés, C++ (final (C++))
  • 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 de fiches non modales (Création de fiches non modales comme fenêtres)
  • création dynamique (Création dynamique de fiches)
  • création (Utilisation des 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 (Utilisation de l'expert Nouveau composant)
  • Composants XML (Construction d'une application avec des composants XML)
  • fiches actives ActiveX (Création d'une fiche active VCL ActiveX)
• fichiers{}
  • renommer (Modification d'un nom de fichier)
• fichiers cibles (Fichiers cibles)
• 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 (Options de ligne de commande des en-têtes précompilés pour BCC32)
• fichiers exécutables
  • internationalisation (Basculement dynamique de DLL de ressources)
  • internationalisation (Utilisation des DLL de ressources)
• 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)
• fichiers .targets (Fichiers cibles)
• 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 fichiers)
• filters
  • member (Modélisation - Options de gestion de la vue Diagramme)
• 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,
  • mots clés, C++ (__finally)
• float
  • mots clés, C++ (float)
• flux (Utilisation des flux)
  • copie des données (Copier des données entre des flux)
  • 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 (:Category:Attributs C++0x)
  • Deprecated (deprecated)
  • énumérations fortement typées (Enumérations fortement typées (C++11))
  • Final (C++) (final (C++))
  • fonctions trait de type (Présentation des fonctions trait de type (C++11))
  • Noreturn (noreturn)
  • opérateur alignof (Assertions statiques (C++11))
  • opérateur alignof (Déclaration forward des énumérations (C++11))
  • opérateur alignof (Littéraux et types de caractères Unicode (C++11))
  • opérateur alignof (Méthodes anonymes dans Delphi)
  • opérateur alignof (Opérateur alignof (C++11))
  • opérateur alignof (Références rvalue (C++11))
  • opérateur alignof (Spécificateur de type decltype (C++11))
  • opérateur alignof (Templates extern (C++11))
  • Opérateurs de conversion explicite (C++11) (Opérateurs de conversion explicite (C++11))
• 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 (C++))
• 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é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)
  • 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 des exceptions (C++))
  • exceptions (Définition des blocs protégés)
  • exceptions (Gestion des exceptions)
  • 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énement)
• 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 - Présentation)
  • 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 fiches)
• 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 RIDL)
• if
  • mots clés, C++ (if, else (C++))
• #ifdef (#ifdef et #ifndef)
• #ifdef (#ifdef et #ifndef)
• #if (#if, #elif, #else et #endif (C++))
• #if (#if, #elif, #else et #endif (C++))
• IInterface (interface)
  • dérivation des interfaces (Implémentation de IInterface)
• ILINK32.EXE (ILINK32.EXE, le lieur incrémentiel 32 bits)
• 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)
• _Imaginary
  • mots clés, C++ (_Imaginary)
• imbrication (Macros avec paramètres (C++))
• 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 pour Win32)
• __import
  • mots clés, C++ (_import, __import)
• __import
  • mots clés, C++ (_import, __import)
• #import (#import)
• #import (#import)
• #include (#include)
• #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 de blocs finally)
• int
  • mots clés, C++ (int)
• __int8, __int16, and so forth
  • éléments lexicaux, C++ (Types entiers étendus : __int8, __int16, __int32, __int64)
• __int8, __int16, et ainsi de suite
  • éléments lexicaux, C++ (Types entiers étendus : __int8, __int16, __int32, __int64)
• 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 (Assignation des relations 'Interface fournie' ou 'Interface requise' - UML 2.0)
• Interfaces COM
  • Interfaces (Interfaces COM)
  • IUnknown (L'interface COM de base, IUnknown)
  • pointeurs (Pointeurs d'interface COM)
• interfaces d'objets
  • interfaces (Interfaces d'objets (Delphi))
• 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)
• 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)
• interface utilisateur
  • développement (Développement de l'interface utilisateur des applications - Présentation)
• Internationalisation (Internationalisation des applications)
• IntraWeb
  • VCL pour le Web (Changement du type d'application IntraWeb)
  • 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)
• Introduction à IntraWeb
  • VCL pour le Web (Introduction à IntraWeb)
• invariant d'état
  • connexion (Création d'un invariant d'état - UML 2.0)
• _itow, itoa (itoa, _itow)
• _itow, itoa (itoa, _itow)

J

• jeu de caractères (Delphi)
  • mots réservés (Eléments syntaxiques fondamentaux (Delphi))
• 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

• 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)
• #line (#line)
• 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)
• 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)
• _lrotr, _lrotl (_lrotl, _lrotr)
• _lrotr, _lrotl (_lrotl, _lrotr)
• _ltoa, _ltow, ltoa (ltoa, _ltoa, _ltow)
• _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.EXE)
• Mappage TCHAR
• 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)
• _mbslen, strlen, wcslen, _mbstrlen (strlen, _mbslen, wcslen, _mbstrlen)
• _mbsnbcat
  • strncat
• _mbsncat
  • strncat
• 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 (C++))
• 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énement 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)
  • 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 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 (Appel de méthodes)
  • classes et objets (Méthodes (Delphi))
  • 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 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 (Edition 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 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 (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'applications)
  • placement des composants (Placer et nommer les composants)
  • présentation (Utilisation des modules de données)
  • règles d'entreprise (Création de règles de gestion dans un module de données)
• modules de fusion
  • packages (Modules de fusion)
• 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 (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
  • structure du langage C++ (Spécificateurs de type)
• 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++)
• MSBuild (Présentation de MSBuild)
• __msfastcall
  • mots clés, C++ (__msfastcall)
• __msfastcall
  • mots clés, C++ (__msfastcall)
• __msreturn
  • mots clés, C++ (__msreturn)
• __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 diagramme)
• 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,! (C++))
• 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 seulement))
• objets champ
  • champs (Manipulation des composants champ - Présentation)
  • 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 (Object Constraint Language))
• OnPopup (événement)
  • gestion (Gestion de l'événement OnPopup)
• * 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 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++ (Opérateurs conditionnels)
• opérateur .
  • opérateurs, C++ (Sélecteur de membre direct (.))
• 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 plus et moins)
• opérateur ++
  • opérateurs, C++ (Opérateurs d'incrémentation/décrémentation)
• 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 avec les tableaux)
  • spécificités du langage C++ (Opérateur new (C++))
  • 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++ (Résumé des opérateurs binaires (C++))
• 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 (C++))
• 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 = (C++))
  • 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 binaires)
  • surcharge des opérateurs, C++ (Surcharge des opérateurs (C++))
  • 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)
• [ ] operator
  • opérateurs, C++ (Opérateur d'accès à un tableau)
• option de compilation -D (Utilisation des options de ligne de commande -D et -U)
• 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 (Delphi))
• 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 (Gestionnaire de traductions dans l'EDI)
  • 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 (Delphi))
  • conception (Packages de conception)
  • création (Création d'un package)
  • définis à l'exécution (Packages d'exécution)
  • déploiement (Déploiement des packages)
  • déploiement (Fichiers package)
  • directives du compilateur (Directives de compilation spécifiques aux packages)
  • et les DLL (Packages et 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 - Présentation)
  • packaging faible (Utilisation de la directive de packaging faible)
  • personnalisés (Packages personnalisés)
  • Pourquoi les utiliser ? (Pourquoi utiliser des packages ?)
  • quand les utiliser (Utilisation des packages et des DLLs)
  • 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 - Présentation)
• 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 - Présentation)
• 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 (Options de l'application)
• partage de code entre plusieurs gestionnaires d'événements (Partage de code entre plusieurs gestionnaires d'événement)
• pascal
  • mots clés, C++ (pascal, _pascal, __pascal (C++))
• 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 alignment (#pragma alignment)
• #pragma alignment (#pragma alignment)
• #pragma argsused (#pragma argsused)
• #pragma argsused (#pragma argsused)
• #pragma checkoption (#pragma checkoption)
• #pragma checkoption (#pragma checkoption)
• #pragma codeseg (#pragma codeseg)
• #pragma codeseg (#pragma codeseg)
• #pragma comment, pragma (#pragma comment)
• #pragma comments, pragma (#pragma comment)
• #pragma defineonoption (#pragma defineonoption et #pragma undefineonoption)
• #pragma defineonoption (#pragma defineonoption et #pragma undefineonoption)
• #pragma exit (#pragma exit et #pragma startup)
• #pragma exit (#pragma exit et #pragma startup)
• #pragma hdrfile (#pragma hdrfile)
• #pragma hdrfile (#pragma hdrfile)
• #pragma hdrstop (#pragma hdrstop)
• #pragma hdrstop (#pragma hdrstop)
• #pragma inline (#pragma inline)
• #pragma inline (#pragma inline)
• #pragma intrinsic (#pragma intrinsic)
• #pragma intrinsic (#pragma intrinsic)
• #pragma link (#pragma link)
• #pragma link (#pragma link)
• #pragma message (#pragma message)
• #pragma message (#pragma message)
• #pragma nopushoptwarn (#pragma nopushoptwarn)
• #pragma nopushoptwarn (#pragma nopushoptwarn)
• #pragma obsolete (#pragma obsolete)
• #pragma obsolete (#pragma obsolete)
• #pragma option (#pragma option)
• #pragma option (#pragma option)
• #pragma package (#pragma package)
• #pragma package (#pragma package)
• #pragma pack (#pragma pack)
• #pragma pack (#pragma pack)
• #pragma (#pragma)
• #pragma (#pragma)
• #pragma region (#pragma region et #pragma end_region)
• #pragma region (#pragma region et #pragma end_region)
• #pragma resource (#pragma resource)
• #pragma resource (#pragma resource)
• #pragma warn (#pragma warn)
• #pragma warn (#pragma warn)
• Présentation du langage Delphi (Présentation du langage)
• priorité
  • opérateurs, C++ (Priorité des opérateurs)
• 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 (Définition 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énement)
  • 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 (C++))
• 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)
• 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 - Présentation)
• 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 (Delphi))
  • é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 (Définition des propriétés à l'exécution)
  • initialisation (Définition 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 (C++))
• 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 (C++))
• published
  • mots clés, C++ (__published (C++))

R

• raccourci
  • create (Création de raccourcis)
• raccourcis
  • autre (Modélisation - Raccourcis clavier)
• raccourci vers un classificateur
  • création (Association d'un objet à un classificateur - UML 1.5)
• rafraîchissement de l'écran (Rafraîchissement de l'écran)
• 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 (Delphi))
  • rechercher le symbole de déclaration (Présentation de la recherche de références (Delphi))
• 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 (Aperçu et application des opérations de refactoring)
  • procédures (Refactoring du code)
• Référencement (C++)
  • Références lvalue (C++)
  • Références rvalue (C++0x)
• références de classe
  • classes et objets (Références de classes)
• références d'interfaces
  • interfaces (Références d'interfaces (Delphi))
• Référentiel d'objets
  • Référentiel (Ajout d'éléments au référentiel d'objets)
  • 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 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 (C++))
• 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 (C++))
• résolution
  • influencer le SQL généré (Comment contrôler l'application des mises à jour)
• ressource DLL
  • localisation (Création de DLL 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)
• _rotr, _rotl (_rotl, _rotr)
• routines de caractères étendus (Routines manipulant les caractères étendus)
• routines de gestion 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 couramment utilisées pour les AnsiStrings)
• routines globales
  • objets utilitaires (Utilisation de la RTL (bibliothèque d'exécution))
• Routines standard
  • unité System (Routines standard et entrées-sorties)
• __rtti
  • spécificités du langage C++ (__rtti et option -RT)
• RTTI
  • spécificités du langage C++ (Identification de type à l'exécution (RTTI))
• __rtti
  • spécificités du langage C++ (__rtti et option -RT)

S

• safecall
  • événements (Ajout des événements)
  • propriétés (Ajout 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
  • création (Création de l'application serveur)
  • 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 - UML 2.0)
• 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 (C++))
• static_assert
  • mots clés, C++ (static_assert)
• static_cast (opérateur de transtypage)
  • transtypage, C++ (static_cast (opérateur de transtypage C++))
• _stdcall
  • mots clés, C++ (_stdcall, __stdcall (C++))
• _stdcall
  • mots clés, C++ (_stdcall, __stdcall (C++))
• 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 (Delphi))
• 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 (Syntaxe assembleur)
• 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 de système d'aide)
  • IHelpSystem (Utilisation de IHelpSystem)
  • pages Man (Activation de l'aide dans les applications)
  • pages Man (Implémentation de ICustomHelpViewer)
  • 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 système 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 (C++))
• Tableaux sécurisés (Tableaux sécurisés)
• tables
  • accès exclusif (Contrôle des accès en lecture ou en écriture aux tables locales)
  • création (Création et suppression des tables)
  • droits d'accès (Contrôle des accès en lecture ou en é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 (C++))
• 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 (Conception 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++ (Présentation des tokens - Index)
• Tools API
  • création de modules (Création d'experts fiches et projets)
  • extension de l'EDI(Tools API) (Extension de l'EDI par l'utilisation de l'API Tools)
  • 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)
• ToolsAPI
  • Extension de l'EDI (ToolsAPI) (Extension de l'EDI par l'utilisation de l'API Tools)
• TOUCH.EXE (TOUCH.EXE)
• TPrinter
  • présentation (Impression dans les applications VCL)
• 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 (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)
• __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înes)
  • types de données (Types chaîne (Delphi))
• Types de données
  • scalaire et réel (Types simples (Delphi))
• types de données, variables et constantes (A propos des types de données (Delphi))
• 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 (Delphi))
• types procédure
  • types de données (Types procéduraux (Delphi))
• types structurés
  • types de données (Types structurés (Delphi))
• types variants
  • types de données (Types variants (Delphi))

U

• _ui64tow, _ui64toa (_ui64toa, _ui64tow)
• _ui64tow, _ui64toa (_ui64toa, _ui64tow)
• _ultow, ultoa (ultoa, _ultow)
• _ultow, ultoa (ultoa, _ultow)
• UML en couleurs
  • utilisation (Utilisation du profil UML en couleur)
• UML (Spécifications UML supportées)
• #undef (#undef)
• #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)
• 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_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 (Delphi))
• 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)
• 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 de la bibliothèque de composants)
  • composants (Présentation de la VCL)
• VCL pour le Web
  • IntraWeb (Création d'une nouvelle application IntraWeb)
• 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é)
• void
  • mots clés, C++ (void)
• volatile
  • mots clés, C++ (volatile)
• volets (Volets)
• Vue Diagramme
  • ouverture (Navigation entre la vue Modèle, la vue Diagramme et le code source)
• Vue Messages (Vue Messages)
• vues arborescentes (Vues arborescentes)
• vues listes (Vues liste)

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' est implicitement importée 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))
• W1061 La réduction de la constante WideChar donnée en AnsiChar génère une perte d'information (H2451 et W1061 La réduction de la constante WideChar donnée en AnsiChar génère une perte d'information (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))
• _wargv, _argv
  • _argv (_argv, _wargv)
• _wargv, _argv
  • _argv (_argv, _wargv)
• wchar_t
  • mots clés, C++ (wchar_t)
• _wcsmpi
  • strcmpi, _wcscmpi
• _wcstod, wcstod (strtod, _strtold, wcstod, _wcstold)
• _wcstod, wcstod (strtod, _strtold, wcstod, _wcstold)
• wcstol, strtol (strtol, wcstol)
• wcstoul (strtoul, wcstoul)
• _wenviron, _environ (_environ, _wenviron)
• _wenviron, _environ (_environ, _wenviron)
• _wgetenv, getenv (getenv, _wgetenv)
• _wgetenv, getenv (getenv, _wgetenv)
• while
  • mots clés, C++ (while (C++))
• 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)
• _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)
• _wsearchenv,, _searchenv (_searchenv, _wsearchenv)
• _wsearchstr, _searchstr (_searchstr, _wsearchstr)
• _wsearchstr, _searchstr (_searchstr, _wsearchstr)
• _wsetlocale
  • setlocale, _wsetlocale
• _wsplitpath, _splitpath (_splitpath, _wsplitpath)
• _wsplitpath, _splitpath (_splitpath, _wsplitpath)
• _wsystem, system (system, _wsystem)
• _wsystem, system (system, _wsystem)
• _wtoi64, _atoi64 (_atoi64, _wtoi64)
• _wtoi64, _atoi64 (_atoi64, _wtoi64)
• _wtoi, atoi
  • routine de conversion (atoi, _wtoi)
• _wtoi, atoi
  • routine de conversion (atoi, _wtoi)
• _wtol, atol (atol, _wtol)
• _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, ^(C++))
• xor_eq
  • représentations alternatives des tokens C++ (xor_eq, ^=)